From 53701c2dabdc5063dad1a5f866d9e34a2a575d67 Mon Sep 17 00:00:00 2001 From: fretuks Date: Sat, 19 Sep 2026 20:49:04 +0200 Subject: [PATCH] Add new advancements, weapon scaling tooltips, passive agility API, and attribute scaling logic --- CHANGELOG.md | 6 + gradle.properties | 4 +- .../advancement/AscendAdvancements.java | 99 +++++++++++++ .../fretux/ascend/api/PassiveAgilityApi.java | 40 ++++++ .../api/event/ArmorPenetrationEvent.java | 62 ++++++++ .../ascend/api/event/PassiveAgilityEvent.java | 37 +++++ .../ascend/client/ClientPacketHandlers.java | 29 ++++ .../ascend/client/WeaponScalingTooltips.java | 34 +++++ .../ascend/client/screen/StatsScreen.java | 89 +++++++----- .../ascend/event/ArcaneEffectEvents.java | 50 +++++++ .../ascend/event/WeaponScalingEvents.java | 136 ++++++++++++++++++ .../ascend/player/AttributeScaling.java | 56 ++++++++ .../fretux/ascend/scaling/ScalingGrade.java | 24 ++++ .../fretux/ascend/scaling/WeaponScaling.java | 15 ++ .../ascend/scaling/WeaponScalingRegistry.java | 111 ++++++++++++++ src/main/resources/META-INF/mods.toml | 2 - .../resources/assets/ascend/lang/en_us.json | 8 +- .../models/enemy/junk_iron_colossus.bbmodel | 1 + .../advancements/big_brain_small_helmet.json | 10 ++ .../ascend/advancements/bonk_scholar.json | 10 ++ .../cannot_hit_what_you_cannot_see.json | 10 ++ .../ascend/advancements/config_enjoyer.json | 10 ++ .../advancements/definition_of_insanity.json | 10 ++ .../data/ascend/advancements/first_steps.json | 13 ++ .../advancements/game_journalist_mode.json | 10 ++ .../advancements/health_bar_enthusiast.json | 10 ++ .../advancements/indecisive_chosen_one.json | 10 ++ .../ascend/advancements/knowledge_100.json | 13 ++ .../data/ascend/advancements/level_10.json | 13 ++ .../data/ascend/advancements/level_5.json | 13 ++ .../advancements/mana_without_purpose.json | 10 ++ .../ascend/advancements/max_attribute.json | 14 ++ .../data/ascend/advancements/max_level.json | 14 ++ .../advancements/perfectly_balanced.json | 10 ++ .../advancements/read_moonseye_tome.json | 13 ++ .../ascend/advancements/talk_no_jutsu.json | 10 ++ .../advancements/unlicensed_therapist.json | 10 ++ .../data/ascend/advancements/use_shrine.json | 13 ++ .../data/ascend/weapon_scaling/vanilla.json | 38 +++++ 39 files changed, 1024 insertions(+), 43 deletions(-) create mode 100644 src/main/java/net/fretux/ascend/advancement/AscendAdvancements.java create mode 100644 src/main/java/net/fretux/ascend/api/PassiveAgilityApi.java create mode 100644 src/main/java/net/fretux/ascend/api/event/ArmorPenetrationEvent.java create mode 100644 src/main/java/net/fretux/ascend/api/event/PassiveAgilityEvent.java create mode 100644 src/main/java/net/fretux/ascend/client/ClientPacketHandlers.java create mode 100644 src/main/java/net/fretux/ascend/client/WeaponScalingTooltips.java create mode 100644 src/main/java/net/fretux/ascend/event/ArcaneEffectEvents.java create mode 100644 src/main/java/net/fretux/ascend/event/WeaponScalingEvents.java create mode 100644 src/main/java/net/fretux/ascend/player/AttributeScaling.java create mode 100644 src/main/java/net/fretux/ascend/scaling/ScalingGrade.java create mode 100644 src/main/java/net/fretux/ascend/scaling/WeaponScaling.java create mode 100644 src/main/java/net/fretux/ascend/scaling/WeaponScalingRegistry.java create mode 100644 src/main/resources/assets/ascend/models/enemy/junk_iron_colossus.bbmodel create mode 100644 src/main/resources/data/ascend/advancements/big_brain_small_helmet.json create mode 100644 src/main/resources/data/ascend/advancements/bonk_scholar.json create mode 100644 src/main/resources/data/ascend/advancements/cannot_hit_what_you_cannot_see.json create mode 100644 src/main/resources/data/ascend/advancements/config_enjoyer.json create mode 100644 src/main/resources/data/ascend/advancements/definition_of_insanity.json create mode 100644 src/main/resources/data/ascend/advancements/first_steps.json create mode 100644 src/main/resources/data/ascend/advancements/game_journalist_mode.json create mode 100644 src/main/resources/data/ascend/advancements/health_bar_enthusiast.json create mode 100644 src/main/resources/data/ascend/advancements/indecisive_chosen_one.json create mode 100644 src/main/resources/data/ascend/advancements/knowledge_100.json create mode 100644 src/main/resources/data/ascend/advancements/level_10.json create mode 100644 src/main/resources/data/ascend/advancements/level_5.json create mode 100644 src/main/resources/data/ascend/advancements/mana_without_purpose.json create mode 100644 src/main/resources/data/ascend/advancements/max_attribute.json create mode 100644 src/main/resources/data/ascend/advancements/max_level.json create mode 100644 src/main/resources/data/ascend/advancements/perfectly_balanced.json create mode 100644 src/main/resources/data/ascend/advancements/read_moonseye_tome.json create mode 100644 src/main/resources/data/ascend/advancements/talk_no_jutsu.json create mode 100644 src/main/resources/data/ascend/advancements/unlicensed_therapist.json create mode 100644 src/main/resources/data/ascend/advancements/use_shrine.json create mode 100644 src/main/resources/data/ascend/weapon_scaling/vanilla.json diff --git a/CHANGELOG.md b/CHANGELOG.md index 24f9a6d..8e42542 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,12 @@ This changelog covers all recorded changes after `1.0.0`, grouped by release version from the git history. +## 3.1.1 + +- Refined the Stats screen with charcoal and iron surfaces, consistent neutral attribute cards, and a shared muted accent instead of screen-only attribute colors. +- Reserved gold for level and XP progression and green for available points, with an aligned progression header and a separate XP bar and label. +- Added distinct 12-pixel attribute icons and stronger name/description contrast while retaining the two-column layout, native Minecraft buttons, and darkened world backdrop. + ## 3.1.0 - Added a public passive Agility event API so integrations such as skill-tree mods can contribute additional Agility points per player. diff --git a/gradle.properties b/gradle.properties index 57053a7..6f1839b 100644 --- a/gradle.properties +++ b/gradle.properties @@ -23,7 +23,7 @@ loader_version_range=[47,) # Additional mapping channels can be registered through the "channelProviders" extension in a Gradle plugin. # mindmotion_version=1.4.5 -skillengine_version=1.4.5 +skillengine_version=1.4.14 irons_spells_version=1.20.1-3.16.2 irons_spells_file_id=8364933 caelus_version=3.2.0+1.20.1 @@ -56,7 +56,7 @@ mod_name=Ascend: SbA # The license of the mod. Review your options at https://choosealicense.com/. All Rights Reserved is the default. mod_license=All Rights Reserved # The mod version. See https://semver.org/ -mod_version=3.1.0 +mod_version=3.1.1 # The group ID for the mod. It is only important when publishing as an artifact to a Maven repository. # This should match the base package used for the mod sources. # See https://maven.apache.org/guides/mini/guide-naming-conventions.html diff --git a/src/main/java/net/fretux/ascend/advancement/AscendAdvancements.java b/src/main/java/net/fretux/ascend/advancement/AscendAdvancements.java new file mode 100644 index 0000000..fdbdf51 --- /dev/null +++ b/src/main/java/net/fretux/ascend/advancement/AscendAdvancements.java @@ -0,0 +1,99 @@ +package net.fretux.ascend.advancement; + +import net.fretux.ascend.AscendMod; +import net.fretux.ascend.config.AscendConfig; +import net.fretux.ascend.player.PlayerStats; +import net.minecraft.advancements.Advancement; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.server.level.ServerPlayer; + +/** Awards Ascend's state-based advancements from server-authoritative player stats. */ +public final class AscendAdvancements { + private static final String CRITERION = "achieved"; + + private AscendAdvancements() { + } + + public static void checkMilestones(ServerPlayer player, PlayerStats stats) { + int level = stats.getAscendLevel(); + if (level >= 2) grant(player, "first_steps"); + if (level >= 5) grant(player, "level_5"); + if (level >= 10) grant(player, "level_10"); + if (level >= stats.getMaxAscendLevel()) grant(player, "max_level"); + if (stats.getKnowledge() >= 100) grant(player, "knowledge_100"); + if (stats.hasUsedMoonseye()) grant(player, "read_moonseye_tome"); + + for (String attribute : PlayerStats.ATTRIBUTE_KEYS) { + if (stats.getAttributeLevel(attribute) >= stats.getMaxAttributePoints()) { + grant(player, "max_attribute"); + break; + } + } + + int vigor = stats.getAttributeLevel("vigor"); + int mind = stats.getAttributeLevel("mind"); + int strength = stats.getAttributeLevel("strength"); + int agility = stats.getAttributeLevel("agility"); + int intelligence = stats.getAttributeLevel("intelligence"); + int willpower = stats.getAttributeLevel("willpower"); + int charisma = stats.getAttributeLevel("charisma"); + int arcane = stats.getAttributeLevel("arcane"); + + if (strength >= 100) grant(player, "bonk_scholar"); + if (agility >= 100) grant(player, "cannot_hit_what_you_cannot_see"); + if (vigor >= 100) grant(player, "health_bar_enthusiast"); + if (intelligence >= 100) grant(player, "big_brain_small_helmet"); + if (mind >= 100) grant(player, "mana_without_purpose"); + if (willpower >= 100) grant(player, "unlicensed_therapist"); + if (charisma >= 100) grant(player, "talk_no_jutsu"); + if (vigor > 0 && vigor == mind && vigor == strength && vigor == agility + && vigor == intelligence && vigor == willpower && vigor == charisma && vigor == arcane) { + grant(player, "perfectly_balanced"); + } + if (stats.getRespecCount() >= 10) grant(player, "indecisive_chosen_one"); + if (hasUnrecognizableProgressionConfig()) grant(player, "config_enjoyer"); + if (hasExtremeXpConfig()) grant(player, "game_journalist_mode"); + if (stats.hasNearlyRestoredLastBuild()) grant(player, "definition_of_insanity"); + } + + private static boolean hasUnrecognizableProgressionConfig() { + int changed = 0; + if (AscendConfig.COMMON.xpPerMobKill.get() != 10) changed++; + if (AscendConfig.COMMON.xpPerBlockBreak.get() != 2) changed++; + if (AscendConfig.COMMON.xpPerCraft.get() != 1) changed++; + if (AscendConfig.COMMON.xpPerSmelt.get() != 1) changed++; + if (AscendConfig.COMMON.xpPerTrade.get() != 5) changed++; + if (AscendConfig.COMMON.xpPerDamageTaken.get() != 2) changed++; + if (AscendConfig.COMMON.xpPerMovement.get() != 1) changed++; + if (AscendConfig.COMMON.xpPerPotion.get() != 3) changed++; + if (AscendConfig.COMMON.pointsPerLevel.get() != 15) changed++; + if (AscendConfig.COMMON.maxAscendLevel.get() != 20) changed++; + if (AscendConfig.COMMON.maxAttributePoints.get() != 100) changed++; + if (Double.compare(AscendConfig.COMMON.xpMultiplier.get(), 1.0D) != 0) changed++; + if (Double.compare(AscendConfig.COMMON.attributeScalingMultiplier.get(), 1.0D) != 0) changed++; + return changed >= 6; + } + + private static boolean hasExtremeXpConfig() { + if (AscendConfig.COMMON.xpMultiplier.get() >= 25.0D) return true; + int extremeSources = 0; + if (AscendConfig.COMMON.xpPerMobKill.get() >= 250) extremeSources++; + if (AscendConfig.COMMON.xpPerBlockBreak.get() >= 250) extremeSources++; + if (AscendConfig.COMMON.xpPerCraft.get() >= 250) extremeSources++; + if (AscendConfig.COMMON.xpPerSmelt.get() >= 250) extremeSources++; + if (AscendConfig.COMMON.xpPerTrade.get() >= 250) extremeSources++; + if (AscendConfig.COMMON.xpPerDamageTaken.get() >= 250) extremeSources++; + if (AscendConfig.COMMON.xpPerMovement.get() >= 250) extremeSources++; + if (AscendConfig.COMMON.xpPerPotion.get() >= 250) extremeSources++; + return extremeSources >= 4; + } + + public static void grant(ServerPlayer player, String advancementPath) { + Advancement advancement = player.server.getAdvancements().getAdvancement( + ResourceLocation.fromNamespaceAndPath(AscendMod.MODID, advancementPath) + ); + if (advancement != null) { + player.getAdvancements().award(advancement, CRITERION); + } + } +} diff --git a/src/main/java/net/fretux/ascend/api/PassiveAgilityApi.java b/src/main/java/net/fretux/ascend/api/PassiveAgilityApi.java new file mode 100644 index 0000000..06e0f2e --- /dev/null +++ b/src/main/java/net/fretux/ascend/api/PassiveAgilityApi.java @@ -0,0 +1,40 @@ +package net.fretux.ascend.api; + +import net.fretux.ascend.api.event.PassiveAgilityEvent; +import net.fretux.ascend.player.AttributeScaling; +import net.fretux.ascend.player.PlayerStatsProvider; +import net.fretux.ascend.player.StatEffects; +import net.minecraft.world.entity.player.Player; +import net.minecraftforge.common.MinecraftForge; + +/** Public entry point for Ascend's passive Agility integration. */ +public final class PassiveAgilityApi { + private PassiveAgilityApi() {} + + /** Collects all passive Agility contributions registered for this player. */ + public static int getPassiveAgility(Player player, int investedAgility) { + PassiveAgilityEvent event = new PassiveAgilityEvent(player, investedAgility); + MinecraftForge.EVENT_BUS.post(event); + return event.getPassiveAgility(); + } + + /** Returns invested and passive Agility, saturating safely at the integer limit. */ + public static int getTotalAgility(Player player, int investedAgility) { + long total = (long) Math.max(0, investedAgility) + getPassiveAgility(player, investedAgility); + return (int) Math.min(Integer.MAX_VALUE, total); + } + + /** + * Returns Agility normalized against the normal investment cap. Values may + * exceed {@code 1.0} when integrations supply passive points above that cap. + */ + public static double getNormalizedAgility(Player player, int investedAgility) { + return AttributeScaling.getExtendedNormalizedAttributeValue(getTotalAgility(player, investedAgility)); + } + + /** Recalculates the player's movement-speed modifier after passive Agility changes. */ + public static void refresh(Player player) { + player.getCapability(PlayerStatsProvider.PLAYER_STATS).ifPresent(stats -> + StatEffects.applyAgility(player, stats.getAttributeLevel("agility"))); + } +} diff --git a/src/main/java/net/fretux/ascend/api/event/ArmorPenetrationEvent.java b/src/main/java/net/fretux/ascend/api/event/ArmorPenetrationEvent.java new file mode 100644 index 0000000..b821a0f --- /dev/null +++ b/src/main/java/net/fretux/ascend/api/event/ArmorPenetrationEvent.java @@ -0,0 +1,62 @@ +package net.fretux.ascend.api.event; + +import net.minecraft.world.damagesource.DamageSource; +import net.minecraft.world.entity.LivingEntity; +import net.minecraft.world.entity.player.Player; +import net.minecraft.world.item.ItemStack; +import net.minecraftforge.eventbus.api.Event; + +/** + * Fired before Ascend applies armor penetration to a player attack. + * Integrations may add penetration, change the cap, or disable the cap for + * this hit. Values use fractions: {@code 0.10} ignores ten percent of armor. + */ +public final class ArmorPenetrationEvent extends Event { + private final Player attacker; + private final LivingEntity target; + private final DamageSource damageSource; + private final ItemStack weapon; + private double armorPenetration; + private double cap; + private boolean capEnabled = true; + + public ArmorPenetrationEvent(Player attacker, LivingEntity target, DamageSource damageSource, + ItemStack weapon, double armorPenetration, double cap) { + this.attacker = attacker; + this.target = target; + this.damageSource = damageSource; + this.weapon = weapon.copy(); + this.armorPenetration = armorPenetration; + this.cap = cap; + } + + public Player getAttacker() { return attacker; } + public LivingEntity getTarget() { return target; } + public DamageSource getDamageSource() { return damageSource; } + public ItemStack getWeapon() { return weapon.copy(); } + public double getArmorPenetration() { return armorPenetration; } + public double getCap() { return cap; } + public boolean isCapEnabled() { return capEnabled; } + + public void setArmorPenetration(double armorPenetration) { this.armorPenetration = finiteOrZero(armorPenetration); } + public void addArmorPenetration(double armorPenetration) { + setArmorPenetration(this.armorPenetration + finiteOrZero(armorPenetration)); + } + public void setCap(double cap) { this.cap = finiteOrZero(cap); } + public void setCapEnabled(boolean capEnabled) { this.capEnabled = capEnabled; } + public void disableCap() { this.capEnabled = false; } + + /** Returns the fraction of armor ignored after applying the requested cap. */ + public double getEffectiveArmorPenetration() { + return calculateEffectiveArmorPenetration(armorPenetration, cap, capEnabled); + } + + /** Pure helper for integrations that need to preview Ascend's cap behavior. */ + public static double calculateEffectiveArmorPenetration(double armorPenetration, double cap, boolean capEnabled) { + double maximum = capEnabled ? clamp(cap) : 1.0; + return Math.min(clamp(armorPenetration), maximum); + } + + private static double clamp(double value) { return Math.max(0.0, Math.min(1.0, finiteOrZero(value))); } + private static double finiteOrZero(double value) { return Double.isFinite(value) ? value : 0.0; } +} diff --git a/src/main/java/net/fretux/ascend/api/event/PassiveAgilityEvent.java b/src/main/java/net/fretux/ascend/api/event/PassiveAgilityEvent.java new file mode 100644 index 0000000..292453c --- /dev/null +++ b/src/main/java/net/fretux/ascend/api/event/PassiveAgilityEvent.java @@ -0,0 +1,37 @@ +package net.fretux.ascend.api.event; + +import net.minecraft.world.entity.player.Player; +import net.minecraftforge.eventbus.api.Event; + +/** + * Fired whenever Ascend calculates a player's Agility effects. + * + *

Integrations may add passive points from skill trees, equipment, or other + * progression systems. Contributions from multiple listeners are additive. + * Passive points are applied after the normal investment cap, but still use + * Ascend's configured diminishing-return curve.

+ */ +public final class PassiveAgilityEvent extends Event { + private final Player player; + private final int investedAgility; + private int passiveAgility; + + public PassiveAgilityEvent(Player player, int investedAgility) { + this.player = player; + this.investedAgility = Math.max(0, investedAgility); + } + + public Player getPlayer() { return player; } + public int getInvestedAgility() { return investedAgility; } + public int getPassiveAgility() { return passiveAgility; } + + public void setPassiveAgility(int passiveAgility) { + this.passiveAgility = Math.max(0, passiveAgility); + } + + public void addPassiveAgility(int passiveAgility) { + if (passiveAgility <= 0) return; + long combined = (long) this.passiveAgility + passiveAgility; + this.passiveAgility = (int) Math.min(Integer.MAX_VALUE, combined); + } +} diff --git a/src/main/java/net/fretux/ascend/client/ClientPacketHandlers.java b/src/main/java/net/fretux/ascend/client/ClientPacketHandlers.java new file mode 100644 index 0000000..796b0d3 --- /dev/null +++ b/src/main/java/net/fretux/ascend/client/ClientPacketHandlers.java @@ -0,0 +1,29 @@ +package net.fretux.ascend.client; + +import net.fretux.ascend.client.screen.ShrineScreen; +import net.fretux.ascend.player.PlayerStatsProvider; +import net.fretux.ascend.player.StatEffects; +import net.minecraft.client.Minecraft; +import net.minecraft.nbt.CompoundTag; + +public final class ClientPacketHandlers { + private ClientPacketHandlers() { + } + + public static void openShrineScreen(boolean essenceMode) { + Minecraft.getInstance().setScreen(new ShrineScreen(essenceMode)); + } + + public static void syncStats(CompoundTag data) { + Minecraft mc = Minecraft.getInstance(); + var player = mc.player; + if (player == null) { + return; + } + + player.getCapability(PlayerStatsProvider.PLAYER_STATS).ifPresent(stats -> { + stats.deserializeNBT(data); + StatEffects.applyAll(player); + }); + } +} diff --git a/src/main/java/net/fretux/ascend/client/WeaponScalingTooltips.java b/src/main/java/net/fretux/ascend/client/WeaponScalingTooltips.java new file mode 100644 index 0000000..b6791fc --- /dev/null +++ b/src/main/java/net/fretux/ascend/client/WeaponScalingTooltips.java @@ -0,0 +1,34 @@ +package net.fretux.ascend.client; + +import net.fretux.ascend.AscendMod; +import net.fretux.ascend.scaling.ScalingGrade; +import net.fretux.ascend.scaling.WeaponScaling; +import net.fretux.ascend.scaling.WeaponScalingRegistry; +import net.minecraft.ChatFormatting; +import net.minecraft.network.chat.Component; +import net.minecraftforge.api.distmarker.Dist; +import net.minecraftforge.event.entity.player.ItemTooltipEvent; +import net.minecraftforge.eventbus.api.SubscribeEvent; +import net.minecraftforge.fml.common.Mod; + +import java.util.ArrayList; +import java.util.List; + +@Mod.EventBusSubscriber(modid = AscendMod.MODID, value = Dist.CLIENT) +public final class WeaponScalingTooltips { + @SubscribeEvent + public static void addScalingTooltip(ItemTooltipEvent event) { + WeaponScaling scaling = WeaponScalingRegistry.get(event.getItemStack().getItem()); + if (scaling == null) return; + List grades = new ArrayList<>(); + for (String attribute : WeaponScaling.SUPPORTED_ATTRIBUTES) { + ScalingGrade grade = scaling.grade(attribute); + if (grade != ScalingGrade.NONE) grades.add(Component.translatable("ascend.weapon_scaling.grade", + Component.translatable("ascend.attribute." + attribute), grade.name())); + } + if (!grades.isEmpty()) { + event.getToolTip().add(Component.translatable("ascend.weapon_scaling.title").withStyle(ChatFormatting.DARK_GRAY)); + grades.forEach(line -> event.getToolTip().add(line.copy().withStyle(ChatFormatting.GRAY))); + } + } +} diff --git a/src/main/java/net/fretux/ascend/client/screen/StatsScreen.java b/src/main/java/net/fretux/ascend/client/screen/StatsScreen.java index 233e643..8b19178 100644 --- a/src/main/java/net/fretux/ascend/client/screen/StatsScreen.java +++ b/src/main/java/net/fretux/ascend/client/screen/StatsScreen.java @@ -15,27 +15,37 @@ import java.util.Map; public class StatsScreen extends Screen { private static final int WIDTH = 480; - private static final int HEIGHT = 266; + private static final int HEIGHT = 280; private static final int PADDING = 12; private static final int COLUMN_GAP = 8; private static final int CARD_GAP = 4; private static final int CARD_HEIGHT = 40; - private static final int CARDS_TOP = 64; + private static final int CARDS_TOP = 78; private static final int CARD_WIDTH = (WIDTH - PADDING * 2 - COLUMN_GAP) / 2; + private static final int BACKGROUND = 0xFF121316; + private static final int PANEL = 0xFF1C1E22; + private static final int CARD = 0xFF25272D; + private static final int BORDER = 0xFF45484F; + private static final int PRIMARY_TEXT = 0xFFE4E4E4; + private static final int SECONDARY_TEXT = 0xFF999DA5; + private static final int ACCENT = 0xFFAAB6C2; + private static final int PROGRESS = 0xFFD1A744; + private static final int AVAILABLE = 0xFF6EAE67; private static final String[] ATTRIBUTES = { "vigor", "mind", "strength", "agility", "intelligence", "willpower", "charisma", "arcane" }; - private static final Map ATTRIBUTE_COLORS = Map.of( - "vigor", 0xFFD85C5C, - "mind", 0xFF6699E8, - "strength", 0xFFD78445, - "agility", 0xFF71C988, - "intelligence", 0xFF9A7BE8, - "willpower", 0xFF79B9C8, - "charisma", 0xFFE28AB8, - "arcane", 0xFFC878E0 + // Twelve-pixel glyphs: heart, orb, sword, boot, book, eye, speech, rune. + private static final Map ATTRIBUTE_ICONS = Map.of( + "vigor", new int[]{0x000, 0x318, 0x7BC, 0xFFE, 0xFFE, 0xFFE, 0x7FC, 0x3F8, 0x1F0, 0x0E0, 0x040, 0x000}, + "mind", new int[]{0x000, 0x0F0, 0x30C, 0x402, 0x4C2, 0x482, 0x402, 0x402, 0x30C, 0x0F0, 0x000, 0x000}, + "strength", new int[]{0x060, 0x0F0, 0x0F0, 0x0F0, 0x0F0, 0x0F0, 0x264, 0x3FC, 0x060, 0x060, 0x0F0, 0x000}, + "agility", new int[]{0x000, 0x3C0, 0x240, 0x240, 0x3C0, 0x240, 0x27C, 0x202, 0x202, 0x3FE, 0x000, 0x000}, + "intelligence", new int[]{0x000, 0x7BC, 0xC46, 0x842, 0xB5A, 0x842, 0xB5A, 0x842, 0xC46, 0x7BC, 0x040, 0x000}, + "willpower", new int[]{0x000, 0x000, 0x0F0, 0x30C, 0x492, 0x891, 0x891, 0x492, 0x30C, 0x0F0, 0x000, 0x000}, + "charisma", new int[]{0x000, 0x7FE, 0x402, 0x402, 0x552, 0x402, 0x402, 0x7FE, 0x180, 0x100, 0x000, 0x000}, + "arcane", new int[]{0x040, 0x0E0, 0x150, 0x248, 0x444, 0x248, 0x150, 0x0E0, 0x150, 0x248, 0x040, 0x000} ); private static final Map ATTRIBUTE_TOOLTIPS = new HashMap<>(); @@ -124,14 +134,14 @@ public class StatsScreen extends Screen { private void drawWindow(GuiGraphics graphics) { RenderSystem.enableBlend(); - graphics.fill(leftPos - 6, topPos - 6, leftPos + WIDTH + 6, topPos + HEIGHT + 6, 0xCC07070C); - graphics.fill(leftPos - 3, topPos - 3, leftPos + WIDTH + 3, topPos + HEIGHT + 3, 0xFF30253C); - graphics.fill(leftPos, topPos, leftPos + WIDTH, topPos + HEIGHT, 0xF016131E); - graphics.fill(leftPos, topPos, leftPos + WIDTH, topPos + 20, 0xFF2A2036); - graphics.fill(leftPos, topPos + 20, leftPos + WIDTH, topPos + 21, 0xFF655275); + graphics.fill(leftPos - 6, topPos - 6, leftPos + WIDTH + 6, topPos + HEIGHT + 6, 0xCC090A0C); + graphics.fill(leftPos - 3, topPos - 3, leftPos + WIDTH + 3, topPos + HEIGHT + 3, BORDER); + graphics.fill(leftPos, topPos, leftPos + WIDTH, topPos + HEIGHT, BACKGROUND); + graphics.fill(leftPos, topPos, leftPos + WIDTH, topPos + 20, PANEL); + graphics.fill(leftPos, topPos + 20, leftPos + WIDTH, topPos + 21, BORDER); RenderSystem.disableBlend(); - graphics.drawCenteredString(font, title, leftPos + WIDTH / 2, topPos + 6, 0xFFF4EAFB); + graphics.drawCenteredString(font, title, leftPos + WIDTH / 2, topPos + 6, PRIMARY_TEXT); } private void drawProgression(GuiGraphics graphics, int level, int maxLevel, int xp, int xpNext, @@ -139,45 +149,54 @@ public class StatsScreen extends Screen { int panelX = leftPos + PADDING; int panelY = topPos + 26; int panelWidth = WIDTH - PADDING * 2; - graphics.fill(panelX, panelY, panelX + panelWidth, panelY + 31, 0xAA211C29); - graphics.fill(panelX, panelY, panelX + 3, panelY + 31, 0xFFCFB060); + graphics.fill(panelX, panelY, panelX + panelWidth, panelY + 45, PANEL); graphics.drawString(font, Component.translatable("ascend.stats.level", level, maxLevel), - panelX + 9, panelY + 5, 0xFFFFDF78, false); - graphics.drawString(font, Component.translatable("ascend.stats.knowledge", knowledge), - panelX + 112, panelY + 5, 0xFFA9C7FF, false); + panelX + 9, panelY + 5, PROGRESS, false); + graphics.drawCenteredString(font, Component.translatable("ascend.stats.knowledge", knowledge), + panelX + panelWidth / 2, panelY + 5, SECONDARY_TEXT); Component points = Component.translatable("ascend.stats.unspent", unspent); int pointsWidth = font.width(points); int pointsX = panelX + panelWidth - pointsWidth - 9; - graphics.fill(pointsX - 5, panelY + 2, panelX + panelWidth - 4, panelY + 16, 0x663D623D); - graphics.drawString(font, points, pointsX, panelY + 5, unspent > 0 ? 0xFF87F58D : 0xFF9D9D9D, false); + graphics.drawString(font, points, pointsX, panelY + 5, unspent > 0 ? AVAILABLE : SECONDARY_TEXT, false); int barX = panelX + 9; int barY = panelY + 20; int barWidth = panelWidth - 18; - graphics.fill(barX, barY, barX + barWidth, barY + 5, 0xFF0C0A10); - double progress = level >= maxLevel || xpNext <= 0 ? 1.0 : Math.min(1.0, (double) xp / xpNext); - graphics.fill(barX + 1, barY + 1, barX + 1 + (int) ((barWidth - 2) * progress), barY + 4, 0xFF8E68C3); + graphics.fill(barX, barY, barX + barWidth, barY + 7, BORDER); + graphics.fill(barX + 1, barY + 1, barX + barWidth - 1, barY + 6, BACKGROUND); + double progress = level >= maxLevel || xpNext <= 0 ? 1.0 : Math.max(0.0, Math.min(1.0, (double) xp / xpNext)); + graphics.fill(barX + 1, barY + 1, barX + 1 + (int) ((barWidth - 2) * progress), barY + 6, PROGRESS); Component xpLabel = level >= maxLevel ? Component.translatable("ascend.stats.xp_max") : Component.translatable("ascend.stats.xp", xp, xpNext); - graphics.drawCenteredString(font, xpLabel, barX + barWidth / 2, barY - 2, 0xFFC9C1D0); + graphics.drawCenteredString(font, xpLabel, barX + barWidth / 2, barY + 11, PROGRESS); } private void drawAttributeCard(GuiGraphics graphics, String attribute, int value, int maximum, int x, int y, boolean hovered) { - int accent = ATTRIBUTE_COLORS.getOrDefault(attribute, 0xFFFFFFFF); - graphics.fill(x, y, x + CARD_WIDTH, y + CARD_HEIGHT, hovered ? 0xE0332B3D : 0xC925202F); - graphics.fill(x, y, x + 3, y + CARD_HEIGHT, accent); - graphics.fill(x + 3, y, x + CARD_WIDTH, y + 1, hovered ? 0x667F6B8C : 0x334C4057); + graphics.fill(x, y, x + CARD_WIDTH, y + CARD_HEIGHT, hovered ? ACCENT : BORDER); + graphics.fill(x + 1, y + 1, x + CARD_WIDTH - 1, y + CARD_HEIGHT - 1, CARD); + drawAttributeIcon(graphics, attribute, x + 8, y + 5); graphics.drawString(font, Component.translatable("ascend.attribute." + attribute), - x + 9, y + 7, 0xFFF1ECF4, false); + x + 25, y + 7, PRIMARY_TEXT, false); Component valueLabel = Component.literal(value + " / " + maximum); int valueX = x + CARD_WIDTH - 38 - font.width(valueLabel); - graphics.drawString(font, valueLabel, valueX, y + 7, value >= maximum ? 0xFFFFD66B : 0xFFC9C1D0, false); + graphics.drawString(font, valueLabel, valueX, y + 7, value >= maximum ? PROGRESS : PRIMARY_TEXT, false); graphics.drawString(font, Component.translatable("ascend.attribute." + attribute + ".short"), - x + 9, y + 26, 0xFF9F98A8, false); + x + 9, y + 26, SECONDARY_TEXT, false); + } + + private void drawAttributeIcon(GuiGraphics graphics, String attribute, int x, int y) { + int[] rows = ATTRIBUTE_ICONS.get(attribute); + for (int row = 0; row < rows.length; row++) { + for (int column = 0; column < 12; column++) { + if ((rows[row] & (1 << (11 - column))) != 0) { + graphics.fill(x + column, y + row, x + column + 1, y + row + 1, ACCENT); + } + } + } } @Override diff --git a/src/main/java/net/fretux/ascend/event/ArcaneEffectEvents.java b/src/main/java/net/fretux/ascend/event/ArcaneEffectEvents.java new file mode 100644 index 0000000..6449dfb --- /dev/null +++ b/src/main/java/net/fretux/ascend/event/ArcaneEffectEvents.java @@ -0,0 +1,50 @@ +package net.fretux.ascend.event; + +import net.fretux.ascend.AscendMod; +import net.fretux.ascend.player.PlayerStatsProvider; +import net.fretux.ascend.player.StatEffects; +import net.minecraft.world.effect.MobEffectCategory; +import net.minecraft.world.effect.MobEffectInstance; +import net.minecraft.world.entity.player.Player; +import net.minecraft.world.entity.projectile.Projectile; +import net.minecraftforge.event.entity.living.MobEffectEvent; +import net.minecraftforge.eventbus.api.SubscribeEvent; +import net.minecraftforge.fml.common.Mod; + +@Mod.EventBusSubscriber(modid = AscendMod.MODID) +public final class ArcaneEffectEvents { + private static final ThreadLocal MODIFYING = ThreadLocal.withInitial(() -> false); + + @SubscribeEvent + public static void onEffectAdded(MobEffectEvent.Added event) { + if (MODIFYING.get() || event.getEntity().level().isClientSide || event.getOldEffectInstance() != null) return; + MobEffectInstance added = event.getEffectInstance(); + if (added.isInfiniteDuration() || added.getDuration() <= 0) return; + + Player arcaneOwner; + boolean beneficialSelf = event.getEntity() instanceof Player player + && added.getEffect().getCategory() == MobEffectCategory.BENEFICIAL; + if (beneficialSelf) arcaneOwner = (Player) event.getEntity(); + else if (added.getEffect().getCategory() == MobEffectCategory.HARMFUL) { + if (event.getEffectSource() instanceof Player source && source != event.getEntity()) arcaneOwner = source; + else if (event.getEffectSource() instanceof Projectile projectile + && projectile.getOwner() instanceof Player source && source != event.getEntity()) arcaneOwner = source; + else return; + } else return; + + arcaneOwner.getCapability(PlayerStatsProvider.PLAYER_STATS).ifPresent(stats -> { + int arcane = stats.getAttributeLevel("arcane"); + if (arcane <= 0) return; + double multiplier = beneficialSelf ? StatEffects.getArcaneBeneficialDurationMultiplier(arcane) + : StatEffects.getArcaneHarmfulDurationMultiplier(arcane); + MobEffectInstance active = event.getEntity().getEffect(added.getEffect()); + if (active == null || active.isInfiniteDuration()) return; + int oldDuration = active.getDuration(); + int newDuration = (int) Math.min(Integer.MAX_VALUE, Math.round(oldDuration * multiplier)); + if (newDuration <= oldDuration) return; + MODIFYING.set(true); + try { active.mapDuration(ignored -> newDuration); } + finally { MODIFYING.set(false); } + }); + } +} diff --git a/src/main/java/net/fretux/ascend/event/WeaponScalingEvents.java b/src/main/java/net/fretux/ascend/event/WeaponScalingEvents.java new file mode 100644 index 0000000..2998f12 --- /dev/null +++ b/src/main/java/net/fretux/ascend/event/WeaponScalingEvents.java @@ -0,0 +1,136 @@ +package net.fretux.ascend.event; + +import com.google.common.collect.Multimap; +import net.fretux.ascend.AscendMod; +import net.fretux.ascend.api.event.ArmorPenetrationEvent; +import net.fretux.ascend.config.AscendConfig; +import net.fretux.ascend.player.PlayerStatsProvider; +import net.fretux.ascend.player.StatEffects; +import net.fretux.ascend.scaling.ScalingGrade; +import net.fretux.ascend.scaling.WeaponScaling; +import net.fretux.ascend.scaling.WeaponScalingRegistry; +import net.minecraft.world.entity.EquipmentSlot; +import net.minecraft.world.entity.ai.attributes.AttributeModifier; +import net.minecraft.world.entity.ai.attributes.Attributes; +import net.minecraft.world.entity.player.Player; +import net.minecraft.world.entity.projectile.AbstractArrow; +import net.minecraft.world.entity.projectile.FireworkRocketEntity; +import net.minecraft.world.entity.projectile.ThrownTrident; +import net.minecraft.world.item.Item; +import net.minecraft.world.item.ItemStack; +import net.minecraft.world.item.Items; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.tags.DamageTypeTags; +import net.minecraft.world.damagesource.CombatRules; +import net.minecraft.world.entity.LivingEntity; +import net.minecraftforge.common.MinecraftForge; +import net.minecraftforge.event.entity.living.LivingHurtEvent; +import net.minecraftforge.event.entity.EntityJoinLevelEvent; +import net.minecraftforge.eventbus.api.SubscribeEvent; +import net.minecraftforge.eventbus.api.EventPriority; +import net.minecraftforge.fml.common.Mod; +import net.minecraftforge.registries.ForgeRegistries; + +@Mod.EventBusSubscriber(modid = AscendMod.MODID) +public final class WeaponScalingEvents { + private static final String PROJECTILE_WEAPON_TAG = "ascend:scaling_weapon"; + + @SubscribeEvent + public static void rememberProjectileWeapon(EntityJoinLevelEvent event) { + if (event.getLevel().isClientSide || !(event.getEntity() instanceof AbstractArrow arrow) + || arrow instanceof ThrownTrident || !(arrow.getOwner() instanceof Player player)) return; + ItemStack stack = player.getMainHandItem(); + if (!stack.is(Items.BOW) && !stack.is(Items.CROSSBOW)) return; + ResourceLocation id = ForgeRegistries.ITEMS.getKey(stack.getItem()); + if (id != null) arrow.getPersistentData().putString(PROJECTILE_WEAPON_TAG, id.toString()); + } + + @SubscribeEvent + public static void addWeaponScaling(LivingHurtEvent event) { + if (!(event.getSource().getEntity() instanceof Player player) || player.level().isClientSide || event.getEntity() == player) return; + Item item = resolveWeapon(player, event.getSource().getDirectEntity()); + WeaponScaling scaling = item == null ? null : WeaponScalingRegistry.get(item); + if (scaling == null) return; + player.getCapability(PlayerStatsProvider.PLAYER_STATS).ifPresent(stats -> { + double baseDamage = event.getSource().getDirectEntity() instanceof AbstractArrow + ? event.getAmount() : getPhysicalBaseDamage(new ItemStack(item), event.getAmount()); + double bonus = WeaponScalingRegistry.calculateWeaponScalingBonus(baseDamage, scaling, player, stats); + if (bonus > 0) event.setAmount((float) (event.getAmount() + bonus)); + }); + } + + @SubscribeEvent(priority = EventPriority.LOWEST) + public static void applyArmorPenetration(LivingHurtEvent event) { + if (!(event.getSource().getEntity() instanceof Player player) || player.level().isClientSide || event.getEntity() == player) return; + if (event.getSource().is(DamageTypeTags.BYPASSES_ARMOR) || event.getAmount() <= 0 || event.getEntity().getArmorValue() <= 0) return; + Item item = resolveWeapon(player, event.getSource().getDirectEntity()); + WeaponScaling scaling = item == null ? null : WeaponScalingRegistry.get(item); + ItemStack weapon = item == null ? ItemStack.EMPTY : new ItemStack(item); + player.getCapability(PlayerStatsProvider.PLAYER_STATS).ifPresent(stats -> { + double basePenetration = scaling != null && scaling.grade("strength") != ScalingGrade.NONE + ? StatEffects.getStrengthArmorPenetration(stats.getAttributeLevel("strength")) : 0.0; + ArmorPenetrationEvent penetrationEvent = new ArmorPenetrationEvent(player, event.getEntity(), + event.getSource(), weapon, basePenetration, configuredArmorPenetrationCap()); + MinecraftForge.EVENT_BUS.post(penetrationEvent); + double penetration = penetrationEvent.getEffectiveArmorPenetration(); + if (penetration <= 0) return; + event.setAmount(getPreArmorDamageForReducedArmor(event.getEntity(), event.getAmount(), penetration)); + }); + } + + /** + * Finds the pre-armor damage that produces the same result through vanilla's + * normal armor pipeline as applying the original hit against reduced armor. + */ + static float getPreArmorDamageForReducedArmor(LivingEntity target, float incomingDamage, double penetration) { + float armor = Math.max(0.0F, target.getArmorValue()); + float toughness = (float) Math.max(0.0, target.getAttributeValue(Attributes.ARMOR_TOUGHNESS)); + return getPreArmorDamageForReducedArmor(incomingDamage, armor, toughness, penetration); + } + + static float getPreArmorDamageForReducedArmor(float incomingDamage, float armor, float toughness, double penetration) { + float reducedArmor = armor * (1.0F - (float) Math.max(0.0, Math.min(1.0, penetration))); + float desiredPostArmor = CombatRules.getDamageAfterAbsorb(incomingDamage, reducedArmor, toughness); + if (desiredPostArmor <= CombatRules.getDamageAfterAbsorb(incomingDamage, armor, toughness)) return incomingDamage; + + float low = incomingDamage; + float high = Math.max(incomingDamage + 1.0F, incomingDamage * 2.0F); + while (CombatRules.getDamageAfterAbsorb(high, armor, toughness) < desiredPostArmor && high < Float.MAX_VALUE / 4.0F) { + high *= 2.0F; + } + for (int i = 0; i < 32; i++) { + float middle = low + (high - low) * 0.5F; + if (CombatRules.getDamageAfterAbsorb(middle, armor, toughness) < desiredPostArmor) low = middle; + else high = middle; + } + return high; + } + + private static double configuredArmorPenetrationCap() { + return AscendConfig.COMMON_SPEC.isLoaded() + ? AscendConfig.COMMON.armorPenetrationCap.get() + : AscendConfig.COMMON.armorPenetrationCap.getDefault(); + } + + private static Item resolveWeapon(Player player, net.minecraft.world.entity.Entity direct) { + if (direct instanceof FireworkRocketEntity) return null; + if (direct instanceof ThrownTrident) return Items.TRIDENT; + ItemStack stack = player.getMainHandItem(); + if (direct instanceof AbstractArrow) { + String storedId = direct.getPersistentData().getString(PROJECTILE_WEAPON_TAG); + ResourceLocation id = ResourceLocation.tryParse(storedId); + if (id != null && ForgeRegistries.ITEMS.containsKey(id)) return ForgeRegistries.ITEMS.getValue(id); + return stack.is(Items.BOW) || stack.is(Items.CROSSBOW) ? stack.getItem() : null; + } + return direct == player && !stack.isEmpty() ? stack.getItem() : null; + } + + private static double getPhysicalBaseDamage(ItemStack stack, float eventDamage) { + Multimap modifiers = + stack.getAttributeModifiers(EquipmentSlot.MAINHAND); + double itemDamage = modifiers.get(Attributes.ATTACK_DAMAGE).stream() + .filter(modifier -> modifier.getOperation() == AttributeModifier.Operation.ADDITION) + .mapToDouble(AttributeModifier::getAmount).sum(); + return Math.max(0, Math.min(eventDamage, 1.0 + itemDamage)); + } +} diff --git a/src/main/java/net/fretux/ascend/player/AttributeScaling.java b/src/main/java/net/fretux/ascend/player/AttributeScaling.java new file mode 100644 index 0000000..637d245 --- /dev/null +++ b/src/main/java/net/fretux/ascend/player/AttributeScaling.java @@ -0,0 +1,56 @@ +package net.fretux.ascend.player; + +import net.fretux.ascend.config.AscendConfig; + +/** Shared piecewise soft-cap curve used by attributes, weapons, and integrations. */ +public final class AttributeScaling { + private AttributeScaling() {} + + public static double getEffectiveAttributeValue(int investment) { + int value = Math.max(0, Math.min(investment, intValue(AscendConfig.COMMON.maxAttributePoints))); + return calculateEffectiveAttributeValue(value); + } + + /** + * Applies the configured curve without enforcing the investable attribute cap. + * Intended for combined values that include passive points supplied by integrations. + */ + public static double getExtendedEffectiveAttributeValue(int investment) { + return calculateEffectiveAttributeValue(Math.max(0, investment)); + } + + private static double calculateEffectiveAttributeValue(int value) { + int c1 = intValue(AscendConfig.COMMON.softCap1); + int c2 = Math.max(c1, intValue(AscendConfig.COMMON.softCap2)); + int c3 = Math.max(c2, intValue(AscendConfig.COMMON.softCap3)); + int c4 = Math.max(c3, intValue(AscendConfig.COMMON.softCap4)); + double effective = segment(value, 0, c1, 1.0); + effective += segment(value, c1, c2, doubleValue(AscendConfig.COMMON.softCapGain2)); + effective += segment(value, c2, c3, doubleValue(AscendConfig.COMMON.softCapGain3)); + effective += segment(value, c3, c4, doubleValue(AscendConfig.COMMON.softCapGain4)); + effective += Math.max(0, value - c4) * doubleValue(AscendConfig.COMMON.softCapGain5); + return effective * doubleValue(AscendConfig.COMMON.attributeScalingMultiplier); + } + + public static double getNormalizedAttributeValue(int investment) { + double max = getEffectiveAttributeValue(intValue(AscendConfig.COMMON.maxAttributePoints)); + return max <= 0 ? 0 : Math.min(1.0, getEffectiveAttributeValue(investment) / max); + } + + /** Returns a value normalized at the investable cap while permitting passive overflow above {@code 1.0}. */ + public static double getExtendedNormalizedAttributeValue(int investment) { + double max = getEffectiveAttributeValue(intValue(AscendConfig.COMMON.maxAttributePoints)); + return max <= 0 ? 0 : getExtendedEffectiveAttributeValue(investment) / max; + } + + private static double segment(int value, int start, int end, double rate) { + return Math.max(0, Math.min(value, end) - start) * rate; + } + + private static int intValue(net.minecraftforge.common.ForgeConfigSpec.IntValue value) { + return AscendConfig.COMMON_SPEC.isLoaded() ? value.get() : value.getDefault(); + } + private static double doubleValue(net.minecraftforge.common.ForgeConfigSpec.DoubleValue value) { + return AscendConfig.COMMON_SPEC.isLoaded() ? value.get() : value.getDefault(); + } +} diff --git a/src/main/java/net/fretux/ascend/scaling/ScalingGrade.java b/src/main/java/net/fretux/ascend/scaling/ScalingGrade.java new file mode 100644 index 0000000..076fae7 --- /dev/null +++ b/src/main/java/net/fretux/ascend/scaling/ScalingGrade.java @@ -0,0 +1,24 @@ +package net.fretux.ascend.scaling; + +import net.fretux.ascend.config.AscendConfig; + +public enum ScalingGrade { + S, A, B, C, D, E, NONE; + + public double coefficient() { + return switch (this) { + case S -> AscendConfig.COMMON.gradeS.get(); + case A -> AscendConfig.COMMON.gradeA.get(); + case B -> AscendConfig.COMMON.gradeB.get(); + case C -> AscendConfig.COMMON.gradeC.get(); + case D -> AscendConfig.COMMON.gradeD.get(); + case E -> AscendConfig.COMMON.gradeE.get(); + case NONE -> 0.0; + }; + } + + public static ScalingGrade parse(String value) { + try { return valueOf(value.toUpperCase(java.util.Locale.ROOT)); } + catch (RuntimeException ignored) { return NONE; } + } +} diff --git a/src/main/java/net/fretux/ascend/scaling/WeaponScaling.java b/src/main/java/net/fretux/ascend/scaling/WeaponScaling.java new file mode 100644 index 0000000..504b812 --- /dev/null +++ b/src/main/java/net/fretux/ascend/scaling/WeaponScaling.java @@ -0,0 +1,15 @@ +package net.fretux.ascend.scaling; + +import java.util.Collections; +import java.util.LinkedHashMap; +import java.util.Map; + +public record WeaponScaling(Map attributes) { + public static final String[] SUPPORTED_ATTRIBUTES = {"strength", "agility", "intelligence", "willpower", "charisma", "arcane"}; + + public WeaponScaling { + attributes = Collections.unmodifiableMap(new LinkedHashMap<>(attributes)); + } + + public ScalingGrade grade(String attribute) { return attributes.getOrDefault(attribute, ScalingGrade.NONE); } +} diff --git a/src/main/java/net/fretux/ascend/scaling/WeaponScalingRegistry.java b/src/main/java/net/fretux/ascend/scaling/WeaponScalingRegistry.java new file mode 100644 index 0000000..cf0dfcf --- /dev/null +++ b/src/main/java/net/fretux/ascend/scaling/WeaponScalingRegistry.java @@ -0,0 +1,111 @@ +package net.fretux.ascend.scaling; + +import com.google.gson.Gson; +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; +import net.fretux.ascend.AscendMod; +import net.fretux.ascend.api.PassiveAgilityApi; +import net.fretux.ascend.player.AttributeScaling; +import net.fretux.ascend.player.PlayerStats; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.server.packs.resources.ResourceManager; +import net.minecraft.server.packs.resources.SimpleJsonResourceReloadListener; +import net.minecraft.util.profiling.ProfilerFiller; +import net.minecraft.world.item.Item; +import net.minecraft.world.entity.player.Player; +import net.minecraftforge.event.AddReloadListenerEvent; +import net.minecraftforge.eventbus.api.SubscribeEvent; +import net.minecraftforge.fml.common.Mod; +import net.minecraftforge.registries.ForgeRegistries; + +import java.util.LinkedHashMap; +import java.util.Map; + +@Mod.EventBusSubscriber(modid = AscendMod.MODID) +public final class WeaponScalingRegistry extends SimpleJsonResourceReloadListener { + private static final Gson GSON = new Gson(); + private static volatile Map entries = createVanillaDefaults(); + + public WeaponScalingRegistry() { super(GSON, "weapon_scaling"); } + + @SubscribeEvent + public static void addReloadListener(AddReloadListenerEvent event) { event.addListener(new WeaponScalingRegistry()); } + + public static WeaponScaling get(Item item) { return entries.get(item); } + + /** Public API for integrations; datapack reloads remain authoritative and may replace this entry. */ + public static synchronized void register(Item item, WeaponScaling scaling) { + Map copy = new LinkedHashMap<>(entries); + copy.put(item, scaling); + entries = Map.copyOf(copy); + } + + public static double getScalingCoefficient(ScalingGrade grade) { return grade.coefficient(); } + + public static double calculateWeaponScalingBonus(double baseDamage, WeaponScaling scaling, PlayerStats stats) { + return calculateWeaponScalingBonus(baseDamage, scaling, null, stats); + } + + /** Calculates weapon scaling, including passive Agility supplied through Ascend's public API. */ + public static double calculateWeaponScalingBonus(double baseDamage, WeaponScaling scaling, Player player, PlayerStats stats) { + if (baseDamage <= 0 || scaling == null) return 0; + double coefficient = 0; + for (String attribute : WeaponScaling.SUPPORTED_ATTRIBUTES) { + ScalingGrade grade = scaling.grade(attribute); + double normalized = "agility".equals(attribute) && player != null + ? PassiveAgilityApi.getNormalizedAgility(player, stats.getAttributeLevel(attribute)) + : AttributeScaling.getNormalizedAttributeValue(stats.getAttributeLevel(attribute)); + coefficient += getScalingCoefficient(grade) * normalized; + } + return baseDamage * coefficient; + } + + @Override + protected void apply(Map resources, ResourceManager manager, ProfilerFiller profiler) { + Map loaded = createVanillaDefaults(); + resources.forEach((file, json) -> { + try { + JsonObject root = json.getAsJsonObject(); + if (root.has("entries")) { + root.getAsJsonArray("entries").forEach(element -> loadEntry(loaded, element.getAsJsonObject())); + } else loadEntry(loaded, root); + } catch (RuntimeException ex) { + AscendMod.LOGGER.warn("Ignoring invalid weapon scaling data {}: {}", file, ex.getMessage()); + } + }); + entries = Map.copyOf(loaded); + AscendMod.LOGGER.info("Loaded {} Ascend weapon scaling entries", entries.size()); + } + + private static void loadEntry(Map target, JsonObject json) { + ResourceLocation id = ResourceLocation.tryParse(json.get("item").getAsString()); + if (id == null || !ForgeRegistries.ITEMS.containsKey(id)) return; + Map grades = new LinkedHashMap<>(); + JsonObject scaling = json.getAsJsonObject("scaling"); + for (String key : WeaponScaling.SUPPORTED_ATTRIBUTES) { + if (scaling.has(key)) grades.put(key, ScalingGrade.parse(scaling.get(key).getAsString())); + } + target.put(ForgeRegistries.ITEMS.getValue(id), new WeaponScaling(grades)); + } + + private static Map createVanillaDefaults() { + Map result = new LinkedHashMap<>(); + String[][] defaults = { + {"wooden_sword","D","D"},{"stone_sword","D","C"},{"iron_sword","C","C"},{"golden_sword","E","B"},{"diamond_sword","C","B"},{"netherite_sword","B","B"}, + {"wooden_axe","C","E"},{"stone_axe","B","E"},{"iron_axe","B","D"},{"golden_axe","D","C"},{"diamond_axe","A","D"},{"netherite_axe","A","C"}, + {"wooden_pickaxe","D","E"},{"stone_pickaxe","C","E"},{"iron_pickaxe","C","E"},{"golden_pickaxe","E","D"},{"diamond_pickaxe","B","E"},{"netherite_pickaxe","B","E"}, + {"wooden_shovel","D","E"},{"stone_shovel","D","E"},{"iron_shovel","C","E"},{"golden_shovel","E","D"},{"diamond_shovel","C","E"},{"netherite_shovel","C","E"}, + {"wooden_hoe","E","D"},{"stone_hoe","E","C"},{"iron_hoe","E","B"},{"golden_hoe","E","B"},{"diamond_hoe","D","B"},{"netherite_hoe","D","A"}, + {"bow","NONE","A"},{"crossbow","D","B"},{"trident","C","B"},{"mace","A","D"} + }; + for (String[] row : defaults) { + ResourceLocation id = ResourceLocation.fromNamespaceAndPath("minecraft", row[0]); + if (!ForgeRegistries.ITEMS.containsKey(id)) continue; + Map grades = new LinkedHashMap<>(); + grades.put("strength", ScalingGrade.parse(row[1])); + grades.put("agility", ScalingGrade.parse(row[2])); + result.put(ForgeRegistries.ITEMS.getValue(id), new WeaponScaling(grades)); + } + return result; + } +} diff --git a/src/main/resources/META-INF/mods.toml b/src/main/resources/META-INF/mods.toml index 80795f1..4c3f21d 100644 --- a/src/main/resources/META-INF/mods.toml +++ b/src/main/resources/META-INF/mods.toml @@ -27,8 +27,6 @@ displayName="${mod_name}" #mandatory #updateJSONURL="https://change.me.example.invalid/updates.json" #optional # A URL for the "homepage" for this mod, displayed in the mod UI #displayURL="https://change.me.to.your.mods.homepage.example.invalid/" #optional -# A file name (in the root of the mod JAR) containing a logo for display -#logoFile="examplemod.png" #optional # A text field displayed in the mod UI #credits="" #optional # A text field displayed in the mod UI diff --git a/src/main/resources/assets/ascend/lang/en_us.json b/src/main/resources/assets/ascend/lang/en_us.json index ba2804e..1dbf16d 100644 --- a/src/main/resources/assets/ascend/lang/en_us.json +++ b/src/main/resources/assets/ascend/lang/en_us.json @@ -2,10 +2,10 @@ "key.ascend.open_stats": "Open Ascend Stats", "key.categories.inventory": "Inventory", "ascend.stats.title": "Ascend Stats", - "ascend.stats.level": "Level: %s/%s", - "ascend.stats.xp": "Ascend XP: %s / %s", - "ascend.stats.xp_max": "Ascend XP: MAX", - "ascend.stats.unspent": "Unspent Points: %s", + "ascend.stats.level": "Level %s / %s", + "ascend.stats.xp": "%s / %s XP", + "ascend.stats.xp_max": "Maximum Level", + "ascend.stats.unspent": "%s Points Available", "ascend.attribute.vigor": "Vigor", "ascend.attribute.vigor.desc": "Increases maximum health.", diff --git a/src/main/resources/assets/ascend/models/enemy/junk_iron_colossus.bbmodel b/src/main/resources/assets/ascend/models/enemy/junk_iron_colossus.bbmodel new file mode 100644 index 0000000..ec70966 --- /dev/null +++ b/src/main/resources/assets/ascend/models/enemy/junk_iron_colossus.bbmodel @@ -0,0 +1 @@ +{"meta":{"format_version":"5.0","model_format":"free","box_uv":false},"name":"junk_iron_colossus","model_identifier":"junk_iron_colossus","visible_box":[2,2,0.5],"variable_placeholders":"","multi_file_ruleset":"","variable_placeholder_buttons":[],"timeline_setups":[],"unhandled_root_fields":{},"resolution":{"width":194,"height":260},"elements":[{"name":"left_foot","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[2,-0.08,6],"to":[6,2.92,12],"autouv":0,"color":0,"origin":[4,1.42,9],"faces":{"north":{"uv":[126,6,130,9],"texture":0},"east":{"uv":[120,6,126,9],"texture":0},"south":{"uv":[136,6,140,9],"texture":0},"west":{"uv":[130,6,136,9],"texture":0},"up":{"uv":[126,0,130,6],"texture":0},"down":{"uv":[130,0,134,6],"texture":0}},"type":"cube","uuid":"9ae4ffe3-8068-4c33-902e-72805423e293"},{"name":"left_foot_plate","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[1.75,2.5,5.5],"to":[6.25,4.5,11],"autouv":0,"color":0,"origin":[4,3.5,8.25],"faces":{"north":{"uv":[146,6,151,8],"texture":0},"east":{"uv":[140,6,146,8],"texture":0},"south":{"uv":[157,6,162,8],"texture":0},"west":{"uv":[151,6,157,8],"texture":0},"up":{"uv":[146,0,151,6],"texture":0},"down":{"uv":[151,0,156,6],"texture":0}},"type":"cube","uuid":"a3046513-da6f-46f0-95c0-f5dc5c5ea0a3"},{"name":"left_calf","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[2.5,3,7],"to":[5.5,12,10],"autouv":0,"color":0,"origin":[4,7.5,8.5],"faces":{"north":{"uv":[165,3,168,12],"texture":0},"east":{"uv":[162,3,165,12],"texture":0},"south":{"uv":[171,3,174,12],"texture":0},"west":{"uv":[168,3,171,12],"texture":0},"up":{"uv":[165,0,168,3],"texture":0},"down":{"uv":[168,0,171,3],"texture":0}},"type":"cube","uuid":"897732bc-7362-4c83-8226-ba730f9f6496"},{"name":"left_knee_guard","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[2,11,5.5],"to":[6,14.5,10.5],"autouv":0,"color":0,"origin":[4,12.75,8],"faces":{"north":{"uv":[179,5,183,9],"texture":0},"east":{"uv":[174,5,179,9],"texture":0},"south":{"uv":[188,5,192,9],"texture":0},"west":{"uv":[183,5,188,9],"texture":0},"up":{"uv":[179,0,183,5],"texture":0},"down":{"uv":[183,0,187,5],"texture":0}},"type":"cube","uuid":"8df975d0-e207-404e-8929-df31cab84fc9"},{"name":"left_thigh","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[2.5,13,7.5],"to":[5.5,22,10.5],"autouv":0,"color":0,"origin":[4,17.5,9],"faces":{"north":{"uv":[3,91,6,100],"texture":0},"east":{"uv":[0,91,3,100],"texture":0},"south":{"uv":[9,91,12,100],"texture":0},"west":{"uv":[6,91,9,100],"texture":0},"up":{"uv":[3,88,6,91],"texture":0},"down":{"uv":[6,88,9,91],"texture":0}},"type":"cube","uuid":"7d5fe12a-c6c8-4b68-a128-e6e42c9b1616"},{"name":"right_foot","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[10,-0.08,6],"to":[14,2.92,12],"autouv":0,"color":0,"origin":[12,1.42,9],"faces":{"north":{"uv":[18,94,22,97],"texture":0},"east":{"uv":[12,94,18,97],"texture":0},"south":{"uv":[28,94,32,97],"texture":0},"west":{"uv":[22,94,28,97],"texture":0},"up":{"uv":[18,88,22,94],"texture":0},"down":{"uv":[22,88,26,94],"texture":0}},"type":"cube","uuid":"eb6c6b77-257f-49eb-bb25-44a0ec73ef78"},{"name":"right_foot_plate","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[9.75,2.5,5.5],"to":[14.25,4.5,11],"autouv":0,"color":0,"origin":[12,3.5,8.25],"faces":{"north":{"uv":[38,94,43,96],"texture":0},"east":{"uv":[32,94,38,96],"texture":0},"south":{"uv":[49,94,54,96],"texture":0},"west":{"uv":[43,94,49,96],"texture":0},"up":{"uv":[38,88,43,94],"texture":0},"down":{"uv":[43,88,48,94],"texture":0}},"type":"cube","uuid":"b4f9900d-4891-4183-9204-a57a793f6956"},{"name":"right_calf","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[10.5,3,7],"to":[13.5,12,10],"autouv":0,"color":0,"origin":[12,7.5,8.5],"faces":{"north":{"uv":[57,91,60,100],"texture":0},"east":{"uv":[54,91,57,100],"texture":0},"south":{"uv":[63,91,66,100],"texture":0},"west":{"uv":[60,91,63,100],"texture":0},"up":{"uv":[57,88,60,91],"texture":0},"down":{"uv":[60,88,63,91],"texture":0}},"type":"cube","uuid":"9421cb65-3809-49b9-8028-b08897713e8d"},{"name":"right_knee_guard","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[10,11,5.5],"to":[14,14.5,10.5],"autouv":0,"color":0,"origin":[12,12.75,8],"faces":{"north":{"uv":[71,93,75,97],"texture":0},"east":{"uv":[66,93,71,97],"texture":0},"south":{"uv":[80,93,84,97],"texture":0},"west":{"uv":[75,93,80,97],"texture":0},"up":{"uv":[71,88,75,93],"texture":0},"down":{"uv":[75,88,79,93],"texture":0}},"type":"cube","uuid":"fc592f19-c82b-4878-87c8-38bf2019a400"},{"name":"right_thigh","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[10.5,13,7.5],"to":[13.5,22,10.5],"autouv":0,"color":0,"origin":[12,17.5,9],"faces":{"north":{"uv":[87,91,90,100],"texture":0},"east":{"uv":[84,91,87,100],"texture":0},"south":{"uv":[93,91,96,100],"texture":0},"west":{"uv":[90,91,93,100],"texture":0},"up":{"uv":[87,88,90,91],"texture":0},"down":{"uv":[90,88,93,91],"texture":0}},"type":"cube","uuid":"ee94f15d-4938-49c9-b521-af740aea0a45"},{"name":"frail_pelvis","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[4,20,7],"to":[12,24,11],"autouv":0,"color":0,"origin":[8,22,9],"faces":{"north":{"uv":[100,92,108,96],"texture":0},"east":{"uv":[96,92,100,96],"texture":0},"south":{"uv":[112,92,120,96],"texture":0},"west":{"uv":[108,92,112,96],"texture":0},"up":{"uv":[100,88,108,92],"texture":0},"down":{"uv":[108,88,116,92],"texture":0}},"type":"cube","uuid":"c7b8f08f-6bac-4a11-8499-867fa8b2bd5e"},{"name":"frail_waist","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[5.5,21.92,8.5],"to":[10.5,26.92,11.5],"autouv":0,"color":0,"origin":[8,24.42,10],"faces":{"north":{"uv":[123,91,128,96],"texture":0},"east":{"uv":[120,91,123,96],"texture":0},"south":{"uv":[131,91,136,96],"texture":0},"west":{"uv":[128,91,131,96],"texture":0},"up":{"uv":[123,88,128,91],"texture":0},"down":{"uv":[128,88,133,91],"texture":0}},"type":"cube","uuid":"b8e7ecc5-6b10-46f8-8a2e-f8095ca4862a"},{"name":"frail_ribcage","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[5,26.92,8],"to":[11,34.92,13],"autouv":0,"color":0,"origin":[8,30.92,10.5],"faces":{"north":{"uv":[141,93,147,101],"texture":0},"east":{"uv":[136,93,141,101],"texture":0},"south":{"uv":[152,93,158,101],"texture":0},"west":{"uv":[147,93,152,101],"texture":0},"up":{"uv":[141,88,147,93],"texture":0},"down":{"uv":[147,88,153,93],"texture":0}},"type":"cube","uuid":"bcfdac59-6fe9-4f25-9b79-8859778458f8"},{"name":"pressure_seam_core","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[3,26,4],"to":[13,48,12],"autouv":0,"color":0,"origin":[8,37,8],"faces":{"north":{"uv":[166,96,176,118],"texture":0},"east":{"uv":[158,96,166,118],"texture":0},"south":{"uv":[184,96,194,118],"texture":0},"west":{"uv":[176,96,184,118],"texture":0},"up":{"uv":[166,88,176,96],"texture":0},"down":{"uv":[176,88,186,96],"texture":0}},"type":"cube","uuid":"82f0b41a-6ecc-4f63-bf35-05d788509fa2"},{"name":"lower_torso_frame","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[1,21,5],"to":[15,29,15],"autouv":0,"color":0,"origin":[8,25,10],"faces":{"north":{"uv":[10,128,24,136],"texture":0},"east":{"uv":[0,128,10,136],"texture":0},"south":{"uv":[34,128,48,136],"texture":0},"west":{"uv":[24,128,34,136],"texture":0},"up":{"uv":[10,118,24,128],"texture":0},"down":{"uv":[24,118,38,128],"texture":0}},"type":"cube","uuid":"8b3b4567-d8b0-4ba4-a82c-e45bfd9ad79c"},{"name":"golem_chestplate_main","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[0,27,6],"to":[16,39,18],"autouv":0,"color":0,"origin":[8,33,12],"faces":{"north":{"uv":[60,130,76,142],"texture":0},"east":{"uv":[48,130,60,142],"texture":0},"south":{"uv":[88,130,104,142],"texture":0},"west":{"uv":[76,130,88,142],"texture":0},"up":{"uv":[60,118,76,130],"texture":0},"down":{"uv":[76,118,92,130],"texture":0}},"type":"cube","uuid":"b88b66ee-9cf8-4221-978a-39075701ed85"},{"name":"front_shield_plate_rust","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[2,27.92,18.25],"to":[14,37.92,20.25],"autouv":0,"color":0,"origin":[8,32.92,19.25],"faces":{"north":{"uv":[106,120,118,130],"texture":0},"east":{"uv":[104,120,106,130],"texture":0},"south":{"uv":[120,120,132,130],"texture":0},"west":{"uv":[118,120,120,130],"texture":0},"up":{"uv":[106,118,118,120],"texture":0},"down":{"uv":[118,118,130,120],"texture":0}},"type":"cube","uuid":"ed2962da-a259-4179-9bdc-6f9bc415e001"},{"name":"front_shield_boss","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[6.5,31.5,20.5],"to":[9.5,34.5,21.5],"autouv":0,"color":0,"origin":[8,33,21],"faces":{"north":{"uv":[133,119,136,122],"texture":0},"east":{"uv":[132,119,133,122],"texture":0},"south":{"uv":[137,119,140,122],"texture":0},"west":{"uv":[136,119,137,122],"texture":0},"up":{"uv":[133,118,136,119],"texture":0},"down":{"uv":[136,118,139,119],"texture":0}},"type":"cube","uuid":"1119dfd5-92eb-48ac-934b-7d1b96df2cc5"},{"name":"hunched_carapace_bulk","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[-2,35,1],"to":[18,50,17],"autouv":0,"color":0,"origin":[8,42.5,9],"faces":{"north":{"uv":[16,158,36,173],"texture":0},"east":{"uv":[0,158,16,173],"texture":0},"south":{"uv":[52,158,72,173],"texture":0},"west":{"uv":[36,158,52,173],"texture":0},"up":{"uv":[16,142,36,158],"texture":0},"down":{"uv":[36,142,56,158],"texture":0}},"type":"cube","uuid":"a7852711-dd06-4a7e-ac82-52f70048fd84"},{"name":"hunched_back_cowl","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[-1,44,-3],"to":[17,56,12],"autouv":0,"color":0,"origin":[8,50,4.5],"faces":{"north":{"uv":[87,157,105,169],"texture":0},"east":{"uv":[72,157,87,169],"texture":0},"south":{"uv":[120,157,138,169],"texture":0},"west":{"uv":[105,157,120,169],"texture":0},"up":{"uv":[87,142,105,157],"texture":0},"down":{"uv":[105,142,123,157],"texture":0}},"type":"cube","uuid":"b6e91bfa-c49f-4076-beb5-79f94b59ba22"},{"name":"back_bent_door_slab","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[-3,33,-1],"to":[4,52,3],"autouv":0,"color":0,"origin":[0.5,42.5,1],"faces":{"north":{"uv":[142,146,149,165],"texture":0},"east":{"uv":[138,146,142,165],"texture":0},"south":{"uv":[153,146,160,165],"texture":0},"west":{"uv":[149,146,153,165],"texture":0},"up":{"uv":[142,142,149,146],"texture":0},"down":{"uv":[149,142,156,146],"texture":0}},"type":"cube","uuid":"6f8a4f40-6bd1-4e2b-badf-55f95f04f17f"},{"name":"door_iron_hinge_top","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[-3.25,47,-0.08],"to":[1,49,1.92],"autouv":0,"color":0,"origin":[-1.125,48,0.92],"faces":{"north":{"uv":[162,144,166,146],"texture":0},"east":{"uv":[160,144,162,146],"texture":0},"south":{"uv":[168,144,172,146],"texture":0},"west":{"uv":[166,144,168,146],"texture":0},"up":{"uv":[162,142,166,144],"texture":0},"down":{"uv":[166,142,170,144],"texture":0}},"type":"cube","uuid":"6f88ee94-f703-4158-abc2-57793be884e4"},{"name":"door_iron_hinge_bottom","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[-3.25,36,0],"to":[1,38,2],"autouv":0,"color":0,"origin":[-1.125,37,1],"faces":{"north":{"uv":[174,144,178,146],"texture":0},"east":{"uv":[172,144,174,146],"texture":0},"south":{"uv":[180,144,184,146],"texture":0},"west":{"uv":[178,144,180,146],"texture":0},"up":{"uv":[174,142,178,144],"texture":0},"down":{"uv":[178,142,182,144],"texture":0}},"type":"cube","uuid":"b573cebf-1c90-4d12-b69b-47b698916014"},{"name":"back_rusted_iron_slab","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[12,34,-2],"to":[19,51,2],"autouv":0,"color":0,"origin":[15.5,42.5,0],"faces":{"north":{"uv":[4,177,11,194],"texture":0},"east":{"uv":[0,177,4,194],"texture":0},"south":{"uv":[15,177,22,194],"texture":0},"west":{"uv":[11,177,15,194],"texture":0},"up":{"uv":[4,173,11,177],"texture":0},"down":{"uv":[11,173,18,177],"texture":0}},"type":"cube","uuid":"89711c10-99ad-4ca1-8ff9-beb0f51ab09d"},{"name":"back_spine_vent_housing","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[5,36,-2],"to":[11,48,2],"autouv":0,"color":0,"origin":[8,42,0],"faces":{"north":{"uv":[26,177,32,189],"texture":0},"east":{"uv":[22,177,26,189],"texture":0},"south":{"uv":[36,177,42,189],"texture":0},"west":{"uv":[32,177,36,189],"texture":0},"up":{"uv":[26,173,32,177],"texture":0},"down":{"uv":[32,173,38,177],"texture":0}},"type":"cube","uuid":"5dc21e5c-9ed2-4658-8fdb-dd10b6762666"},{"name":"back_vent_grille_lower","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[5.5,37,-2.25],"to":[10.5,41,-1.75],"autouv":0,"color":0,"origin":[8,39,-2],"faces":{"north":{"uv":[43,174,48,178],"texture":0},"east":{"uv":[42,174,43,178],"texture":0},"south":{"uv":[49,174,54,178],"texture":0},"west":{"uv":[48,174,49,178],"texture":0},"up":{"uv":[43,173,48,174],"texture":0},"down":{"uv":[48,173,53,174],"texture":0}},"type":"cube","uuid":"c4d509fa-9d92-4a50-9556-87c7533bdaaf"},{"name":"back_vent_grille_upper","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[5.5,43,-2.25],"to":[10.5,47,-1.75],"autouv":0,"color":0,"origin":[8,45,-2],"faces":{"north":{"uv":[55,174,60,178],"texture":0},"east":{"uv":[54,174,55,178],"texture":0},"south":{"uv":[61,174,66,178],"texture":0},"west":{"uv":[60,174,61,178],"texture":0},"up":{"uv":[55,173,60,174],"texture":0},"down":{"uv":[60,173,65,174],"texture":0}},"type":"cube","uuid":"e5b5974f-39b9-436d-a23d-8a75378afa23"},{"name":"steam_vent_pipe_left","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[-2,48,2],"to":[0,57,5],"autouv":0,"color":0,"origin":[-1,52.5,3.5],"faces":{"north":{"uv":[69,176,71,185],"texture":0},"east":{"uv":[66,176,69,185],"texture":0},"south":{"uv":[74,176,76,185],"texture":0},"west":{"uv":[71,176,74,185],"texture":0},"up":{"uv":[69,173,71,176],"texture":0},"down":{"uv":[71,173,73,176],"texture":0}},"type":"cube","uuid":"303a3115-0449-4ff4-b8de-522435b11638"},{"name":"steam_vent_particle_left","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[-1.75,57.08,2.25],"to":[-0.25,59.08,4.75],"autouv":0,"color":0,"origin":[-1,58.08,3.5],"faces":{"north":{"uv":[79,176,81,178],"texture":0},"east":{"uv":[76,176,79,178],"texture":0},"south":{"uv":[84,176,86,178],"texture":0},"west":{"uv":[81,176,84,178],"texture":0},"up":{"uv":[79,173,81,176],"texture":0},"down":{"uv":[81,173,83,176],"texture":0}},"type":"cube","uuid":"be8a9872-45bc-4790-b2fc-ea66a7ce93f8"},{"name":"steam_vent_pipe_right","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[16,48,2.08],"to":[18,57,5.08],"autouv":0,"color":0,"origin":[17,52.5,3.58],"faces":{"north":{"uv":[89,176,91,185],"texture":0},"east":{"uv":[86,176,89,185],"texture":0},"south":{"uv":[94,176,96,185],"texture":0},"west":{"uv":[91,176,94,185],"texture":0},"up":{"uv":[89,173,91,176],"texture":0},"down":{"uv":[91,173,93,176],"texture":0}},"type":"cube","uuid":"4f926539-0feb-4a5d-9171-925d0fd54100"},{"name":"steam_vent_particle_right","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[16.25,57.08,2.25],"to":[17.75,59.08,4.75],"autouv":0,"color":0,"origin":[17,58.08,3.5],"faces":{"north":{"uv":[99,176,101,178],"texture":0},"east":{"uv":[96,176,99,178],"texture":0},"south":{"uv":[104,176,106,178],"texture":0},"west":{"uv":[101,176,104,178],"texture":0},"up":{"uv":[99,173,101,176],"texture":0},"down":{"uv":[101,173,103,176],"texture":0}},"type":"cube","uuid":"da0ed065-ff10-4a95-a114-c43a831c6e0f"},{"name":"recessed_neck_collar","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[3,38,13],"to":[13,44,21],"autouv":0,"color":0,"origin":[8,41,17],"faces":{"north":{"uv":[114,181,124,187],"texture":0},"east":{"uv":[106,181,114,187],"texture":0},"south":{"uv":[132,181,142,187],"texture":0},"west":{"uv":[124,181,132,187],"texture":0},"up":{"uv":[114,173,124,181],"texture":0},"down":{"uv":[124,173,134,181],"texture":0}},"type":"cube","uuid":"5191e634-694f-4487-88af-236ca2239942"},{"name":"dark_iron_mask","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[5,40,15],"to":[11,47,21],"autouv":0,"color":0,"origin":[8,43.5,18],"faces":{"north":{"uv":[148,179,154,186],"texture":0},"east":{"uv":[142,179,148,186],"texture":0},"south":{"uv":[160,179,166,186],"texture":0},"west":{"uv":[154,179,160,186],"texture":0},"up":{"uv":[148,173,154,179],"texture":0},"down":{"uv":[154,173,160,179],"texture":0}},"type":"cube","uuid":"17d716fb-94c3-4e35-ba6e-55d6f75f0033"},{"name":"mask_visor_brow","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[5.25,44.75,20.5],"to":[10.75,46.25,21.5],"autouv":0,"color":0,"origin":[8,45.5,21],"faces":{"north":{"uv":[167,174,173,176],"texture":0},"east":{"uv":[166,174,167,176],"texture":0},"south":{"uv":[174,174,180,176],"texture":0},"west":{"uv":[173,174,174,176],"texture":0},"up":{"uv":[167,173,173,174],"texture":0},"down":{"uv":[173,173,179,174],"texture":0}},"type":"cube","uuid":"8289ac8c-fb71-4a3b-98e5-6ca76c05a48d"},{"name":"eye_left","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[6,43.25,20.75],"to":[7.5,44.25,21.25],"autouv":0,"color":0,"origin":[6.75,43.75,21],"faces":{"north":{"uv":[181,174,183,175],"texture":0},"east":{"uv":[180,174,181,175],"texture":0},"south":{"uv":[184,174,186,175],"texture":0},"west":{"uv":[183,174,184,175],"texture":0},"up":{"uv":[181,173,183,174],"texture":0},"down":{"uv":[183,173,185,174],"texture":0}},"type":"cube","uuid":"32967663-c3b0-4883-bb15-ec85a6dd48f2"},{"name":"eye_right","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[8.5,43.25,20.75],"to":[10,44.25,21.25],"autouv":0,"color":0,"origin":[9.25,43.75,21],"faces":{"north":{"uv":[187,174,189,175],"texture":0},"east":{"uv":[186,174,187,175],"texture":0},"south":{"uv":[190,174,192,175],"texture":0},"west":{"uv":[189,174,190,175],"texture":0},"up":{"uv":[187,173,189,174],"texture":0},"down":{"uv":[189,173,191,174],"texture":0}},"type":"cube","uuid":"5521353e-2c29-4e4e-9e2b-670869cbda87"},{"name":"mask_jaw_plate","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[5.5,40.25,20.5],"to":[10.5,42.25,21.25],"autouv":0,"color":0,"origin":[8,41.25,20.875],"faces":{"north":{"uv":[1,195,6,197],"texture":0},"east":{"uv":[0,195,1,197],"texture":0},"south":{"uv":[7,195,12,197],"texture":0},"west":{"uv":[6,195,7,197],"texture":0},"up":{"uv":[1,194,6,195],"texture":0},"down":{"uv":[6,194,11,195],"texture":0}},"type":"cube","uuid":"59efb985-113f-4f35-b405-c37f5c34dfdb"},{"name":"left_shoulder_base","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[-8.08,38,8],"to":[-1.08,49,18],"autouv":0,"color":0,"origin":[-4.58,43.5,13],"faces":{"north":{"uv":[22,204,29,215],"texture":0},"east":{"uv":[12,204,22,215],"texture":0},"south":{"uv":[39,204,46,215],"texture":0},"west":{"uv":[29,204,39,215],"texture":0},"up":{"uv":[22,194,29,204],"texture":0},"down":{"uv":[29,194,36,204],"texture":0}},"type":"cube","uuid":"91fac475-b378-4034-aabf-7cd222502d11"},{"name":"left_pauldron_rusted_slab","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[-9,41,7],"to":[-1.5,51,19],"autouv":0,"color":0,"origin":[-5.25,46,13],"faces":{"north":{"uv":[58,206,66,216],"texture":0},"east":{"uv":[46,206,58,216],"texture":0},"south":{"uv":[78,206,86,216],"texture":0},"west":{"uv":[66,206,78,216],"texture":0},"up":{"uv":[58,194,66,206],"texture":0},"down":{"uv":[66,194,74,206],"texture":0}},"type":"cube","uuid":"4ccabb3e-e110-4db6-8aaa-88a85d504204"},{"name":"left_arm_pressure_vent","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[-8.58,43,11],"to":[-8.18,47,15],"autouv":0,"color":0,"origin":[-8.38,45,13],"faces":{"north":{"uv":[90,198,91,202],"texture":0},"east":{"uv":[86,198,90,202],"texture":0},"south":{"uv":[95,198,96,202],"texture":0},"west":{"uv":[91,198,95,202],"texture":0},"up":{"uv":[90,194,91,198],"texture":0},"down":{"uv":[91,194,92,198],"texture":0}},"type":"cube","uuid":"6a62b60e-156f-4b12-85a7-94ada78e1265"},{"name":"left_arm_upper","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[-7.08,25,10],"to":[-2.08,39,16],"autouv":0,"color":0,"origin":[-4.58,32,13],"faces":{"north":{"uv":[102,200,107,214],"texture":0},"east":{"uv":[96,200,102,214],"texture":0},"south":{"uv":[113,200,118,214],"texture":0},"west":{"uv":[107,200,113,214],"texture":0},"up":{"uv":[102,194,107,200],"texture":0},"down":{"uv":[107,194,112,200],"texture":0}},"type":"cube","uuid":"c5454985-d6ee-4c44-8c69-52fc718ee178"},{"name":"left_elbow_plate","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[-7.5,23,9.5],"to":[-1.5,27,16.5],"autouv":0,"color":0,"origin":[-4.5,25,13],"faces":{"north":{"uv":[125,201,131,205],"texture":0},"east":{"uv":[118,201,125,205],"texture":0},"south":{"uv":[138,201,144,205],"texture":0},"west":{"uv":[131,201,138,205],"texture":0},"up":{"uv":[125,194,131,201],"texture":0},"down":{"uv":[131,194,137,201],"texture":0}},"type":"cube","uuid":"645f9093-dac8-45e3-b953-dcf0bfcf6188"},{"name":"left_forearm_heavy","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[-8,10,11],"to":[-1,26,18],"autouv":0,"color":0,"origin":[-4.5,18,14.5],"faces":{"north":{"uv":[151,201,158,217],"texture":0},"east":{"uv":[144,201,151,217],"texture":0},"south":{"uv":[165,201,172,217],"texture":0},"west":{"uv":[158,201,165,217],"texture":0},"up":{"uv":[151,194,158,201],"texture":0},"down":{"uv":[158,194,165,201],"texture":0}},"type":"cube","uuid":"8e56c982-3748-45f7-81fa-4197c25aed5f"},{"name":"left_fist_main","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[-8.5,2,10],"to":[-0.5,11,19],"autouv":0,"color":0,"origin":[-4.5,6.5,14.5],"faces":{"north":{"uv":[9,226,17,235],"texture":0},"east":{"uv":[0,226,9,235],"texture":0},"south":{"uv":[26,226,34,235],"texture":0},"west":{"uv":[17,226,26,235],"texture":0},"up":{"uv":[9,217,17,226],"texture":0},"down":{"uv":[17,217,25,226],"texture":0}},"type":"cube","uuid":"4c73612e-5922-4173-9def-e7d11dac3835"},{"name":"left_fist_knuckle_1","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[-8,1,11],"to":[-5,4,18.5],"autouv":0,"color":0,"origin":[-6.5,2.5,14.75],"faces":{"north":{"uv":[42,225,45,228],"texture":0},"east":{"uv":[34,225,42,228],"texture":0},"south":{"uv":[53,225,56,228],"texture":0},"west":{"uv":[45,225,53,228],"texture":0},"up":{"uv":[42,217,45,225],"texture":0},"down":{"uv":[45,217,48,225],"texture":0}},"type":"cube","uuid":"7e24324e-00e0-4974-9e39-3b7da0503509"},{"name":"left_fist_knuckle_2","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[-4.5,1,11],"to":[-1,4,18.5],"autouv":0,"color":0,"origin":[-2.75,2.5,14.75],"faces":{"north":{"uv":[64,225,68,228],"texture":0},"east":{"uv":[56,225,64,228],"texture":0},"south":{"uv":[76,225,80,228],"texture":0},"west":{"uv":[68,225,76,228],"texture":0},"up":{"uv":[64,217,68,225],"texture":0},"down":{"uv":[68,217,72,225],"texture":0}},"type":"cube","uuid":"d4a5ce3c-b916-4ad6-a588-210f0a5beb90"},{"name":"left_fist_band","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[-8.75,6,9.75],"to":[-0.25,8.5,19.25],"autouv":0,"color":0,"origin":[-4.5,7.25,14.5],"faces":{"north":{"uv":[90,227,99,230],"texture":0},"east":{"uv":[80,227,90,230],"texture":0},"south":{"uv":[109,227,118,230],"texture":0},"west":{"uv":[99,227,109,230],"texture":0},"up":{"uv":[90,217,99,227],"texture":0},"down":{"uv":[99,217,108,227],"texture":0}},"type":"cube","uuid":"f53ed599-96c7-4407-9776-a90067fd2d45"},{"name":"right_shoulder_base","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[17.08,38,8],"to":[24.08,49,18],"autouv":0,"color":0,"origin":[20.58,43.5,13],"faces":{"north":{"uv":[128,227,135,238],"texture":0},"east":{"uv":[118,227,128,238],"texture":0},"south":{"uv":[145,227,152,238],"texture":0},"west":{"uv":[135,227,145,238],"texture":0},"up":{"uv":[128,217,135,227],"texture":0},"down":{"uv":[135,217,142,227],"texture":0}},"type":"cube","uuid":"b86aeff8-0949-4642-9ed1-09886bde84ff"},{"name":"right_pauldron_golem_slice","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[17.5,40,6.5],"to":[25,50,18.5],"autouv":0,"color":0,"origin":[21.25,45,12.5],"faces":{"north":{"uv":[164,229,172,239],"texture":0},"east":{"uv":[152,229,164,239],"texture":0},"south":{"uv":[184,229,192,239],"texture":0},"west":{"uv":[172,229,184,239],"texture":0},"up":{"uv":[164,217,172,229],"texture":0},"down":{"uv":[172,217,180,229],"texture":0}},"type":"cube","uuid":"735dc2b9-f850-4aa4-95a7-579d43cfcabd"},{"name":"right_arm_pressure_vent","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[24.18,43,11],"to":[24.58,47,15],"autouv":0,"color":0,"origin":[24.38,45,13],"faces":{"north":{"uv":[4,243,5,247],"texture":0},"east":{"uv":[0,243,4,247],"texture":0},"south":{"uv":[9,243,10,247],"texture":0},"west":{"uv":[5,243,9,247],"texture":0},"up":{"uv":[4,239,5,243],"texture":0},"down":{"uv":[5,239,6,243],"texture":0}},"type":"cube","uuid":"d63b4ed7-1333-4e01-a985-efa75f65fa0b"},{"name":"right_arm_upper","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[18.08,25,10],"to":[23.08,39,16],"autouv":0,"color":0,"origin":[20.58,32,13],"faces":{"north":{"uv":[16,245,21,259],"texture":0},"east":{"uv":[10,245,16,259],"texture":0},"south":{"uv":[27,245,32,259],"texture":0},"west":{"uv":[21,245,27,259],"texture":0},"up":{"uv":[16,239,21,245],"texture":0},"down":{"uv":[21,239,26,245],"texture":0}},"type":"cube","uuid":"1c18e020-ba87-4ac0-bfdc-237fb4228d48"},{"name":"right_elbow_plate","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[17.5,23,9.5],"to":[23.5,27,16.5],"autouv":0,"color":0,"origin":[20.5,25,13],"faces":{"north":{"uv":[39,246,45,250],"texture":0},"east":{"uv":[32,246,39,250],"texture":0},"south":{"uv":[52,246,58,250],"texture":0},"west":{"uv":[45,246,52,250],"texture":0},"up":{"uv":[39,239,45,246],"texture":0},"down":{"uv":[45,239,51,246],"texture":0}},"type":"cube","uuid":"6ddcb853-157e-410f-bb5d-1962d0bc2072"},{"name":"right_forearm_outer_plate","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[17,12,10],"to":[24,26,17],"autouv":0,"color":0,"origin":[20.5,19,13.5],"faces":{"north":{"uv":[65,246,72,260],"texture":0},"east":{"uv":[58,246,65,260],"texture":0},"south":{"uv":[79,246,86,260],"texture":0},"west":{"uv":[72,246,79,260],"texture":0},"up":{"uv":[65,239,72,246],"texture":0},"down":{"uv":[72,239,79,246],"texture":0}},"type":"cube","uuid":"70f3370b-4c31-4b1c-8fd2-f35af6fc0d2d"},{"name":"right_frail_arm_peeking","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[19,8,12],"to":[22,20,15],"autouv":0,"color":0,"origin":[20.5,14,13.5],"faces":{"north":{"uv":[89,242,92,254],"texture":0},"east":{"uv":[86,242,89,254],"texture":0},"south":{"uv":[95,242,98,254],"texture":0},"west":{"uv":[92,242,95,254],"texture":0},"up":{"uv":[89,239,92,242],"texture":0},"down":{"uv":[92,239,95,242],"texture":0}},"type":"cube","uuid":"75132bbd-18e0-4469-9698-6fe18b377d2c"},{"name":"right_hand_overhanging_guard","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[17,6,11],"to":[24,11,18],"autouv":0,"color":0,"origin":[20.5,8.5,14.5],"faces":{"north":{"uv":[105,246,112,251],"texture":0},"east":{"uv":[98,246,105,251],"texture":0},"south":{"uv":[119,246,126,251],"texture":0},"west":{"uv":[112,246,119,251],"texture":0},"up":{"uv":[105,239,112,246],"texture":0},"down":{"uv":[112,239,119,246],"texture":0}},"type":"cube","uuid":"3cbf7223-fc0f-48b9-86a2-6c656a12ea34"},{"name":"right_withered_palm","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[18.5,4,12.5],"to":[22.5,7,16.5],"autouv":0,"color":0,"origin":[20.5,5.5,14.5],"faces":{"north":{"uv":[130,243,134,246],"texture":0},"east":{"uv":[126,243,130,246],"texture":0},"south":{"uv":[138,243,142,246],"texture":0},"west":{"uv":[134,243,138,246],"texture":0},"up":{"uv":[130,239,134,243],"texture":0},"down":{"uv":[134,239,138,243],"texture":0}},"type":"cube","uuid":"ac5addf5-54f1-466a-b0bb-bec9fc63d220"},{"name":"right_withered_finger_1","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[18.75,0.5,13],"to":[19.5,4.5,14],"autouv":0,"color":0,"origin":[19.125,2.5,13.5],"faces":{"north":{"uv":[143,240,144,244],"texture":0},"east":{"uv":[142,240,143,244],"texture":0},"south":{"uv":[145,240,146,244],"texture":0},"west":{"uv":[144,240,145,244],"texture":0},"up":{"uv":[143,239,144,240],"texture":0},"down":{"uv":[144,239,145,240],"texture":0}},"type":"cube","uuid":"f1b3064a-4752-44c6-88e4-ddc4c9b7003e"},{"name":"right_withered_finger_2","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[20,0,13.5],"to":[20.8,4.5,14.5],"autouv":0,"color":0,"origin":[20.4,2.25,14],"faces":{"north":{"uv":[147,240,148,245],"texture":0},"east":{"uv":[146,240,147,245],"texture":0},"south":{"uv":[149,240,150,245],"texture":0},"west":{"uv":[148,240,149,245],"texture":0},"up":{"uv":[147,239,148,240],"texture":0},"down":{"uv":[148,239,149,240],"texture":0}},"type":"cube","uuid":"ec856743-2a9b-4e11-9cdb-c2ade9041d99"},{"name":"right_withered_finger_3","box_uv":false,"render_order":"default","locked":false,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[21.3,0.5,13],"to":[22.1,4.5,14],"autouv":0,"color":0,"origin":[21.7,2.5,13.5],"faces":{"north":{"uv":[151,240,152,244],"texture":0},"east":{"uv":[150,240,151,244],"texture":0},"south":{"uv":[153,240,154,244],"texture":0},"west":{"uv":[152,240,153,244],"texture":0},"up":{"uv":[151,239,152,240],"texture":0},"down":{"uv":[152,239,153,240],"texture":0}},"type":"cube","uuid":"fb64dd76-6ad9-481b-82fb-74ca19b52047"},{"name":"hitbox","box_uv":false,"render_order":"default","locked":true,"export":true,"scope":0,"allow_mirror_modeling":true,"from":[-9,-0.08,-3],"to":[25,59.08,21.5],"autouv":0,"color":0,"visibility":false,"origin":[8,-0.08,9.25],"faces":{"north":{"uv":[0,0,1,1],"texture":0},"east":{"uv":[0,0,1,1],"texture":0},"south":{"uv":[0,0,1,1],"texture":0},"west":{"uv":[0,0,1,1],"texture":0},"up":{"uv":[0,0,1,1],"texture":0},"down":{"uv":[0,0,1,1],"texture":0}},"type":"cube","uuid":"c1d936d7-c797-450b-b07b-a3319be50a69"}],"groups":[{"name":"root","uuid":"a87b02f7-2e0f-4b4b-a115-3e491765572d","export":true,"locked":false,"scope":0,"selected":false,"_static":{"properties":{},"temp_data":{}},"origin":[0,0,0],"rotation":[0,0,0],"color":0,"children":[],"reset":false,"shade":true,"mirror_uv":false,"visibility":true,"autouv":0,"isOpen":true,"primary_selected":false},{"name":"hitbox","uuid":"68caf434-0c78-4d82-87a4-e69914bb5739","export":true,"locked":true,"scope":0,"selected":false,"_static":{"properties":{},"temp_data":{}},"origin":[8,-0.08,9.25],"rotation":[0,0,0],"color":0,"children":[],"reset":false,"shade":true,"mirror_uv":false,"visibility":false,"autouv":0,"isOpen":false,"primary_selected":false},{"name":"legs","uuid":"dbdc7e75-5754-48f9-9156-b920a3a86db5","export":true,"locked":false,"scope":0,"selected":false,"_static":{"properties":{},"temp_data":{}},"origin":[8,22,9],"rotation":[0,0,0],"color":0,"children":[],"reset":false,"shade":true,"mirror_uv":false,"visibility":true,"autouv":0,"isOpen":true,"primary_selected":true},{"name":"inner_body","uuid":"dd20dbbc-86d4-4473-99f4-067c11da8894","export":true,"locked":false,"scope":0,"selected":false,"_static":{"properties":{},"temp_data":{}},"origin":[8,27.46,10],"rotation":[0,0,0],"color":0,"children":[],"reset":false,"shade":true,"mirror_uv":false,"visibility":true,"autouv":0,"isOpen":true,"primary_selected":false},{"name":"torso","uuid":"1b55306c-7a6d-458c-b4ca-6a4fbddfe461","export":true,"locked":false,"scope":0,"selected":false,"_static":{"properties":{},"temp_data":{}},"origin":[7.875,40.04,9.25],"rotation":[0,0,0],"color":0,"children":[],"reset":false,"shade":true,"mirror_uv":false,"visibility":true,"autouv":0,"isOpen":true,"primary_selected":false},{"name":"head","uuid":"c92ca07a-eefd-46ed-a8e4-ae825536f36d","export":true,"locked":false,"scope":0,"selected":false,"_static":{"properties":{},"temp_data":{}},"origin":[8,38,17.25],"rotation":[0,0,0],"color":0,"children":[],"reset":false,"shade":true,"mirror_uv":false,"visibility":true,"autouv":0,"isOpen":false,"primary_selected":false},{"name":"left_arm","uuid":"4ae77681-171a-45ab-8998-004cfb2d7d41","export":true,"locked":false,"scope":0,"selected":false,"_static":{"properties":{},"temp_data":{}},"origin":[-1.08,49,13],"rotation":[0,0,0],"color":0,"children":[],"reset":false,"shade":true,"mirror_uv":false,"visibility":true,"autouv":0,"isOpen":false,"primary_selected":false},{"name":"right_arm","uuid":"60f01a01-8929-47c5-9114-6e2acc8327d9","export":true,"locked":false,"scope":0,"selected":false,"_static":{"properties":{},"temp_data":{}},"origin":[17.08,49,13],"rotation":[0,0,0],"color":0,"children":[],"reset":false,"shade":true,"mirror_uv":false,"visibility":true,"autouv":0,"isOpen":false,"primary_selected":false}],"outliner":[{"uuid":"a87b02f7-2e0f-4b4b-a115-3e491765572d","isOpen":true,"children":[{"uuid":"68caf434-0c78-4d82-87a4-e69914bb5739","isOpen":false,"children":["c1d936d7-c797-450b-b07b-a3319be50a69"]},{"uuid":"dbdc7e75-5754-48f9-9156-b920a3a86db5","isOpen":true,"children":["9ae4ffe3-8068-4c33-902e-72805423e293","a3046513-da6f-46f0-95c0-f5dc5c5ea0a3","897732bc-7362-4c83-8226-ba730f9f6496","8df975d0-e207-404e-8929-df31cab84fc9","7d5fe12a-c6c8-4b68-a128-e6e42c9b1616","eb6c6b77-257f-49eb-bb25-44a0ec73ef78","b4f9900d-4891-4183-9204-a57a793f6956","9421cb65-3809-49b9-8028-b08897713e8d","fc592f19-c82b-4878-87c8-38bf2019a400","ee94f15d-4938-49c9-b521-af740aea0a45"]},{"uuid":"dd20dbbc-86d4-4473-99f4-067c11da8894","isOpen":true,"children":["c7b8f08f-6bac-4a11-8499-867fa8b2bd5e","b8e7ecc5-6b10-46f8-8a2e-f8095ca4862a","bcfdac59-6fe9-4f25-9b79-8859778458f8"]},{"uuid":"1b55306c-7a6d-458c-b4ca-6a4fbddfe461","isOpen":true,"children":["82f0b41a-6ecc-4f63-bf35-05d788509fa2","8b3b4567-d8b0-4ba4-a82c-e45bfd9ad79c","b88b66ee-9cf8-4221-978a-39075701ed85","ed2962da-a259-4179-9bdc-6f9bc415e001","1119dfd5-92eb-48ac-934b-7d1b96df2cc5","a7852711-dd06-4a7e-ac82-52f70048fd84","b6e91bfa-c49f-4076-beb5-79f94b59ba22","6f8a4f40-6bd1-4e2b-badf-55f95f04f17f","6f88ee94-f703-4158-abc2-57793be884e4","b573cebf-1c90-4d12-b69b-47b698916014","89711c10-99ad-4ca1-8ff9-beb0f51ab09d","5dc21e5c-9ed2-4658-8fdb-dd10b6762666","c4d509fa-9d92-4a50-9556-87c7533bdaaf","e5b5974f-39b9-436d-a23d-8a75378afa23","303a3115-0449-4ff4-b8de-522435b11638","be8a9872-45bc-4790-b2fc-ea66a7ce93f8","4f926539-0feb-4a5d-9171-925d0fd54100","da0ed065-ff10-4a95-a114-c43a831c6e0f"]},{"uuid":"c92ca07a-eefd-46ed-a8e4-ae825536f36d","isOpen":false,"children":["5191e634-694f-4487-88af-236ca2239942","17d716fb-94c3-4e35-ba6e-55d6f75f0033","8289ac8c-fb71-4a3b-98e5-6ca76c05a48d","32967663-c3b0-4883-bb15-ec85a6dd48f2","5521353e-2c29-4e4e-9e2b-670869cbda87","59efb985-113f-4f35-b405-c37f5c34dfdb"]},{"uuid":"4ae77681-171a-45ab-8998-004cfb2d7d41","isOpen":false,"children":["91fac475-b378-4034-aabf-7cd222502d11","4ccabb3e-e110-4db6-8aaa-88a85d504204","6a62b60e-156f-4b12-85a7-94ada78e1265","c5454985-d6ee-4c44-8c69-52fc718ee178","645f9093-dac8-45e3-b953-dcf0bfcf6188","8e56c982-3748-45f7-81fa-4197c25aed5f","4c73612e-5922-4173-9def-e7d11dac3835","7e24324e-00e0-4974-9e39-3b7da0503509","d4a5ce3c-b916-4ad6-a588-210f0a5beb90","f53ed599-96c7-4407-9776-a90067fd2d45"]},{"uuid":"60f01a01-8929-47c5-9114-6e2acc8327d9","isOpen":false,"children":["b86aeff8-0949-4642-9ed1-09886bde84ff","735dc2b9-f850-4aa4-95a7-579d43cfcabd","d63b4ed7-1333-4e01-a985-efa75f65fa0b","1c18e020-ba87-4ac0-bfdc-237fb4228d48","6ddcb853-157e-410f-bb5d-1962d0bc2072","70f3370b-4c31-4b1c-8fd2-f35af6fc0d2d","75132bbd-18e0-4469-9698-6fe18b377d2c","3cbf7223-fc0f-48b9-86a2-6c656a12ea34","ac5addf5-54f1-466a-b0bb-bec9fc63d220","f1b3064a-4752-44c6-88e4-ddc4c9b7003e","ec856743-2a9b-4e11-9cdb-c2ade9041d99","fb64dd76-6ad9-481b-82fb-74ca19b52047"]}]}],"textures":[{"name":"junk_iron_colossus.png","relative_path":"../block/junk_iron_colossus.png","folder":"","namespace":"","id":"197168a9-dcba-41b4-b3ec-39ce66fbff3e","group":"","scope":0,"width":1552,"height":2080,"uv_width":194,"uv_height":260,"particle":false,"use_as_default":false,"layers_enabled":false,"sync_to_project":"","file_format":"png","render_mode":"default","render_sides":"auto","wrap_mode":"limited","pbr_channel":"color","fps":7,"frame_time":1,"frame_order_type":"loop","frame_order":"","frame_interpolate":false,"visible":true,"internal":true,"saved":true,"uuid":"197168a9-dcba-41b4-b3ec-39ce66fbff3e","source":"data:image/png;base64,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"}],"animations":[{"uuid":"c45c3389-ab50-4510-6d72-a4d147353005","name":"awaken","loop":"once","override":false,"length":6,"snapping":24,"selected":false,"group_name":"","scope":0,"anim_time_update":"","blend_weight":"","start_delay":"","loop_delay":"","animators":{"a87b02f7-2e0f-4b4b-a115-3e491765572d":{"name":"root","type":"bone","rotation_global":false,"quaternion_interpolation":false},"68caf434-0c78-4d82-87a4-e69914bb5739":{"name":"hitbox","type":"bone","rotation_global":false,"quaternion_interpolation":false},"dbdc7e75-5754-48f9-9156-b920a3a86db5":{"name":"legs","type":"bone","rotation_global":false,"quaternion_interpolation":false},"dd20dbbc-86d4-4473-99f4-067c11da8894":{"name":"inner_body","type":"bone","rotation_global":false,"quaternion_interpolation":false},"1b55306c-7a6d-458c-b4ca-6a4fbddfe461":{"name":"torso","type":"bone","rotation_global":false,"quaternion_interpolation":false,"keyframes":[{"channel":"position","data_points":[{"x":"0","y":"-10","z":"0"}],"uuid":"614f75fe-6c47-761b-5b27-a50161feedc4","time":0,"color":-1,"interpolation":"linear"},{"channel":"position","data_points":[{"x":"0","y":"0","z":"0"}],"uuid":"c9a1a7d0-cc41-1e85-bd9c-958bbdca6237","time":0.75,"color":-1,"interpolation":"linear"},{"channel":"position","data_points":[{"x":"0","y":"0","z":"0"}],"uuid":"3885c394-430a-ede4-52a8-8123991878b4","time":1.25,"color":-1,"interpolation":"linear"},{"channel":"position","data_points":[{"x":"0","y":"-7","z":"0"}],"uuid":"dbcfae0b-f46c-1047-6f67-3dcb6f5e296a","time":1.375,"color":-1,"interpolation":"linear"},{"channel":"position","data_points":[{"x":"0","y":"-7","z":"0"}],"uuid":"5728e720-2a49-623c-c07d-3e8e1454aa1e","time":2.25,"color":-1,"interpolation":"linear"},{"channel":"position","data_points":[{"x":"0","y":"0","z":"0"}],"uuid":"bf137afb-53ac-ed1a-6d96-7699addb4abf","time":2.75,"color":-1,"interpolation":"linear"}]},"c92ca07a-eefd-46ed-a8e4-ae825536f36d":{"name":"head","type":"bone","rotation_global":false,"quaternion_interpolation":false,"keyframes":[{"channel":"position","data_points":[{"x":"0","y":"-10","z":"0"}],"uuid":"efad16e0-cb14-2ce8-c0ad-1d0173e6cbdf","time":0,"color":-1,"interpolation":"linear"},{"channel":"position","data_points":[{"x":"0","y":"0","z":"0"}],"uuid":"e3daf012-7310-e50f-b804-c0c1842ca48f","time":0.75,"color":-1,"interpolation":"linear"},{"channel":"position","data_points":[{"x":"0","y":"0","z":"0"}],"uuid":"37cad56d-e703-0261-a038-eda1e7b301f3","time":1.25,"color":-1,"interpolation":"linear"},{"channel":"position","data_points":[{"x":"0","y":"-7","z":"0"}],"uuid":"a9913993-d08c-99df-a45d-27ee63f32379","time":1.375,"color":-1,"interpolation":"linear"},{"channel":"position","data_points":[{"x":"0","y":"-7","z":"0"}],"uuid":"31ad5cba-1e7d-a1c5-7183-4325df616a1f","time":2.25,"color":-1,"interpolation":"linear"},{"channel":"position","data_points":[{"x":"0","y":"0","z":"0"}],"uuid":"61306138-4e76-09cc-bf11-db85a0907c2d","time":2.75,"color":-1,"interpolation":"linear"}]},"4ae77681-171a-45ab-8998-004cfb2d7d41":{"name":"left_arm","type":"bone","rotation_global":false,"quaternion_interpolation":false,"keyframes":[{"channel":"rotation","data_points":[{"x":"50","y":"0","z":"0"}],"uuid":"29a0e74d-0857-2ea7-f397-3645ea152e4b","time":0,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"310","y":"0","z":"0"}],"uuid":"f6e8a228-4c87-684b-fe1e-b47d39995a37","time":3.5,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"152.14","y":"0","z":"0"}],"uuid":"277bbcfb-e48f-618b-efbb-fb5f47bfae4a","time":1.375,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"152.14","y":"0","z":"0"}],"uuid":"29e1790b-27cc-d722-97f6-77657d983301","time":2.25,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"310","y":"0","z":"0"}],"uuid":"0acacd17-8cd6-afd0-0794-49e9e860ebe5","time":4.25,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"360","y":"0","z":"0"}],"uuid":"40af201b-3e1d-04e4-c68d-a0debf0df0f8","time":5.5,"color":-1,"interpolation":"linear"},{"channel":"position","data_points":[{"x":"0","y":"-20","z":"0"}],"uuid":"8e7c9c08-c9eb-3917-b179-13271aaf40c2","time":0,"color":-1,"interpolation":"linear"},{"channel":"position","data_points":[{"x":"0","y":"-20","z":"0"}],"uuid":"3f7674fc-5f5b-ddda-1ac0-bf0e9f7bd1ce","time":3.5,"color":-1,"interpolation":"linear"},{"channel":"position","data_points":[{"x":"0","y":"-22","z":"0"}],"uuid":"1ef17ed4-6bb9-6586-e7c2-7053a6674910","time":1.375,"color":-1,"interpolation":"linear"},{"channel":"position","data_points":[{"x":"0","y":"-22","z":"0"}],"uuid":"04796eb2-c046-f3a6-40c6-d675a3e48576","time":2.25,"color":-1,"interpolation":"linear"},{"channel":"position","data_points":[{"x":"0","y":"-20","z":"0"}],"uuid":"89dd14cf-5128-d954-cefd-dc0d48c08c06","time":4.25,"color":-1,"interpolation":"linear"},{"channel":"position","data_points":[{"x":"0","y":"-8","z":"0"}],"uuid":"1243eea2-b23d-3252-cebd-6de74bb71fea","time":5,"color":-1,"interpolation":"linear"},{"channel":"position","data_points":[{"x":"0","y":"0","z":"0"}],"uuid":"642deb11-2c60-a84b-f693-e384652145fd","time":5.5,"color":-1,"interpolation":"linear"}]},"60f01a01-8929-47c5-9114-6e2acc8327d9":{"name":"right_arm","type":"bone","rotation_global":false,"quaternion_interpolation":false,"keyframes":[{"channel":"rotation","data_points":[{"x":"55","y":"0","z":"0"}],"uuid":"33d72019-10fe-37e3-e15f-33a592ae5a20","time":0,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"310","y":"0","z":"0"}],"uuid":"b7b2f107-a0f8-410a-34bb-d7c11b21f197","time":3.75,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"148.5","y":"0","z":"0"}],"uuid":"d6ff5229-58e5-bf8e-e1e5-1fb4908bee5e","time":1.375,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"148.5","y":"0","z":"0"}],"uuid":"ceb4124b-5d33-72ce-46f8-e067ab106d1c","time":2.25,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"310","y":"0","z":"0"}],"uuid":"5aaa2c1b-46d3-926a-0d4f-2c588c0892bc","time":4.25,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"360","y":"0","z":"0"}],"uuid":"5cb0cac9-b1a7-ce0e-8123-b281ea61e24b","time":5.5,"color":-1,"interpolation":"linear"},{"channel":"position","data_points":[{"x":"0","y":"-20","z":"0"}],"uuid":"f0b7da3e-931a-4292-3db3-32eecb750176","time":0,"color":-1,"interpolation":"linear"},{"channel":"position","data_points":[{"x":"0","y":"-22","z":"0"}],"uuid":"e0e17600-1801-aea8-765c-49c2dda579a0","time":1.375,"color":-1,"interpolation":"linear"},{"channel":"position","data_points":[{"x":"0","y":"-22","z":"0"}],"uuid":"f2a4227d-81ba-9b10-53cf-aec086990ed2","time":2.25,"color":-1,"interpolation":"linear"},{"channel":"position","data_points":[{"x":"0","y":"-22","z":"0"}],"uuid":"888dd40b-595b-3278-ab6c-61fe3349c63d","time":4.25,"color":-1,"interpolation":"linear"},{"channel":"position","data_points":[{"x":"0","y":"-9","z":"0"}],"uuid":"cee36c62-a7fa-74f8-5d24-9fa4b6fe357a","time":5,"color":-1,"interpolation":"linear"},{"channel":"position","data_points":[{"x":"0","y":"1","z":"0"}],"uuid":"70d49e8c-e98e-5d35-a64f-720370160fed","time":5.5,"color":-1,"interpolation":"linear"}]}}},{"uuid":"49e27506-128a-45c9-2c6e-716482ad24a3","name":"slam","loop":"once","override":false,"length":6,"snapping":24,"selected":true,"group_name":"","scope":0,"anim_time_update":"","blend_weight":"","start_delay":"","loop_delay":"","animators":{"a87b02f7-2e0f-4b4b-a115-3e491765572d":{"name":"root","type":"bone","rotation_global":false,"quaternion_interpolation":false},"68caf434-0c78-4d82-87a4-e69914bb5739":{"name":"hitbox","type":"bone","rotation_global":false,"quaternion_interpolation":false},"dbdc7e75-5754-48f9-9156-b920a3a86db5":{"name":"legs","type":"bone","rotation_global":false,"quaternion_interpolation":false},"dd20dbbc-86d4-4473-99f4-067c11da8894":{"name":"inner_body","type":"bone","rotation_global":false,"quaternion_interpolation":false},"1b55306c-7a6d-458c-b4ca-6a4fbddfe461":{"name":"torso","type":"bone","rotation_global":false,"quaternion_interpolation":false,"keyframes":[{"channel":"rotation","data_points":[{"x":"0","y":"0","z":"0"}],"uuid":"4c05df53-f9ff-1307-1be9-5c29ded9bb2c","time":0,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"-10","y":"0","z":"0"}],"uuid":"167c37e4-73ff-a730-ea18-f5f2bf1fe6b2","time":2.25,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"-10","y":"0","z":"0"}],"uuid":"46f7d1d3-2ad2-1c63-2492-40bf58730bfa","time":2.5,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"-12.5","y":"0","z":"0"}],"uuid":"03cb71d3-1b9a-eac2-a0bf-92246d3052bc","time":3,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"0","y":"0","z":"0"}],"uuid":"fa645ec8-c699-db43-b3d8-79d6da0b9df2","time":3.16667,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"-5","y":"0","z":"0"}],"uuid":"1b906782-ee6f-074e-2fa6-3fbf4cbc589b","time":3.5,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"25","y":"0","z":"0"}],"uuid":"6a3f6b1c-1ae1-2ee5-6539-86f0430b680a","time":3.66667,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"25","y":"0","z":"0"}],"uuid":"dbc4e6fa-523c-c83c-82b9-8682f3ee2d3b","time":4.5,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"0","y":"0","z":"0"}],"uuid":"99294f96-f7e6-0783-328c-ea446ad696ff","time":5,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"12.5","y":"0","z":"0"}],"uuid":"5a740596-a459-35e2-6f21-d03e61380bd8","time":4.75,"color":-1,"interpolation":"linear"}]},"c92ca07a-eefd-46ed-a8e4-ae825536f36d":{"name":"head","type":"bone","rotation_global":false,"quaternion_interpolation":false,"keyframes":[{"channel":"rotation","data_points":[{"x":"0","y":"0","z":"0"}],"uuid":"1bb1d02c-6d9b-e6f6-1921-54c767893bb1","time":0,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"-10","y":"0","z":"0"}],"uuid":"e82be52a-b332-c978-80e9-66d464a27a54","time":2.25,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"-10","y":"0","z":"0"}],"uuid":"dced545e-210d-bdf8-fc2e-5bf100956e4d","time":2.5,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"-12.5","y":"0","z":"0"}],"uuid":"8f9a5537-f844-2b50-3abc-61112d7f3d8b","time":3,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"0","y":"0","z":"0"}],"uuid":"5a4fe54b-b62c-8b62-9edc-c92431b934c8","time":3.16667,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"-5","y":"0","z":"0"}],"uuid":"ee9fb267-4dcd-ba5b-ea61-a41419edc211","time":3.5,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"25","y":"0","z":"0"}],"uuid":"0ae2022e-958d-bc49-0dbd-e11fc5dcd034","time":3.66667,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"25","y":"0","z":"0"}],"uuid":"bb86a2b5-17b3-7f1e-e29a-251d9dc2a94c","time":4.5,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"0","y":"0","z":"0"}],"uuid":"5ff969c1-8c0f-25a6-963c-322f6d31826f","time":5,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"12.5","y":"0","z":"0"}],"uuid":"b9d82c7c-92fe-fbb0-3ddf-7d98b150881f","time":4.75,"color":-1,"interpolation":"linear"}]},"4ae77681-171a-45ab-8998-004cfb2d7d41":{"name":"left_arm","type":"bone","rotation_global":false,"quaternion_interpolation":false,"keyframes":[{"channel":"rotation","data_points":[{"x":"0","y":"0","z":"0"}],"uuid":"f81f838b-651e-0ee1-076d-46b32a0d65a8","time":0,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"-190","y":"0","z":"0"}],"uuid":"b6863210-9338-7986-7678-12da4cbf55b3","time":2.25,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"-190","y":"0","z":"0"}],"uuid":"6cafd5d0-8974-c4e3-8e14-c6c16f54432d","time":2.5,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"-197.5","y":"0","z":"0"}],"uuid":"9ddeb774-168c-82a3-7fb5-d3c62da3d8ba","time":3,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"-42.5","y":"0","z":"0"}],"uuid":"2dc1b8fe-5f2e-7501-8834-9eee624c0148","time":3.16667,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"-117.5","y":"0","z":"0"}],"uuid":"98189322-3ca0-4fa1-d99a-931316d6386e","time":3.5,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"-22.5","y":"0","z":"0"}],"uuid":"b1a7de96-58d4-2298-8891-5f7810bdd471","time":3.66667,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"0","y":"0","z":"0"}],"uuid":"8681a098-14fd-1f5c-2893-2e5d06ae936b","time":5,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"-22.5","y":"0","z":"0"}],"uuid":"820cc99f-ba7f-0636-4d8f-de8ea427fd48","time":4.5,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"-11.25","y":"0","z":"0"}],"uuid":"3c2ac5de-6c68-2166-c299-5740ad97ba38","time":4.75,"color":-1,"interpolation":"linear"}]},"60f01a01-8929-47c5-9114-6e2acc8327d9":{"name":"right_arm","type":"bone","rotation_global":false,"quaternion_interpolation":false,"keyframes":[{"channel":"rotation","data_points":[{"x":"2.5","y":"0","z":"0"}],"uuid":"1b9b67ae-5629-5bc2-b0d1-dd018946e11f","time":0,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"-190","y":"0","z":"0"}],"uuid":"89851ff6-c368-932c-0e0b-42e3492d8105","time":2.25,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"-190","y":"0","z":"0"}],"uuid":"0be81cb9-b4f6-98ce-228f-72bc3bccdb6f","time":2.5,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"-197.5","y":"0","z":"0"}],"uuid":"5ef473ec-bd2e-af64-1d1b-5a12d2e2cc8e","time":3,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"-42.5","y":"0","z":"0"}],"uuid":"a61c83de-9363-faba-83a9-e73054592cca","time":3.16667,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"-117.5","y":"0","z":"0"}],"uuid":"04d24c79-07ba-72e4-4a32-981e0e1cea93","time":3.5,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"-22.5","y":"0","z":"0"}],"uuid":"761330d3-9ff2-bb9d-97ee-acc16475ad85","time":3.66667,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"0","y":"0","z":"0"}],"uuid":"aa80aff8-b917-ef91-2629-9bc8a55de3bc","time":5,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"-22.5","y":"0","z":"0"}],"uuid":"da4fb15e-8e0f-aedb-2b3b-f5664e808db8","time":4.5,"color":-1,"interpolation":"linear"},{"channel":"rotation","data_points":[{"x":"-11.25","y":"0","z":"0"}],"uuid":"19ac5e49-ebce-9daf-a2f0-73a4ab47274d","time":4.75,"color":-1,"interpolation":"linear"}]},"effects":{"name":"Effects","type":"effect"}}}]} \ No newline at end of file diff --git a/src/main/resources/data/ascend/advancements/big_brain_small_helmet.json b/src/main/resources/data/ascend/advancements/big_brain_small_helmet.json new file mode 100644 index 0000000..fc79297 --- /dev/null +++ b/src/main/resources/data/ascend/advancements/big_brain_small_helmet.json @@ -0,0 +1,10 @@ +{ + "parent": "ascend:first_steps", + "display": { + "icon": { "item": "minecraft:chainmail_helmet" }, + "title": { "translate": "advancements.ascend.big_brain_small_helmet.title" }, + "description": { "translate": "advancements.ascend.big_brain_small_helmet.description" }, + "frame": "challenge", "show_toast": true, "announce_to_chat": true, "hidden": true + }, + "criteria": { "achieved": { "trigger": "minecraft:impossible" } } +} diff --git a/src/main/resources/data/ascend/advancements/bonk_scholar.json b/src/main/resources/data/ascend/advancements/bonk_scholar.json new file mode 100644 index 0000000..697eeeb --- /dev/null +++ b/src/main/resources/data/ascend/advancements/bonk_scholar.json @@ -0,0 +1,10 @@ +{ + "parent": "ascend:first_steps", + "display": { + "icon": { "item": "minecraft:anvil" }, + "title": { "translate": "advancements.ascend.bonk_scholar.title" }, + "description": { "translate": "advancements.ascend.bonk_scholar.description" }, + "frame": "challenge", "show_toast": true, "announce_to_chat": true, "hidden": true + }, + "criteria": { "achieved": { "trigger": "minecraft:impossible" } } +} diff --git a/src/main/resources/data/ascend/advancements/cannot_hit_what_you_cannot_see.json b/src/main/resources/data/ascend/advancements/cannot_hit_what_you_cannot_see.json new file mode 100644 index 0000000..bd7600c --- /dev/null +++ b/src/main/resources/data/ascend/advancements/cannot_hit_what_you_cannot_see.json @@ -0,0 +1,10 @@ +{ + "parent": "ascend:first_steps", + "display": { + "icon": { "item": "minecraft:ender_pearl" }, + "title": { "translate": "advancements.ascend.cannot_hit_what_you_cannot_see.title" }, + "description": { "translate": "advancements.ascend.cannot_hit_what_you_cannot_see.description" }, + "frame": "challenge", "show_toast": true, "announce_to_chat": true, "hidden": true + }, + "criteria": { "achieved": { "trigger": "minecraft:impossible" } } +} diff --git a/src/main/resources/data/ascend/advancements/config_enjoyer.json b/src/main/resources/data/ascend/advancements/config_enjoyer.json new file mode 100644 index 0000000..a7f549b --- /dev/null +++ b/src/main/resources/data/ascend/advancements/config_enjoyer.json @@ -0,0 +1,10 @@ +{ + "parent": "ascend:first_steps", + "display": { + "icon": { "item": "minecraft:comparator" }, + "title": { "translate": "advancements.ascend.config_enjoyer.title" }, + "description": { "translate": "advancements.ascend.config_enjoyer.description" }, + "frame": "challenge", "show_toast": true, "announce_to_chat": true, "hidden": true + }, + "criteria": { "achieved": { "trigger": "minecraft:impossible" } } +} diff --git a/src/main/resources/data/ascend/advancements/definition_of_insanity.json b/src/main/resources/data/ascend/advancements/definition_of_insanity.json new file mode 100644 index 0000000..f770850 --- /dev/null +++ b/src/main/resources/data/ascend/advancements/definition_of_insanity.json @@ -0,0 +1,10 @@ +{ + "parent": "ascend:first_steps", + "display": { + "icon": { "item": "minecraft:clock" }, + "title": { "translate": "advancements.ascend.definition_of_insanity.title" }, + "description": { "translate": "advancements.ascend.definition_of_insanity.description" }, + "frame": "challenge", "show_toast": true, "announce_to_chat": true, "hidden": true + }, + "criteria": { "achieved": { "trigger": "minecraft:impossible" } } +} diff --git a/src/main/resources/data/ascend/advancements/first_steps.json b/src/main/resources/data/ascend/advancements/first_steps.json new file mode 100644 index 0000000..b503914 --- /dev/null +++ b/src/main/resources/data/ascend/advancements/first_steps.json @@ -0,0 +1,13 @@ +{ + "display": { + "icon": { "item": "minecraft:experience_bottle" }, + "title": { "translate": "advancements.ascend.first_steps.title" }, + "description": { "translate": "advancements.ascend.first_steps.description" }, + "background": "minecraft:textures/gui/advancements/backgrounds/adventure.png", + "frame": "task", + "show_toast": true, + "announce_to_chat": true, + "hidden": false + }, + "criteria": { "achieved": { "trigger": "minecraft:impossible" } } +} diff --git a/src/main/resources/data/ascend/advancements/game_journalist_mode.json b/src/main/resources/data/ascend/advancements/game_journalist_mode.json new file mode 100644 index 0000000..2aaa9d9 --- /dev/null +++ b/src/main/resources/data/ascend/advancements/game_journalist_mode.json @@ -0,0 +1,10 @@ +{ + "parent": "ascend:first_steps", + "display": { + "icon": { "item": "minecraft:experience_bottle" }, + "title": { "translate": "advancements.ascend.game_journalist_mode.title" }, + "description": { "translate": "advancements.ascend.game_journalist_mode.description" }, + "frame": "challenge", "show_toast": true, "announce_to_chat": true, "hidden": true + }, + "criteria": { "achieved": { "trigger": "minecraft:impossible" } } +} diff --git a/src/main/resources/data/ascend/advancements/health_bar_enthusiast.json b/src/main/resources/data/ascend/advancements/health_bar_enthusiast.json new file mode 100644 index 0000000..510d632 --- /dev/null +++ b/src/main/resources/data/ascend/advancements/health_bar_enthusiast.json @@ -0,0 +1,10 @@ +{ + "parent": "ascend:first_steps", + "display": { + "icon": { "item": "minecraft:golden_apple" }, + "title": { "translate": "advancements.ascend.health_bar_enthusiast.title" }, + "description": { "translate": "advancements.ascend.health_bar_enthusiast.description" }, + "frame": "challenge", "show_toast": true, "announce_to_chat": true, "hidden": true + }, + "criteria": { "achieved": { "trigger": "minecraft:impossible" } } +} diff --git a/src/main/resources/data/ascend/advancements/indecisive_chosen_one.json b/src/main/resources/data/ascend/advancements/indecisive_chosen_one.json new file mode 100644 index 0000000..85d7993 --- /dev/null +++ b/src/main/resources/data/ascend/advancements/indecisive_chosen_one.json @@ -0,0 +1,10 @@ +{ + "parent": "ascend:first_steps", + "display": { + "icon": { "item": "ascend:remembrance_essence" }, + "title": { "translate": "advancements.ascend.indecisive_chosen_one.title" }, + "description": { "translate": "advancements.ascend.indecisive_chosen_one.description" }, + "frame": "challenge", "show_toast": true, "announce_to_chat": true, "hidden": true + }, + "criteria": { "achieved": { "trigger": "minecraft:impossible" } } +} diff --git a/src/main/resources/data/ascend/advancements/knowledge_100.json b/src/main/resources/data/ascend/advancements/knowledge_100.json new file mode 100644 index 0000000..ca701c0 --- /dev/null +++ b/src/main/resources/data/ascend/advancements/knowledge_100.json @@ -0,0 +1,13 @@ +{ + "parent": "ascend:first_steps", + "display": { + "icon": { "item": "minecraft:enchanting_table" }, + "title": { "translate": "advancements.ascend.knowledge_100.title" }, + "description": { "translate": "advancements.ascend.knowledge_100.description" }, + "frame": "goal", + "show_toast": true, + "announce_to_chat": true, + "hidden": false + }, + "criteria": { "achieved": { "trigger": "minecraft:impossible" } } +} diff --git a/src/main/resources/data/ascend/advancements/level_10.json b/src/main/resources/data/ascend/advancements/level_10.json new file mode 100644 index 0000000..02aee58 --- /dev/null +++ b/src/main/resources/data/ascend/advancements/level_10.json @@ -0,0 +1,13 @@ +{ + "parent": "ascend:level_5", + "display": { + "icon": { "item": "minecraft:diamond_sword" }, + "title": { "translate": "advancements.ascend.level_10.title" }, + "description": { "translate": "advancements.ascend.level_10.description" }, + "frame": "goal", + "show_toast": true, + "announce_to_chat": true, + "hidden": false + }, + "criteria": { "achieved": { "trigger": "minecraft:impossible" } } +} diff --git a/src/main/resources/data/ascend/advancements/level_5.json b/src/main/resources/data/ascend/advancements/level_5.json new file mode 100644 index 0000000..32d72ca --- /dev/null +++ b/src/main/resources/data/ascend/advancements/level_5.json @@ -0,0 +1,13 @@ +{ + "parent": "ascend:first_steps", + "display": { + "icon": { "item": "minecraft:iron_sword" }, + "title": { "translate": "advancements.ascend.level_5.title" }, + "description": { "translate": "advancements.ascend.level_5.description" }, + "frame": "task", + "show_toast": true, + "announce_to_chat": true, + "hidden": false + }, + "criteria": { "achieved": { "trigger": "minecraft:impossible" } } +} diff --git a/src/main/resources/data/ascend/advancements/mana_without_purpose.json b/src/main/resources/data/ascend/advancements/mana_without_purpose.json new file mode 100644 index 0000000..2ca374d --- /dev/null +++ b/src/main/resources/data/ascend/advancements/mana_without_purpose.json @@ -0,0 +1,10 @@ +{ + "parent": "ascend:first_steps", + "display": { + "icon": { "item": "minecraft:glass_bottle" }, + "title": { "translate": "advancements.ascend.mana_without_purpose.title" }, + "description": { "translate": "advancements.ascend.mana_without_purpose.description" }, + "frame": "goal", "show_toast": true, "announce_to_chat": true, "hidden": true + }, + "criteria": { "achieved": { "trigger": "minecraft:impossible" } } +} diff --git a/src/main/resources/data/ascend/advancements/max_attribute.json b/src/main/resources/data/ascend/advancements/max_attribute.json new file mode 100644 index 0000000..0a0ddde --- /dev/null +++ b/src/main/resources/data/ascend/advancements/max_attribute.json @@ -0,0 +1,14 @@ +{ + "parent": "ascend:first_steps", + "display": { + "icon": { "item": "minecraft:enchanted_golden_apple" }, + "title": { "translate": "advancements.ascend.max_attribute.title" }, + "description": { "translate": "advancements.ascend.max_attribute.description" }, + "frame": "challenge", + "show_toast": true, + "announce_to_chat": true, + "hidden": false + }, + "criteria": { "achieved": { "trigger": "minecraft:impossible" } }, + "rewards": { "experience": 250 } +} diff --git a/src/main/resources/data/ascend/advancements/max_level.json b/src/main/resources/data/ascend/advancements/max_level.json new file mode 100644 index 0000000..7fd1ca9 --- /dev/null +++ b/src/main/resources/data/ascend/advancements/max_level.json @@ -0,0 +1,14 @@ +{ + "parent": "ascend:level_10", + "display": { + "icon": { "item": "minecraft:nether_star" }, + "title": { "translate": "advancements.ascend.max_level.title" }, + "description": { "translate": "advancements.ascend.max_level.description" }, + "frame": "challenge", + "show_toast": true, + "announce_to_chat": true, + "hidden": false + }, + "criteria": { "achieved": { "trigger": "minecraft:impossible" } }, + "rewards": { "experience": 500 } +} diff --git a/src/main/resources/data/ascend/advancements/perfectly_balanced.json b/src/main/resources/data/ascend/advancements/perfectly_balanced.json new file mode 100644 index 0000000..3b10451 --- /dev/null +++ b/src/main/resources/data/ascend/advancements/perfectly_balanced.json @@ -0,0 +1,10 @@ +{ + "parent": "ascend:first_steps", + "display": { + "icon": { "item": "minecraft:recovery_compass" }, + "title": { "translate": "advancements.ascend.perfectly_balanced.title" }, + "description": { "translate": "advancements.ascend.perfectly_balanced.description" }, + "frame": "challenge", "show_toast": true, "announce_to_chat": true, "hidden": true + }, + "criteria": { "achieved": { "trigger": "minecraft:impossible" } } +} diff --git a/src/main/resources/data/ascend/advancements/read_moonseye_tome.json b/src/main/resources/data/ascend/advancements/read_moonseye_tome.json new file mode 100644 index 0000000..9e1663a --- /dev/null +++ b/src/main/resources/data/ascend/advancements/read_moonseye_tome.json @@ -0,0 +1,13 @@ +{ + "parent": "ascend:knowledge_100", + "display": { + "icon": { "item": "ascend:moonseye_tome" }, + "title": { "translate": "advancements.ascend.read_moonseye_tome.title" }, + "description": { "translate": "advancements.ascend.read_moonseye_tome.description" }, + "frame": "goal", + "show_toast": true, + "announce_to_chat": true, + "hidden": false + }, + "criteria": { "achieved": { "trigger": "minecraft:impossible" } } +} diff --git a/src/main/resources/data/ascend/advancements/talk_no_jutsu.json b/src/main/resources/data/ascend/advancements/talk_no_jutsu.json new file mode 100644 index 0000000..7be316b --- /dev/null +++ b/src/main/resources/data/ascend/advancements/talk_no_jutsu.json @@ -0,0 +1,10 @@ +{ + "parent": "ascend:first_steps", + "display": { + "icon": { "item": "minecraft:emerald" }, + "title": { "translate": "advancements.ascend.talk_no_jutsu.title" }, + "description": { "translate": "advancements.ascend.talk_no_jutsu.description" }, + "frame": "challenge", "show_toast": true, "announce_to_chat": true, "hidden": true + }, + "criteria": { "achieved": { "trigger": "minecraft:impossible" } } +} diff --git a/src/main/resources/data/ascend/advancements/unlicensed_therapist.json b/src/main/resources/data/ascend/advancements/unlicensed_therapist.json new file mode 100644 index 0000000..6ae1a10 --- /dev/null +++ b/src/main/resources/data/ascend/advancements/unlicensed_therapist.json @@ -0,0 +1,10 @@ +{ + "parent": "ascend:first_steps", + "display": { + "icon": { "item": "minecraft:amethyst_shard" }, + "title": { "translate": "advancements.ascend.unlicensed_therapist.title" }, + "description": { "translate": "advancements.ascend.unlicensed_therapist.description" }, + "frame": "challenge", "show_toast": true, "announce_to_chat": true, "hidden": true + }, + "criteria": { "achieved": { "trigger": "minecraft:impossible" } } +} diff --git a/src/main/resources/data/ascend/advancements/use_shrine.json b/src/main/resources/data/ascend/advancements/use_shrine.json new file mode 100644 index 0000000..fabe16c --- /dev/null +++ b/src/main/resources/data/ascend/advancements/use_shrine.json @@ -0,0 +1,13 @@ +{ + "parent": "ascend:first_steps", + "display": { + "icon": { "item": "ascend:remembrance_essence" }, + "title": { "translate": "advancements.ascend.use_shrine.title" }, + "description": { "translate": "advancements.ascend.use_shrine.description" }, + "frame": "goal", + "show_toast": true, + "announce_to_chat": true, + "hidden": false + }, + "criteria": { "achieved": { "trigger": "minecraft:impossible" } } +} diff --git a/src/main/resources/data/ascend/weapon_scaling/vanilla.json b/src/main/resources/data/ascend/weapon_scaling/vanilla.json new file mode 100644 index 0000000..2288997 --- /dev/null +++ b/src/main/resources/data/ascend/weapon_scaling/vanilla.json @@ -0,0 +1,38 @@ +{ + "entries": [ + {"item":"minecraft:wooden_sword","scaling":{"strength":"D","agility":"D"}}, + {"item":"minecraft:stone_sword","scaling":{"strength":"D","agility":"C"}}, + {"item":"minecraft:iron_sword","scaling":{"strength":"C","agility":"C"}}, + {"item":"minecraft:golden_sword","scaling":{"strength":"E","agility":"B"}}, + {"item":"minecraft:diamond_sword","scaling":{"strength":"C","agility":"B"}}, + {"item":"minecraft:netherite_sword","scaling":{"strength":"B","agility":"B"}}, + {"item":"minecraft:wooden_axe","scaling":{"strength":"C","agility":"E"}}, + {"item":"minecraft:stone_axe","scaling":{"strength":"B","agility":"E"}}, + {"item":"minecraft:iron_axe","scaling":{"strength":"B","agility":"D"}}, + {"item":"minecraft:golden_axe","scaling":{"strength":"D","agility":"C"}}, + {"item":"minecraft:diamond_axe","scaling":{"strength":"A","agility":"D"}}, + {"item":"minecraft:netherite_axe","scaling":{"strength":"A","agility":"C"}}, + {"item":"minecraft:wooden_pickaxe","scaling":{"strength":"D","agility":"E"}}, + {"item":"minecraft:stone_pickaxe","scaling":{"strength":"C","agility":"E"}}, + {"item":"minecraft:iron_pickaxe","scaling":{"strength":"C","agility":"E"}}, + {"item":"minecraft:golden_pickaxe","scaling":{"strength":"E","agility":"D"}}, + {"item":"minecraft:diamond_pickaxe","scaling":{"strength":"B","agility":"E"}}, + {"item":"minecraft:netherite_pickaxe","scaling":{"strength":"B","agility":"E"}}, + {"item":"minecraft:wooden_shovel","scaling":{"strength":"D","agility":"E"}}, + {"item":"minecraft:stone_shovel","scaling":{"strength":"D","agility":"E"}}, + {"item":"minecraft:iron_shovel","scaling":{"strength":"C","agility":"E"}}, + {"item":"minecraft:golden_shovel","scaling":{"strength":"E","agility":"D"}}, + {"item":"minecraft:diamond_shovel","scaling":{"strength":"C","agility":"E"}}, + {"item":"minecraft:netherite_shovel","scaling":{"strength":"C","agility":"E"}}, + {"item":"minecraft:wooden_hoe","scaling":{"strength":"E","agility":"D"}}, + {"item":"minecraft:stone_hoe","scaling":{"strength":"E","agility":"C"}}, + {"item":"minecraft:iron_hoe","scaling":{"strength":"E","agility":"B"}}, + {"item":"minecraft:golden_hoe","scaling":{"strength":"E","agility":"B"}}, + {"item":"minecraft:diamond_hoe","scaling":{"strength":"D","agility":"B"}}, + {"item":"minecraft:netherite_hoe","scaling":{"strength":"D","agility":"A"}}, + {"item":"minecraft:bow","scaling":{"strength":"NONE","agility":"A"}}, + {"item":"minecraft:crossbow","scaling":{"strength":"D","agility":"B"}}, + {"item":"minecraft:trident","scaling":{"strength":"C","agility":"B"}}, + {"item":"minecraft:mace","scaling":{"strength":"A","agility":"D"}} + ] +}