From cd8fb8ec20315608d752b536b13bd7da0bc0c2e6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ossi=20Erkkil=C3=A4?= Date: Thu, 25 Sep 2025 22:56:29 +0300 Subject: [PATCH 01/18] Add Keys.WEAPON_DAMAGE_PER_ATTACK and Keys.DISABLE_BLOCKING_TICKS # Conflicts: # SpongeAPI # src/main/java/org/spongepowered/common/data/provider/item/stack/ItemStackData.java --- SpongeAPI | 2 +- .../provider/item/stack/ItemStackData.java | 55 +++++++++++++++++++ .../spongepowered/common/util/Constants.java | 1 + 3 files changed, 57 insertions(+), 1 deletion(-) diff --git a/SpongeAPI b/SpongeAPI index 9b0d6786155..8b310746d31 160000 --- a/SpongeAPI +++ b/SpongeAPI @@ -1 +1 @@ -Subproject commit 9b0d678615595bec00cf099af576c931cc044d48 +Subproject commit 8b310746d311575dc7e78d15fac3fe5004ebdfff diff --git a/src/main/java/org/spongepowered/common/data/provider/item/stack/ItemStackData.java b/src/main/java/org/spongepowered/common/data/provider/item/stack/ItemStackData.java index a9d1d4212fd..6eb6786f18f 100644 --- a/src/main/java/org/spongepowered/common/data/provider/item/stack/ItemStackData.java +++ b/src/main/java/org/spongepowered/common/data/provider/item/stack/ItemStackData.java @@ -47,6 +47,9 @@ import net.minecraft.world.item.component.ItemLore; import net.minecraft.world.item.component.UseCooldown; import net.minecraft.world.item.component.UseRemainder; +import net.minecraft.world.item.component.Weapon; +import net.minecraft.world.item.consume_effects.ApplyStatusEffectsConsumeEffect; +import net.minecraft.world.item.consume_effects.ClearAllStatusEffectsConsumeEffect; import net.minecraft.world.item.consume_effects.ConsumeEffect; import org.checkerframework.checker.nullness.qual.Nullable; import org.spongepowered.api.Platform; @@ -65,6 +68,7 @@ import org.spongepowered.common.adventure.SpongeAdventure; import org.spongepowered.common.data.provider.DataProviderRegistrator; import org.spongepowered.common.item.util.ItemStackUtil; +import org.spongepowered.common.util.Constants; import java.util.List; import java.util.Optional; @@ -370,6 +374,57 @@ public static void register(final DataProviderRegistrator registrator) { .get(h -> (ResourceKey) (Object) h.get(DataComponents.TOOLTIP_STYLE)) .set((h, v) -> h.set(DataComponents.TOOLTIP_STYLE, (ResourceLocation) (Object) v)) .delete(h -> h.remove(DataComponents.TOOLTIP_STYLE)) + .create(Keys.WEAPON_DAMAGE_PER_ATTACK) + .get(h -> { + final @Nullable Weapon weapon = h.get(DataComponents.WEAPON); + if (weapon == null) { + return null; + } + return weapon.itemDamagePerAttack(); + }) + .set((h, v) -> { + final @Nullable Weapon weapon = h.get(DataComponents.WEAPON); + h.set(DataComponents.WEAPON, new Weapon(v, weapon == null ? 0 : weapon.disableBlockingForSeconds())); + }) + .delete(h -> { + final @Nullable Weapon weapon = h.get(DataComponents.WEAPON); + if (weapon == null) { + return; + } + if (weapon.disableBlockingForSeconds() == 0) { + h.remove(DataComponents.WEAPON); + } else { + h.set(DataComponents.WEAPON, new Weapon(0, weapon.disableBlockingForSeconds())); + } + }) + .create(Keys.DISABLE_BLOCKING_TICKS) + .get(h -> { + final @Nullable Weapon weapon = h.get(DataComponents.WEAPON); + if (weapon == null) { + return null; + } + return Ticks.of(Math.round( + Constants.TickConversions.TICKS_PER_SECOND * weapon.disableBlockingForSeconds() + )); + }) + .set((h, v) -> { + final @Nullable Weapon weapon = h.get(DataComponents.WEAPON); + h.set(DataComponents.WEAPON, new Weapon( + weapon == null ? 0 : weapon.itemDamagePerAttack(), + v.ticks() / (float) Constants.TickConversions.TICKS_PER_SECOND + )); + }) + .delete(h -> { + final @Nullable Weapon weapon = h.get(DataComponents.WEAPON); + if (weapon == null) { + return; + } + if (weapon.itemDamagePerAttack() == 0) { + h.remove(DataComponents.WEAPON); + } else { + h.set(DataComponents.WEAPON, new Weapon(weapon.itemDamagePerAttack())); + } + }) ; } // @formatter:on diff --git a/src/main/java/org/spongepowered/common/util/Constants.java b/src/main/java/org/spongepowered/common/util/Constants.java index db3dbb7b1f8..eb2601246ba 100644 --- a/src/main/java/org/spongepowered/common/util/Constants.java +++ b/src/main/java/org/spongepowered/common/util/Constants.java @@ -1539,6 +1539,7 @@ public static final class KeyValueMatcher { public static final class TickConversions { public static final int TICK_DURATION_MS = 50; + public static final int TICKS_PER_SECOND = 1000 / TICK_DURATION_MS; public static final Duration EFFECTIVE_MINIMUM_DURATION = Duration.ofMillis(TickConversions.TICK_DURATION_MS); public static final int MINECRAFT_DAY_TICKS = 24000; From 63ab92c7681e35cc5b969c6fbbc7f8e66bcebec6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ossi=20Erkkil=C3=A4?= Date: Fri, 26 Sep 2025 15:01:46 +0300 Subject: [PATCH 02/18] Expose minecraft:blocks_attacks related Keys  Conflicts:  SpongeAPI --- .../item/stack/ShieldItemStackData.java | 204 +++++++++++++++++- .../SpongeShieldDamageReductionBuilder.java | 85 ++++++++ ...SpongeShieldItemDamageFunctionBuilder.java | 52 +++++ .../registry/SpongeBuilderProvider.java | 6 + ...locksAttacks_DamageReductionMixin_API.java | 45 ++++ .../BlocksAttacks_ItemDamageFunction_API.java | 31 +++ src/mixins/resources/mixins.sponge.api.json | 2 + 7 files changed, 423 insertions(+), 2 deletions(-) create mode 100644 src/main/java/org/spongepowered/common/item/SpongeShieldDamageReductionBuilder.java create mode 100644 src/main/java/org/spongepowered/common/item/SpongeShieldItemDamageFunctionBuilder.java create mode 100644 src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_DamageReductionMixin_API.java create mode 100644 src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_ItemDamageFunction_API.java diff --git a/src/main/java/org/spongepowered/common/data/provider/item/stack/ShieldItemStackData.java b/src/main/java/org/spongepowered/common/data/provider/item/stack/ShieldItemStackData.java index 9b499f8084f..a058bdebb5b 100644 --- a/src/main/java/org/spongepowered/common/data/provider/item/stack/ShieldItemStackData.java +++ b/src/main/java/org/spongepowered/common/data/provider/item/stack/ShieldItemStackData.java @@ -24,15 +24,30 @@ */ package org.spongepowered.common.data.provider.item.stack; +import net.minecraft.core.Holder; import net.minecraft.core.component.DataComponents; +import net.minecraft.sounds.SoundEvent; import net.minecraft.world.item.BannerItem; import net.minecraft.world.item.ItemStack; import net.minecraft.world.item.ShieldItem; +import net.minecraft.world.item.component.BlocksAttacks; import net.minecraft.world.level.block.entity.BannerPatternLayers; +import org.checkerframework.checker.nullness.qual.Nullable; import org.spongepowered.api.data.Keys; import org.spongepowered.api.data.meta.BannerPatternLayer; import org.spongepowered.api.data.type.DyeColor; +import org.spongepowered.api.data.type.ShieldDamageReduction; +import org.spongepowered.api.data.type.ShieldItemDamageFunction; +import org.spongepowered.api.effect.sound.SoundType; +import org.spongepowered.api.event.cause.entity.damage.DamageType; +import org.spongepowered.api.tag.Tag; +import org.spongepowered.api.util.Ticks; +import org.spongepowered.common.bridge.tags.TagBridge; import org.spongepowered.common.data.provider.DataProviderRegistrator; +import org.spongepowered.common.util.Constants; + +import java.util.List; +import java.util.Optional; public final class ShieldItemStackData { @@ -46,7 +61,6 @@ public static void register(final DataProviderRegistrator registrator) { .create(Keys.DYE_COLOR) .get(h -> (DyeColor) (Object) h.getOrDefault(DataComponents.BASE_COLOR, net.minecraft.world.item.DyeColor.WHITE)) .set((h, v) -> h.set(DataComponents.BASE_COLOR, (net.minecraft.world.item.DyeColor) (Object) v)) - .supports(h -> h.getItem() instanceof ShieldItem) .create(Keys.BANNER_PATTERN_LAYERS) .get(h -> h.getOrDefault(DataComponents.BANNER_PATTERNS, BannerPatternLayers.EMPTY).layers() .stream().map(BannerPatternLayer.class::cast).toList()) @@ -54,8 +68,194 @@ public static void register(final DataProviderRegistrator registrator) { h.set(DataComponents.BANNER_PATTERNS, new BannerPatternLayers(v.stream().map(BannerPatternLayers.Layer.class::cast).toList())); // TODO check setting banner base? Constants.TileEntity.Banner.BANNER_BASE / BannerPatternShapes.BASE }) - .supports(h -> h.getItem() instanceof ShieldItem || h.getItem() instanceof BannerItem); + .create(Keys.BLOCK_DELAY_TICKS) + .get(h -> { + final @Nullable BlocksAttacks blocksAttacks = h.get(DataComponents.BLOCKS_ATTACKS); + if (blocksAttacks == null) { + return null; + } + return Ticks.of((long) (Constants.TickConversions.TICKS_PER_SECOND * blocksAttacks.blockDelaySeconds())); + }) + .set((h, v) -> { + final @Nullable BlocksAttacks blocksAttacks = h.getOrDefault(DataComponents.BLOCKS_ATTACKS, BLOCKS_ATTACKS_DEFAULTS); + h.set(DataComponents.BLOCKS_ATTACKS, new BlocksAttacks( + v.ticks() / (float) Constants.TickConversions.TICKS_PER_SECOND, + blocksAttacks.disableCooldownScale(), + blocksAttacks.damageReductions(), + blocksAttacks.itemDamage(), + blocksAttacks.bypassedBy(), + blocksAttacks.blockSound(), + blocksAttacks.disableSound() + )); + }) + .create(Keys.DISABLED_BLOCKING_COOLDOWN_SCALE) + .get(h -> { + final @Nullable BlocksAttacks blocksAttacks = h.get(DataComponents.BLOCKS_ATTACKS); + if (blocksAttacks == null) { + return null; + } + return blocksAttacks.disableCooldownScale(); + }) + .set((h, v) -> { + final @Nullable BlocksAttacks blocksAttacks = h.getOrDefault(DataComponents.BLOCKS_ATTACKS, BLOCKS_ATTACKS_DEFAULTS); + h.set(DataComponents.BLOCKS_ATTACKS, new BlocksAttacks( + blocksAttacks.blockDelaySeconds(), + v, + blocksAttacks.damageReductions(), + blocksAttacks.itemDamage(), + blocksAttacks.bypassedBy(), + blocksAttacks.blockSound(), + blocksAttacks.disableSound() + )); + }) + .create(Keys.SHIELD_DAMAGE_REDUCTIONS) + .get(h -> { + final @Nullable BlocksAttacks blocksAttacks = h.get(DataComponents.BLOCKS_ATTACKS); + if (blocksAttacks == null) { + return null; + } + return (List) (Object) List.copyOf(blocksAttacks.damageReductions()); + }) + .set((h, v) -> { + final @Nullable BlocksAttacks blocksAttacks = h.getOrDefault(DataComponents.BLOCKS_ATTACKS, BLOCKS_ATTACKS_DEFAULTS); + h.set(DataComponents.BLOCKS_ATTACKS, new BlocksAttacks( + blocksAttacks.blockDelaySeconds(), + blocksAttacks.disableCooldownScale(), + (List) (Object) List.copyOf(v), + blocksAttacks.itemDamage(), + blocksAttacks.bypassedBy(), + blocksAttacks.blockSound(), + blocksAttacks.disableSound() + )); + }) + .create(Keys.SHIELD_ITEM_DAMAGE_FUNCTION) + .get(h -> { + final @Nullable BlocksAttacks blocksAttacks = h.get(DataComponents.BLOCKS_ATTACKS); + if (blocksAttacks == null) { + return null; + } + return (ShieldItemDamageFunction) (Object) blocksAttacks.itemDamage(); + }) + .set((h, v) -> { + final @Nullable BlocksAttacks blocksAttacks = h.getOrDefault(DataComponents.BLOCKS_ATTACKS, BLOCKS_ATTACKS_DEFAULTS); + h.set(DataComponents.BLOCKS_ATTACKS, new BlocksAttacks( + blocksAttacks.blockDelaySeconds(), + blocksAttacks.disableCooldownScale(), + blocksAttacks.damageReductions(), + (BlocksAttacks.ItemDamageFunction) (Object) v, + blocksAttacks.bypassedBy(), + blocksAttacks.blockSound(), + blocksAttacks.disableSound() + )); + }) + .create(Keys.BYPASS_DAMAGE_TAG) + .get(h -> { + final @Nullable BlocksAttacks blocksAttacks = h.get(DataComponents.BLOCKS_ATTACKS); + if (blocksAttacks == null || blocksAttacks.bypassedBy().isEmpty()) { + return null; + } + return (Tag) (Object) blocksAttacks.bypassedBy().get(); + }) + .set((h, v) -> { + final @Nullable BlocksAttacks blocksAttacks = h.getOrDefault(DataComponents.BLOCKS_ATTACKS, BLOCKS_ATTACKS_DEFAULTS); + h.set(DataComponents.BLOCKS_ATTACKS, new BlocksAttacks( + blocksAttacks.blockDelaySeconds(), + blocksAttacks.disableCooldownScale(), + blocksAttacks.damageReductions(), + blocksAttacks.itemDamage(), + Optional.of(((TagBridge) v).bridge$asVanillaTag()), + blocksAttacks.blockSound(), + blocksAttacks.disableSound() + )); + }) + .delete(h -> { + final @Nullable BlocksAttacks blocksAttacks = h.getOrDefault(DataComponents.BLOCKS_ATTACKS, BLOCKS_ATTACKS_DEFAULTS); + h.set(DataComponents.BLOCKS_ATTACKS, new BlocksAttacks( + blocksAttacks.blockDelaySeconds(), + blocksAttacks.disableCooldownScale(), + blocksAttacks.damageReductions(), + blocksAttacks.itemDamage(), + Optional.empty(), + blocksAttacks.blockSound(), + blocksAttacks.disableSound() + )); + }) + .create(Keys.SHIELD_BLOCK_SOUND) + .get(h -> { + final @Nullable BlocksAttacks blocksAttacks = h.get(DataComponents.BLOCKS_ATTACKS); + if (blocksAttacks == null || blocksAttacks.blockSound().isEmpty()) { + return null; + } + return (SoundType) (Object) blocksAttacks.blockSound().get().value(); + }) + .set((h, v) -> { + final @Nullable BlocksAttacks blocksAttacks = h.getOrDefault(DataComponents.BLOCKS_ATTACKS, BLOCKS_ATTACKS_DEFAULTS); + h.set(DataComponents.BLOCKS_ATTACKS, new BlocksAttacks( + blocksAttacks.blockDelaySeconds(), + blocksAttacks.disableCooldownScale(), + blocksAttacks.damageReductions(), + blocksAttacks.itemDamage(), + blocksAttacks.bypassedBy(), + Optional.of(Holder.direct((SoundEvent) (Object) v)), + blocksAttacks.disableSound() + )); + }) + .delete(h -> { + final @Nullable BlocksAttacks blocksAttacks = h.getOrDefault(DataComponents.BLOCKS_ATTACKS, BLOCKS_ATTACKS_DEFAULTS); + h.set(DataComponents.BLOCKS_ATTACKS, new BlocksAttacks( + blocksAttacks.blockDelaySeconds(), + blocksAttacks.disableCooldownScale(), + blocksAttacks.damageReductions(), + blocksAttacks.itemDamage(), + blocksAttacks.bypassedBy(), + Optional.empty(), + blocksAttacks.disableSound() + )); + }) + .create(Keys.SHIELD_DISABLE_SOUND) + .get(h -> { + final @Nullable BlocksAttacks blocksAttacks = h.get(DataComponents.BLOCKS_ATTACKS); + if (blocksAttacks == null || blocksAttacks.disableSound().isEmpty()) { + return null; + } + return (SoundType) (Object) blocksAttacks.disableSound().get().value(); + }) + .set((h, v) -> { + final @Nullable BlocksAttacks blocksAttacks = h.getOrDefault(DataComponents.BLOCKS_ATTACKS, BLOCKS_ATTACKS_DEFAULTS); + h.set(DataComponents.BLOCKS_ATTACKS, new BlocksAttacks( + blocksAttacks.blockDelaySeconds(), + blocksAttacks.disableCooldownScale(), + blocksAttacks.damageReductions(), + blocksAttacks.itemDamage(), + blocksAttacks.bypassedBy(), + blocksAttacks.blockSound(), + Optional.of(Holder.direct((SoundEvent) (Object) v)) + )); + }) + .delete(h -> { + final @Nullable BlocksAttacks blocksAttacks = h.getOrDefault(DataComponents.BLOCKS_ATTACKS, BLOCKS_ATTACKS_DEFAULTS); + h.set(DataComponents.BLOCKS_ATTACKS, new BlocksAttacks( + blocksAttacks.blockDelaySeconds(), + blocksAttacks.disableCooldownScale(), + blocksAttacks.damageReductions(), + blocksAttacks.itemDamage(), + blocksAttacks.bypassedBy(), + blocksAttacks.blockSound(), + Optional.empty() + )); + }) + ; } // @formatter:on + private static final BlocksAttacks BLOCKS_ATTACKS_DEFAULTS = new BlocksAttacks( + 0, + 1, + List.of(), + BlocksAttacks.ItemDamageFunction.DEFAULT, + Optional.empty(), + Optional.empty(), + Optional.empty() + ); + } diff --git a/src/main/java/org/spongepowered/common/item/SpongeShieldDamageReductionBuilder.java b/src/main/java/org/spongepowered/common/item/SpongeShieldDamageReductionBuilder.java new file mode 100644 index 00000000000..dfff39cc811 --- /dev/null +++ b/src/main/java/org/spongepowered/common/item/SpongeShieldDamageReductionBuilder.java @@ -0,0 +1,85 @@ +package org.spongepowered.common.item; + +import net.minecraft.core.HolderSet; +import net.minecraft.core.Registry; +import net.minecraft.world.item.component.BlocksAttacks; +import org.spongepowered.api.Sponge; +import org.spongepowered.api.data.type.ShieldDamageReduction; +import org.spongepowered.api.event.cause.entity.damage.DamageType; +import org.spongepowered.api.registry.RegistryTypes; +import org.spongepowered.api.tag.Tag; +import org.spongepowered.common.bridge.tags.TagBridge; +import org.spongepowered.common.util.Preconditions; + +import java.util.Optional; +import java.util.Set; + +public class SpongeShieldDamageReductionBuilder implements ShieldDamageReduction.Builder { + private HolderSet damageTypes; + private Double horizontalBlockingAngle; + private double base = 0; + private double factor = 0; + + @Override + public ShieldDamageReduction.Builder damageTypes(Set damageTypes) { + final Registry registry = (Registry) Sponge.server().registry(RegistryTypes.DAMAGE_TYPE); + + this.damageTypes = HolderSet.direct(damageTypes.stream() + .map(dt -> registry.wrapAsHolder((net.minecraft.world.damagesource.DamageType) (Object) dt)) + .toList()); + + return this; + } + + @Override + public ShieldDamageReduction.Builder damageTypes(Tag tag) { + final Registry registry = (Registry) Sponge.server().registry(RegistryTypes.DAMAGE_TYPE); + final var vanillaTag = ((TagBridge) tag).bridge$asVanillaTag(); + this.damageTypes = registry.getOrThrow(vanillaTag); + + return this; + } + + @Override + public ShieldDamageReduction.Builder horizontalBlockingAngle(double angle) { + Preconditions.checkArgument(angle > 0, "angle must be positive"); + this.horizontalBlockingAngle = angle; + + return this; + } + + @Override + public ShieldDamageReduction.Builder constantReduction(double constant) { + this.base = constant; + + return this; + } + + @Override + public ShieldDamageReduction.Builder fractionalReduction(double fraction) { + this.factor = fraction; + + return this; + } + + @Override + public ShieldDamageReduction build() { + return (ShieldDamageReduction) (Object) new BlocksAttacks.DamageReduction( + horizontalBlockingAngle != null ? horizontalBlockingAngle.floatValue() : 90, + Optional.ofNullable(damageTypes), + (float) base, + (float) factor + ); + } + + @Override + public ShieldDamageReduction.Builder reset() { + this.damageTypes = null; + this.horizontalBlockingAngle = null; + this.base = 0; + this.factor = 0; + + return this; + } + +} diff --git a/src/main/java/org/spongepowered/common/item/SpongeShieldItemDamageFunctionBuilder.java b/src/main/java/org/spongepowered/common/item/SpongeShieldItemDamageFunctionBuilder.java new file mode 100644 index 00000000000..63703537207 --- /dev/null +++ b/src/main/java/org/spongepowered/common/item/SpongeShieldItemDamageFunctionBuilder.java @@ -0,0 +1,52 @@ +package org.spongepowered.common.item; + +import net.minecraft.world.item.component.BlocksAttacks; +import org.spongepowered.api.data.type.ShieldItemDamageFunction; +import org.spongepowered.common.util.Preconditions; + +public class SpongeShieldItemDamageFunctionBuilder implements ShieldItemDamageFunction.Builder { + private double minAttackDamage = 0; + private double constantDamage = 0; + private double fractionalDamage = 0; + + @Override + public ShieldItemDamageFunction.Builder minAttackDamage(double minDamage) { + Preconditions.checkArgument(minDamage >= 0, "minAttackDamage must be >= 0"); + this.minAttackDamage = minDamage; + + return this; + } + + @Override + public ShieldItemDamageFunction.Builder constantDamage(double constantDamage) { + this.constantDamage = constantDamage; + + return this; + } + + @Override + public ShieldItemDamageFunction.Builder fractionalDamage(double fractionalDamage) { + this.fractionalDamage = fractionalDamage; + + return this; + } + + @Override + public ShieldItemDamageFunction build() { + return (ShieldItemDamageFunction) (Object) new BlocksAttacks.ItemDamageFunction( + (float) minAttackDamage, + (float) constantDamage, + (float) fractionalDamage + ); + } + + @Override + public ShieldItemDamageFunction.Builder reset() { + this.minAttackDamage = 0; + this.constantDamage = 0; + this.fractionalDamage = 0; + + return this; + } + +} diff --git a/src/main/java/org/spongepowered/common/registry/SpongeBuilderProvider.java b/src/main/java/org/spongepowered/common/registry/SpongeBuilderProvider.java index 821ca0dcb09..44b0a99f5c3 100644 --- a/src/main/java/org/spongepowered/common/registry/SpongeBuilderProvider.java +++ b/src/main/java/org/spongepowered/common/registry/SpongeBuilderProvider.java @@ -51,6 +51,8 @@ import org.spongepowered.api.data.meta.BannerPatternLayer; import org.spongepowered.api.data.persistence.DataStore; import org.spongepowered.api.data.type.ArtType; +import org.spongepowered.api.data.type.ShieldDamageReduction; +import org.spongepowered.api.data.type.ShieldItemDamageFunction; import org.spongepowered.api.effect.particle.ParticleEffect; import org.spongepowered.api.effect.potion.PotionEffect; import org.spongepowered.api.effect.sound.SoundType; @@ -192,6 +194,8 @@ import org.spongepowered.common.inventory.query.SpongeQueryBuilder; import org.spongepowered.common.item.SpongeFireworkEffectBuilder; import org.spongepowered.common.item.SpongeItemStack; +import org.spongepowered.common.item.SpongeShieldDamageReductionBuilder; +import org.spongepowered.common.item.SpongeShieldItemDamageFunctionBuilder; import org.spongepowered.common.item.enchantment.SpongeEnchantmentBuilder; import org.spongepowered.common.item.enchantment.SpongeRandomEnchantmentListBuilder; import org.spongepowered.common.item.generation.SpongeItemStackGenerator; @@ -395,6 +399,8 @@ public void registerDefaultBuilders() { .register(PortalLogic.Builder.class, SpongePortalLogicBuilder::new) .register(ServerWorldProperties.LoadOptions.Builder.class, SpongeServerWorldPropertiesLoadOptions.BuilderImpl::new) .register(WorldArchetype.Builder.class, SpongeWorldArchetype.BuilderImpl::new) + .register(ShieldDamageReduction.Builder.class, SpongeShieldDamageReductionBuilder::new) + .register(ShieldItemDamageFunction.Builder.class, SpongeShieldItemDamageFunctionBuilder::new) ; } } diff --git a/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_DamageReductionMixin_API.java b/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_DamageReductionMixin_API.java new file mode 100644 index 00000000000..0597e612ee9 --- /dev/null +++ b/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_DamageReductionMixin_API.java @@ -0,0 +1,45 @@ +package org.spongepowered.common.mixin.api.minecraft.world.item.component; + +import net.minecraft.core.Holder; +import net.minecraft.core.HolderSet; +import net.minecraft.world.item.component.BlocksAttacks; +import org.spongepowered.api.data.type.ShieldDamageReduction; +import org.spongepowered.api.event.cause.entity.damage.DamageType; +import org.spongepowered.asm.mixin.*; + +import java.util.Optional; +import java.util.Set; +import java.util.stream.Collectors; + +@Mixin(BlocksAttacks.DamageReduction.class) +@Implements(@Interface(iface = ShieldDamageReduction.class, prefix = "shielddamagereduction$")) +public abstract class BlocksAttacks_DamageReductionMixin_API implements ShieldDamageReduction { + + @Shadow @Final private Optional> type; + @Shadow @Final private float base; + @Shadow @Final private float factor; + @Shadow @Final private float horizontalBlockingAngle; + + @Override + public Optional> damageTypes() { + return this.type.map(set -> set.stream() + .map(Holder::value) + .map(DamageType.class::cast) + .collect(Collectors.toSet())); + } + + public double shielddamagereduction$horizontalBlockingAngle() { + return this.horizontalBlockingAngle; + } + + @Override + public double constantReduction() { + return this.base; + } + + @Override + public double fractionalReduction() { + return this.factor; + } + +} diff --git a/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_ItemDamageFunction_API.java b/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_ItemDamageFunction_API.java new file mode 100644 index 00000000000..d86052c1861 --- /dev/null +++ b/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_ItemDamageFunction_API.java @@ -0,0 +1,31 @@ +package org.spongepowered.common.mixin.api.minecraft.world.item.component; + +import net.minecraft.world.item.component.BlocksAttacks; +import org.spongepowered.api.data.type.ShieldItemDamageFunction; +import org.spongepowered.asm.mixin.Final; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Shadow; + +@Mixin(BlocksAttacks.ItemDamageFunction.class) +public abstract class BlocksAttacks_ItemDamageFunction_API implements ShieldItemDamageFunction { + + @Shadow @Final private float threshold; + @Shadow @Final private float base; + @Shadow @Final private float factor; + + @Override + public double minAttackDamage() { + return this.threshold; + } + + @Override + public double constantDamage() { + return this.base; + } + + @Override + public double fractionalDamage() { + return this.factor; + } + +} diff --git a/src/mixins/resources/mixins.sponge.api.json b/src/mixins/resources/mixins.sponge.api.json index c0189a5990e..840a6f902da 100644 --- a/src/mixins/resources/mixins.sponge.api.json +++ b/src/mixins/resources/mixins.sponge.api.json @@ -333,6 +333,8 @@ "minecraft.world.item.RarityMixin_API", "minecraft.world.item.ToolMaterialMixin_API", "minecraft.world.item.alchemy.PotionMixin_API", + "minecraft.world.item.component.BlocksAttacks_DamageReductionMixin_API", + "minecraft.world.item.component.BlocksAttacks_ItemDamageFunction_API", "minecraft.world.item.component.FireworkExplosionMixin_API", "minecraft.world.item.component.Tool_RuleMixin_API", "minecraft.world.item.consume_effects.ApplyStatusEffectsConsumeEffectMixin_API", From d79393405b286e3ff370f39fb4e1f0af5b5da816 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ossi=20Erkkil=C3=A4?= Date: Fri, 26 Sep 2025 17:35:20 +0300 Subject: [PATCH 03/18] Add tests & peform cleanup --- .../item/stack/ShieldItemStackData.java | 2 - .../SpongeShieldDamageReductionBuilder.java | 24 ++++ ...SpongeShieldItemDamageFunctionBuilder.java | 24 ++++ ...locksAttacks_DamageReductionMixin_API.java | 24 ++++ .../BlocksAttacks_ItemDamageFunction_API.java | 24 ++++ .../common/data/key/KeysTest.java | 119 ++++++++++++++++++ 6 files changed, 215 insertions(+), 2 deletions(-) create mode 100644 src/test/java/org/spongepowered/common/data/key/KeysTest.java diff --git a/src/main/java/org/spongepowered/common/data/provider/item/stack/ShieldItemStackData.java b/src/main/java/org/spongepowered/common/data/provider/item/stack/ShieldItemStackData.java index a058bdebb5b..973dda9b5fd 100644 --- a/src/main/java/org/spongepowered/common/data/provider/item/stack/ShieldItemStackData.java +++ b/src/main/java/org/spongepowered/common/data/provider/item/stack/ShieldItemStackData.java @@ -27,9 +27,7 @@ import net.minecraft.core.Holder; import net.minecraft.core.component.DataComponents; import net.minecraft.sounds.SoundEvent; -import net.minecraft.world.item.BannerItem; import net.minecraft.world.item.ItemStack; -import net.minecraft.world.item.ShieldItem; import net.minecraft.world.item.component.BlocksAttacks; import net.minecraft.world.level.block.entity.BannerPatternLayers; import org.checkerframework.checker.nullness.qual.Nullable; diff --git a/src/main/java/org/spongepowered/common/item/SpongeShieldDamageReductionBuilder.java b/src/main/java/org/spongepowered/common/item/SpongeShieldDamageReductionBuilder.java index dfff39cc811..0ae80cfd82e 100644 --- a/src/main/java/org/spongepowered/common/item/SpongeShieldDamageReductionBuilder.java +++ b/src/main/java/org/spongepowered/common/item/SpongeShieldDamageReductionBuilder.java @@ -1,3 +1,27 @@ +/* + * This file is part of Sponge, licensed under the MIT License (MIT). + * + * Copyright (c) SpongePowered + * Copyright (c) contributors + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ package org.spongepowered.common.item; import net.minecraft.core.HolderSet; diff --git a/src/main/java/org/spongepowered/common/item/SpongeShieldItemDamageFunctionBuilder.java b/src/main/java/org/spongepowered/common/item/SpongeShieldItemDamageFunctionBuilder.java index 63703537207..2a141f90135 100644 --- a/src/main/java/org/spongepowered/common/item/SpongeShieldItemDamageFunctionBuilder.java +++ b/src/main/java/org/spongepowered/common/item/SpongeShieldItemDamageFunctionBuilder.java @@ -1,3 +1,27 @@ +/* + * This file is part of Sponge, licensed under the MIT License (MIT). + * + * Copyright (c) SpongePowered + * Copyright (c) contributors + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ package org.spongepowered.common.item; import net.minecraft.world.item.component.BlocksAttacks; diff --git a/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_DamageReductionMixin_API.java b/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_DamageReductionMixin_API.java index 0597e612ee9..4f6b88ef238 100644 --- a/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_DamageReductionMixin_API.java +++ b/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_DamageReductionMixin_API.java @@ -1,3 +1,27 @@ +/* + * This file is part of Sponge, licensed under the MIT License (MIT). + * + * Copyright (c) SpongePowered + * Copyright (c) contributors + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ package org.spongepowered.common.mixin.api.minecraft.world.item.component; import net.minecraft.core.Holder; diff --git a/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_ItemDamageFunction_API.java b/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_ItemDamageFunction_API.java index d86052c1861..278e98321d2 100644 --- a/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_ItemDamageFunction_API.java +++ b/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_ItemDamageFunction_API.java @@ -1,3 +1,27 @@ +/* + * This file is part of Sponge, licensed under the MIT License (MIT). + * + * Copyright (c) SpongePowered + * Copyright (c) contributors + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ package org.spongepowered.common.mixin.api.minecraft.world.item.component; import net.minecraft.world.item.component.BlocksAttacks; diff --git a/src/test/java/org/spongepowered/common/data/key/KeysTest.java b/src/test/java/org/spongepowered/common/data/key/KeysTest.java new file mode 100644 index 00000000000..41dd7d80c5f --- /dev/null +++ b/src/test/java/org/spongepowered/common/data/key/KeysTest.java @@ -0,0 +1,119 @@ +/* + * This file is part of Sponge, licensed under the MIT License (MIT). + * + * Copyright (c) SpongePowered + * Copyright (c) contributors + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package org.spongepowered.common.data.key; + +import com.google.common.collect.ImmutableMap; +import io.leangen.geantyref.GenericTypeReflector; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import org.spongepowered.api.ResourceKeyed; +import org.spongepowered.api.data.Key; +import org.spongepowered.api.data.Keys; +import org.spongepowered.api.data.type.ShieldDamageReduction; +import org.spongepowered.api.data.type.ShieldItemDamageFunction; +import org.spongepowered.api.data.value.Value; +import org.spongepowered.api.effect.sound.SoundTypes; +import org.spongepowered.api.event.cause.entity.damage.DamageTypes; +import org.spongepowered.api.item.ItemTypes; +import org.spongepowered.api.item.inventory.ItemStack; +import org.spongepowered.api.tag.DamageTypeTags; +import org.spongepowered.api.util.Ticks; + +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.function.Function; + +public class KeysTest { + private final Map, Object> toTest = ImmutableMap., Object>builder() + .put(Keys.WEAPON_DAMAGE_PER_ATTACK, 5) + .put(Keys.DISABLE_BLOCKING_TICKS, Ticks.of(10)) + .put(Keys.BLOCK_DELAY_TICKS, Ticks.of(15)) + .put(Keys.DISABLED_BLOCKING_COOLDOWN_SCALE, 2.5f) + .put(Keys.SHIELD_DAMAGE_REDUCTIONS, List.of(ShieldDamageReduction.builder() + .horizontalBlockingAngle(45) + .constantReduction(2) + .fractionalReduction(0.5) + .damageTypes(Set.of(DamageTypes.ARROW.get(), DamageTypes.PLAYER_ATTACK.get())) + .build())) + .put(Keys.SHIELD_ITEM_DAMAGE_FUNCTION, ShieldItemDamageFunction.builder() + .constantDamage(5) + .fractionalDamage(2) + .minAttackDamage(2.5) + .build()) + .put(Keys.SHIELD_BLOCK_SOUND, SoundTypes.ENTITY_SHULKER_HURT.get()) + .put(Keys.SHIELD_DISABLE_SOUND, SoundTypes.ENTITY_ENDER_DRAGON_DEATH.get()) + .build(); + + @Test + void testSingleKeys() { + toTest.forEach(KeysTest::testSingleKeyUnchecked); + } + + @Test + void testBypassDamageTag() { + testSingleKey(Keys.BYPASS_DAMAGE_TAG, DamageTypeTags.BYPASSES_ARMOR, ResourceKeyed::key); + } + + @Test + void testAllWeaponKeys() { + final var stack = ItemStack.builder() + .itemType(ItemTypes.DIAMOND_SWORD) + .add(Keys.WEAPON_DAMAGE_PER_ATTACK, 5) + .add(Keys.DISABLE_BLOCKING_TICKS, Ticks.of(5)) + .build(); + + Assertions.assertEquals(5, stack.require(Keys.WEAPON_DAMAGE_PER_ATTACK)); + Assertions.assertEquals(Ticks.of(5), stack.require(Keys.DISABLE_BLOCKING_TICKS)); + + stack.remove(Keys.DISABLE_BLOCKING_TICKS); + Assertions.assertEquals(5, stack.require(Keys.WEAPON_DAMAGE_PER_ATTACK)); + + stack.remove(Keys.WEAPON_DAMAGE_PER_ATTACK); + + Assertions.assertNull(stack.getOrNull(Keys.WEAPON_DAMAGE_PER_ATTACK)); + Assertions.assertNull(stack.getOrNull(Keys.DISABLE_BLOCKING_TICKS)); + } + + @SuppressWarnings("unchecked") + private static > void testSingleKeyUnchecked(Key k, Object value) { + if (!GenericTypeReflector.isSuperType(k.elementType(), value.getClass())) { + throw new IllegalArgumentException("Invalid value type for key " + k.key() + ": " + value.getClass().getName()); + } + + testSingleKey((Key) k, (T) value, a -> a); + } + + private static > void testSingleKey(Key k, T value, Function equalityExtractor) { + final var stack = ItemStack.builder() + .itemType(ItemTypes.DIAMOND_SWORD) + .add(k, value) + .build(); + + Assertions.assertEquals(equalityExtractor.apply(value), equalityExtractor.apply(stack.require(k)), () -> "retrieved value is not equal " + + "to the original for " + k.key().asString()); + } + +} From 9ff4d975d1716b7a2f1de065d05fff51bd0f6fd5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ossi=20Erkkil=C3=A4?= Date: Sun, 28 Sep 2025 17:46:50 +0300 Subject: [PATCH 04/18] Rename Keys to be consistent & improve their Javadocs --- SpongeAPI | 2 +- .../data/provider/item/stack/ItemStackData.java | 4 +--- .../provider/item/stack/ShieldItemStackData.java | 8 ++++---- .../spongepowered/common/data/key/KeysTest.java | 14 +++++++------- 4 files changed, 13 insertions(+), 15 deletions(-) diff --git a/SpongeAPI b/SpongeAPI index 8b310746d31..ef134d6a298 160000 --- a/SpongeAPI +++ b/SpongeAPI @@ -1 +1 @@ -Subproject commit 8b310746d311575dc7e78d15fac3fe5004ebdfff +Subproject commit ef134d6a29810d454b32d20a1359f9936bc2e74b diff --git a/src/main/java/org/spongepowered/common/data/provider/item/stack/ItemStackData.java b/src/main/java/org/spongepowered/common/data/provider/item/stack/ItemStackData.java index 6eb6786f18f..e4d0d005a1c 100644 --- a/src/main/java/org/spongepowered/common/data/provider/item/stack/ItemStackData.java +++ b/src/main/java/org/spongepowered/common/data/provider/item/stack/ItemStackData.java @@ -48,8 +48,6 @@ import net.minecraft.world.item.component.UseCooldown; import net.minecraft.world.item.component.UseRemainder; import net.minecraft.world.item.component.Weapon; -import net.minecraft.world.item.consume_effects.ApplyStatusEffectsConsumeEffect; -import net.minecraft.world.item.consume_effects.ClearAllStatusEffectsConsumeEffect; import net.minecraft.world.item.consume_effects.ConsumeEffect; import org.checkerframework.checker.nullness.qual.Nullable; import org.spongepowered.api.Platform; @@ -397,7 +395,7 @@ public static void register(final DataProviderRegistrator registrator) { h.set(DataComponents.WEAPON, new Weapon(0, weapon.disableBlockingForSeconds())); } }) - .create(Keys.DISABLE_BLOCKING_TICKS) + .create(Keys.DISABLE_SHIELD_TICKS) .get(h -> { final @Nullable Weapon weapon = h.get(DataComponents.WEAPON); if (weapon == null) { diff --git a/src/main/java/org/spongepowered/common/data/provider/item/stack/ShieldItemStackData.java b/src/main/java/org/spongepowered/common/data/provider/item/stack/ShieldItemStackData.java index 973dda9b5fd..d83cdfe07b4 100644 --- a/src/main/java/org/spongepowered/common/data/provider/item/stack/ShieldItemStackData.java +++ b/src/main/java/org/spongepowered/common/data/provider/item/stack/ShieldItemStackData.java @@ -66,7 +66,7 @@ public static void register(final DataProviderRegistrator registrator) { h.set(DataComponents.BANNER_PATTERNS, new BannerPatternLayers(v.stream().map(BannerPatternLayers.Layer.class::cast).toList())); // TODO check setting banner base? Constants.TileEntity.Banner.BANNER_BASE / BannerPatternShapes.BASE }) - .create(Keys.BLOCK_DELAY_TICKS) + .create(Keys.SHIELD_DEPLOY_TICKS) .get(h -> { final @Nullable BlocksAttacks blocksAttacks = h.get(DataComponents.BLOCKS_ATTACKS); if (blocksAttacks == null) { @@ -86,19 +86,19 @@ public static void register(final DataProviderRegistrator registrator) { blocksAttacks.disableSound() )); }) - .create(Keys.DISABLED_BLOCKING_COOLDOWN_SCALE) + .create(Keys.DISABLE_SHIELD_TICKS_SCALE) .get(h -> { final @Nullable BlocksAttacks blocksAttacks = h.get(DataComponents.BLOCKS_ATTACKS); if (blocksAttacks == null) { return null; } - return blocksAttacks.disableCooldownScale(); + return (double) blocksAttacks.disableCooldownScale(); }) .set((h, v) -> { final @Nullable BlocksAttacks blocksAttacks = h.getOrDefault(DataComponents.BLOCKS_ATTACKS, BLOCKS_ATTACKS_DEFAULTS); h.set(DataComponents.BLOCKS_ATTACKS, new BlocksAttacks( blocksAttacks.blockDelaySeconds(), - v, + v.floatValue(), blocksAttacks.damageReductions(), blocksAttacks.itemDamage(), blocksAttacks.bypassedBy(), diff --git a/src/test/java/org/spongepowered/common/data/key/KeysTest.java b/src/test/java/org/spongepowered/common/data/key/KeysTest.java index 41dd7d80c5f..e7efb071325 100644 --- a/src/test/java/org/spongepowered/common/data/key/KeysTest.java +++ b/src/test/java/org/spongepowered/common/data/key/KeysTest.java @@ -49,9 +49,9 @@ public class KeysTest { private final Map, Object> toTest = ImmutableMap., Object>builder() .put(Keys.WEAPON_DAMAGE_PER_ATTACK, 5) - .put(Keys.DISABLE_BLOCKING_TICKS, Ticks.of(10)) - .put(Keys.BLOCK_DELAY_TICKS, Ticks.of(15)) - .put(Keys.DISABLED_BLOCKING_COOLDOWN_SCALE, 2.5f) + .put(Keys.DISABLE_SHIELD_TICKS, Ticks.of(10)) + .put(Keys.SHIELD_DEPLOY_TICKS, Ticks.of(15)) + .put(Keys.DISABLE_SHIELD_TICKS_SCALE, 2.5f) .put(Keys.SHIELD_DAMAGE_REDUCTIONS, List.of(ShieldDamageReduction.builder() .horizontalBlockingAngle(45) .constantReduction(2) @@ -82,19 +82,19 @@ void testAllWeaponKeys() { final var stack = ItemStack.builder() .itemType(ItemTypes.DIAMOND_SWORD) .add(Keys.WEAPON_DAMAGE_PER_ATTACK, 5) - .add(Keys.DISABLE_BLOCKING_TICKS, Ticks.of(5)) + .add(Keys.DISABLE_SHIELD_TICKS, Ticks.of(5)) .build(); Assertions.assertEquals(5, stack.require(Keys.WEAPON_DAMAGE_PER_ATTACK)); - Assertions.assertEquals(Ticks.of(5), stack.require(Keys.DISABLE_BLOCKING_TICKS)); + Assertions.assertEquals(Ticks.of(5), stack.require(Keys.DISABLE_SHIELD_TICKS)); - stack.remove(Keys.DISABLE_BLOCKING_TICKS); + stack.remove(Keys.DISABLE_SHIELD_TICKS); Assertions.assertEquals(5, stack.require(Keys.WEAPON_DAMAGE_PER_ATTACK)); stack.remove(Keys.WEAPON_DAMAGE_PER_ATTACK); Assertions.assertNull(stack.getOrNull(Keys.WEAPON_DAMAGE_PER_ATTACK)); - Assertions.assertNull(stack.getOrNull(Keys.DISABLE_BLOCKING_TICKS)); + Assertions.assertNull(stack.getOrNull(Keys.DISABLE_SHIELD_TICKS)); } @SuppressWarnings("unchecked") From 318b203a4c9fd7d0990c0516bda2abe3925a07d8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ossi=20Erkkil=C3=A4?= <52257907+avaruus1@users.noreply.github.com> Date: Sun, 28 Sep 2025 17:50:55 +0300 Subject: [PATCH 05/18] Add missed final modifiers Co-authored-by: Joni Aromaa --- .../common/item/SpongeShieldDamageReductionBuilder.java | 2 +- .../common/item/SpongeShieldItemDamageFunctionBuilder.java | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/org/spongepowered/common/item/SpongeShieldDamageReductionBuilder.java b/src/main/java/org/spongepowered/common/item/SpongeShieldDamageReductionBuilder.java index 0ae80cfd82e..c764d21869f 100644 --- a/src/main/java/org/spongepowered/common/item/SpongeShieldDamageReductionBuilder.java +++ b/src/main/java/org/spongepowered/common/item/SpongeShieldDamageReductionBuilder.java @@ -38,7 +38,7 @@ import java.util.Optional; import java.util.Set; -public class SpongeShieldDamageReductionBuilder implements ShieldDamageReduction.Builder { +public final class SpongeShieldDamageReductionBuilder implements ShieldDamageReduction.Builder { private HolderSet damageTypes; private Double horizontalBlockingAngle; private double base = 0; diff --git a/src/main/java/org/spongepowered/common/item/SpongeShieldItemDamageFunctionBuilder.java b/src/main/java/org/spongepowered/common/item/SpongeShieldItemDamageFunctionBuilder.java index 2a141f90135..0c1223ca522 100644 --- a/src/main/java/org/spongepowered/common/item/SpongeShieldItemDamageFunctionBuilder.java +++ b/src/main/java/org/spongepowered/common/item/SpongeShieldItemDamageFunctionBuilder.java @@ -28,7 +28,7 @@ import org.spongepowered.api.data.type.ShieldItemDamageFunction; import org.spongepowered.common.util.Preconditions; -public class SpongeShieldItemDamageFunctionBuilder implements ShieldItemDamageFunction.Builder { +public final class SpongeShieldItemDamageFunctionBuilder implements ShieldItemDamageFunction.Builder { private double minAttackDamage = 0; private double constantDamage = 0; private double fractionalDamage = 0; From ad5517d049a16b0f5f32668a3e052995ffda4e8a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ossi=20Erkkil=C3=A4?= Date: Sun, 28 Sep 2025 20:49:58 +0300 Subject: [PATCH 06/18] Rework ShieldDamageReduction & ShieldItemDamageFunction to be more future proof --- SpongeAPI | 2 +- ...locksAttacks_DamageReductionMixin_API.java | 41 ++++--------------- .../BlocksAttacks_ItemDamageFunction_API.java | 20 ++------- .../common/data/key/KeysTest.java | 2 +- 4 files changed, 15 insertions(+), 50 deletions(-) diff --git a/SpongeAPI b/SpongeAPI index ef134d6a298..36b13d797ce 160000 --- a/SpongeAPI +++ b/SpongeAPI @@ -1 +1 @@ -Subproject commit ef134d6a29810d454b32d20a1359f9936bc2e74b +Subproject commit 36b13d797ce71b850416d906c38735412d0e19e0 diff --git a/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_DamageReductionMixin_API.java b/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_DamageReductionMixin_API.java index 4f6b88ef238..fd90575dd37 100644 --- a/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_DamageReductionMixin_API.java +++ b/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_DamageReductionMixin_API.java @@ -24,46 +24,23 @@ */ package org.spongepowered.common.mixin.api.minecraft.world.item.component; -import net.minecraft.core.Holder; -import net.minecraft.core.HolderSet; import net.minecraft.world.item.component.BlocksAttacks; import org.spongepowered.api.data.type.ShieldDamageReduction; -import org.spongepowered.api.event.cause.entity.damage.DamageType; -import org.spongepowered.asm.mixin.*; - -import java.util.Optional; -import java.util.Set; -import java.util.stream.Collectors; +import org.spongepowered.api.event.cause.entity.damage.source.DamageSource; +import org.spongepowered.asm.mixin.Implements; +import org.spongepowered.asm.mixin.Interface; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Shadow; @Mixin(BlocksAttacks.DamageReduction.class) @Implements(@Interface(iface = ShieldDamageReduction.class, prefix = "shielddamagereduction$")) public abstract class BlocksAttacks_DamageReductionMixin_API implements ShieldDamageReduction { - @Shadow @Final private Optional> type; - @Shadow @Final private float base; - @Shadow @Final private float factor; - @Shadow @Final private float horizontalBlockingAngle; - - @Override - public Optional> damageTypes() { - return this.type.map(set -> set.stream() - .map(Holder::value) - .map(DamageType.class::cast) - .collect(Collectors.toSet())); - } - - public double shielddamagereduction$horizontalBlockingAngle() { - return this.horizontalBlockingAngle; - } - - @Override - public double constantReduction() { - return this.base; - } + @Shadow + public abstract float resolve(net.minecraft.world.damagesource.DamageSource $$0, float $$1, double $$2); - @Override - public double fractionalReduction() { - return this.factor; + public double shielddamagereduction$resolve(DamageSource source, double damage, double angle) { + return this.resolve((net.minecraft.world.damagesource.DamageSource) source, (float) damage, angle); } } diff --git a/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_ItemDamageFunction_API.java b/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_ItemDamageFunction_API.java index 278e98321d2..8dec3303bef 100644 --- a/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_ItemDamageFunction_API.java +++ b/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_ItemDamageFunction_API.java @@ -26,30 +26,18 @@ import net.minecraft.world.item.component.BlocksAttacks; import org.spongepowered.api.data.type.ShieldItemDamageFunction; -import org.spongepowered.asm.mixin.Final; import org.spongepowered.asm.mixin.Mixin; import org.spongepowered.asm.mixin.Shadow; @Mixin(BlocksAttacks.ItemDamageFunction.class) public abstract class BlocksAttacks_ItemDamageFunction_API implements ShieldItemDamageFunction { - @Shadow @Final private float threshold; - @Shadow @Final private float base; - @Shadow @Final private float factor; + @Shadow + public abstract int apply(float $$0); @Override - public double minAttackDamage() { - return this.threshold; - } - - @Override - public double constantDamage() { - return this.base; - } - - @Override - public double fractionalDamage() { - return this.factor; + public double resolve(double damage) { + return this.apply((float) damage); } } diff --git a/src/test/java/org/spongepowered/common/data/key/KeysTest.java b/src/test/java/org/spongepowered/common/data/key/KeysTest.java index e7efb071325..a0e342d0dc1 100644 --- a/src/test/java/org/spongepowered/common/data/key/KeysTest.java +++ b/src/test/java/org/spongepowered/common/data/key/KeysTest.java @@ -51,7 +51,7 @@ public class KeysTest { .put(Keys.WEAPON_DAMAGE_PER_ATTACK, 5) .put(Keys.DISABLE_SHIELD_TICKS, Ticks.of(10)) .put(Keys.SHIELD_DEPLOY_TICKS, Ticks.of(15)) - .put(Keys.DISABLE_SHIELD_TICKS_SCALE, 2.5f) + .put(Keys.DISABLE_SHIELD_TICKS_SCALE, 2.5) .put(Keys.SHIELD_DAMAGE_REDUCTIONS, List.of(ShieldDamageReduction.builder() .horizontalBlockingAngle(45) .constantReduction(2) From 0c1d1602af7c6f1d00dc635fdabc73d91da080eb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ossi=20Erkkil=C3=A4?= Date: Sun, 28 Sep 2025 21:00:16 +0300 Subject: [PATCH 07/18] Convert testSingleKeys to a parameterized test --- .../common/data/key/KeysTest.java | 54 ++++++++++--------- 1 file changed, 30 insertions(+), 24 deletions(-) diff --git a/src/test/java/org/spongepowered/common/data/key/KeysTest.java b/src/test/java/org/spongepowered/common/data/key/KeysTest.java index a0e342d0dc1..8f88ea9d837 100644 --- a/src/test/java/org/spongepowered/common/data/key/KeysTest.java +++ b/src/test/java/org/spongepowered/common/data/key/KeysTest.java @@ -24,10 +24,12 @@ */ package org.spongepowered.common.data.key; -import com.google.common.collect.ImmutableMap; import io.leangen.geantyref.GenericTypeReflector; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import org.spongepowered.api.ResourceKeyed; import org.spongepowered.api.data.Key; import org.spongepowered.api.data.Keys; @@ -42,34 +44,38 @@ import org.spongepowered.api.util.Ticks; import java.util.List; -import java.util.Map; import java.util.Set; import java.util.function.Function; +import java.util.stream.Stream; public class KeysTest { - private final Map, Object> toTest = ImmutableMap., Object>builder() - .put(Keys.WEAPON_DAMAGE_PER_ATTACK, 5) - .put(Keys.DISABLE_SHIELD_TICKS, Ticks.of(10)) - .put(Keys.SHIELD_DEPLOY_TICKS, Ticks.of(15)) - .put(Keys.DISABLE_SHIELD_TICKS_SCALE, 2.5) - .put(Keys.SHIELD_DAMAGE_REDUCTIONS, List.of(ShieldDamageReduction.builder() - .horizontalBlockingAngle(45) - .constantReduction(2) - .fractionalReduction(0.5) - .damageTypes(Set.of(DamageTypes.ARROW.get(), DamageTypes.PLAYER_ATTACK.get())) - .build())) - .put(Keys.SHIELD_ITEM_DAMAGE_FUNCTION, ShieldItemDamageFunction.builder() - .constantDamage(5) - .fractionalDamage(2) - .minAttackDamage(2.5) - .build()) - .put(Keys.SHIELD_BLOCK_SOUND, SoundTypes.ENTITY_SHULKER_HURT.get()) - .put(Keys.SHIELD_DISABLE_SOUND, SoundTypes.ENTITY_ENDER_DRAGON_DEATH.get()) - .build(); - @Test - void testSingleKeys() { - toTest.forEach(KeysTest::testSingleKeyUnchecked); + private static Stream testSingleKeys() { + return Stream.of( + Arguments.of(Keys.WEAPON_DAMAGE_PER_ATTACK, 5), + Arguments.of(Keys.DISABLE_SHIELD_TICKS, Ticks.of(10)), + Arguments.of(Keys.SHIELD_DEPLOY_TICKS, Ticks.of(15)), + Arguments.of(Keys.DISABLE_SHIELD_TICKS_SCALE, 2.5), + Arguments.of(Keys.SHIELD_DAMAGE_REDUCTIONS, List.of(ShieldDamageReduction.builder() + .horizontalBlockingAngle(45) + .constantReduction(2) + .fractionalReduction(0.5) + .damageTypes(Set.of(DamageTypes.ARROW.get(), DamageTypes.PLAYER_ATTACK.get())) + .build())), + Arguments.of(Keys.SHIELD_ITEM_DAMAGE_FUNCTION, ShieldItemDamageFunction.builder() + .constantDamage(5) + .fractionalDamage(2) + .minAttackDamage(2.5) + .build()), + Arguments.of(Keys.SHIELD_BLOCK_SOUND, SoundTypes.ENTITY_SHULKER_HURT.get()), + Arguments.of(Keys.SHIELD_DISABLE_SOUND, SoundTypes.ENTITY_ENDER_DRAGON_DEATH.get()) + ); + } + + @MethodSource + @ParameterizedTest + void testSingleKeys(Key k, Object value) { + testSingleKeyUnchecked(k, value); } @Test From c57018a15164753dc64128d55e22478c1c29e896 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ossi=20Erkkil=C3=A4?= Date: Sun, 28 Sep 2025 21:07:46 +0300 Subject: [PATCH 08/18] Sort keys --- SpongeAPI | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/SpongeAPI b/SpongeAPI index 36b13d797ce..f233d981a9f 160000 --- a/SpongeAPI +++ b/SpongeAPI @@ -1 +1 @@ -Subproject commit 36b13d797ce71b850416d906c38735412d0e19e0 +Subproject commit f233d981a9fd3c9e15c6c0a7ade8fcfc9ea10f23 From c295d80a92a58e8dab87faa94425afa2b1ed8195 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ossi=20Erkkil=C3=A4?= Date: Sun, 28 Sep 2025 21:08:35 +0300 Subject: [PATCH 09/18] Remove accidental whitespace --- SpongeAPI | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/SpongeAPI b/SpongeAPI index f233d981a9f..6b0b7ed0010 160000 --- a/SpongeAPI +++ b/SpongeAPI @@ -1 +1 @@ -Subproject commit f233d981a9fd3c9e15c6c0a7ade8fcfc9ea10f23 +Subproject commit 6b0b7ed0010d7051e1e6448ed4f0c292785e9473 From e686621472877177d06e033181f7c59dda230de9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ossi=20Erkkil=C3=A4?= Date: Mon, 29 Sep 2025 00:02:41 +0300 Subject: [PATCH 10/18] Rework ShieldDamageReduction & ShieldItemDamageFunction to be even more future proof --- SpongeAPI | 2 +- .../SpongeShieldDamageReductionFactory.java | 12 +++++++++++ ...eldDamageReductionMultiplyAddBuilder.java} | 20 +++++++++---------- ...SpongeShieldItemDamageFunctionFactory.java | 12 +++++++++++ ...ItemDamageFunctionMultiplyAddBuilder.java} | 16 +++++++-------- .../registry/SpongeBuilderProvider.java | 8 ++++---- .../registry/SpongeFactoryProvider.java | 6 ++++++ ...locksAttacks_DamageReductionMixin_API.java | 14 +++++++++---- .../BlocksAttacks_ItemDamageFunction_API.java | 2 +- .../common/data/key/KeysTest.java | 8 ++++---- 10 files changed, 68 insertions(+), 32 deletions(-) create mode 100644 src/main/java/org/spongepowered/common/item/shield/SpongeShieldDamageReductionFactory.java rename src/main/java/org/spongepowered/common/item/{SpongeShieldDamageReductionBuilder.java => shield/SpongeShieldDamageReductionMultiplyAddBuilder.java} (80%) create mode 100644 src/main/java/org/spongepowered/common/item/shield/SpongeShieldItemDamageFunctionFactory.java rename src/main/java/org/spongepowered/common/item/{SpongeShieldItemDamageFunctionBuilder.java => shield/SpongeShieldItemDamageFunctionMultiplyAddBuilder.java} (76%) diff --git a/SpongeAPI b/SpongeAPI index 6b0b7ed0010..f3d8cc566e3 160000 --- a/SpongeAPI +++ b/SpongeAPI @@ -1 +1 @@ -Subproject commit 6b0b7ed0010d7051e1e6448ed4f0c292785e9473 +Subproject commit f3d8cc566e308a2ed8f4df8d4768212737d5d35e diff --git a/src/main/java/org/spongepowered/common/item/shield/SpongeShieldDamageReductionFactory.java b/src/main/java/org/spongepowered/common/item/shield/SpongeShieldDamageReductionFactory.java new file mode 100644 index 00000000000..f16dadc8e17 --- /dev/null +++ b/src/main/java/org/spongepowered/common/item/shield/SpongeShieldDamageReductionFactory.java @@ -0,0 +1,12 @@ +package org.spongepowered.common.item.shield; + +import org.spongepowered.api.data.type.ShieldDamageReduction; + +public final class SpongeShieldDamageReductionFactory implements ShieldDamageReduction.Factory { + + @Override + public ShieldDamageReduction create(ShieldDamageReduction.MultiplyAdd config) { + return (ShieldDamageReduction) config; + } + +} diff --git a/src/main/java/org/spongepowered/common/item/SpongeShieldDamageReductionBuilder.java b/src/main/java/org/spongepowered/common/item/shield/SpongeShieldDamageReductionMultiplyAddBuilder.java similarity index 80% rename from src/main/java/org/spongepowered/common/item/SpongeShieldDamageReductionBuilder.java rename to src/main/java/org/spongepowered/common/item/shield/SpongeShieldDamageReductionMultiplyAddBuilder.java index c764d21869f..9f78bf02f74 100644 --- a/src/main/java/org/spongepowered/common/item/SpongeShieldDamageReductionBuilder.java +++ b/src/main/java/org/spongepowered/common/item/shield/SpongeShieldDamageReductionMultiplyAddBuilder.java @@ -22,7 +22,7 @@ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ -package org.spongepowered.common.item; +package org.spongepowered.common.item.shield; import net.minecraft.core.HolderSet; import net.minecraft.core.Registry; @@ -38,14 +38,14 @@ import java.util.Optional; import java.util.Set; -public final class SpongeShieldDamageReductionBuilder implements ShieldDamageReduction.Builder { +public final class SpongeShieldDamageReductionMultiplyAddBuilder implements ShieldDamageReduction.MultiplyAdd.Builder { private HolderSet damageTypes; private Double horizontalBlockingAngle; private double base = 0; private double factor = 0; @Override - public ShieldDamageReduction.Builder damageTypes(Set damageTypes) { + public ShieldDamageReduction.MultiplyAdd.Builder damageTypes(Set damageTypes) { final Registry registry = (Registry) Sponge.server().registry(RegistryTypes.DAMAGE_TYPE); this.damageTypes = HolderSet.direct(damageTypes.stream() @@ -56,7 +56,7 @@ public ShieldDamageReduction.Builder damageTypes(Set damageTypes) { } @Override - public ShieldDamageReduction.Builder damageTypes(Tag tag) { + public ShieldDamageReduction.MultiplyAdd.Builder damageTypes(Tag tag) { final Registry registry = (Registry) Sponge.server().registry(RegistryTypes.DAMAGE_TYPE); final var vanillaTag = ((TagBridge) tag).bridge$asVanillaTag(); this.damageTypes = registry.getOrThrow(vanillaTag); @@ -65,7 +65,7 @@ public ShieldDamageReduction.Builder damageTypes(Tag tag) { } @Override - public ShieldDamageReduction.Builder horizontalBlockingAngle(double angle) { + public ShieldDamageReduction.MultiplyAdd.Builder horizontalBlockingAngle(double angle) { Preconditions.checkArgument(angle > 0, "angle must be positive"); this.horizontalBlockingAngle = angle; @@ -73,22 +73,22 @@ public ShieldDamageReduction.Builder horizontalBlockingAngle(double angle) { } @Override - public ShieldDamageReduction.Builder constantReduction(double constant) { + public ShieldDamageReduction.MultiplyAdd.Builder constantReduction(double constant) { this.base = constant; return this; } @Override - public ShieldDamageReduction.Builder fractionalReduction(double fraction) { + public ShieldDamageReduction.MultiplyAdd.Builder fractionalReduction(double fraction) { this.factor = fraction; return this; } @Override - public ShieldDamageReduction build() { - return (ShieldDamageReduction) (Object) new BlocksAttacks.DamageReduction( + public ShieldDamageReduction.MultiplyAdd build() { + return (ShieldDamageReduction.MultiplyAdd) (Object) new BlocksAttacks.DamageReduction( horizontalBlockingAngle != null ? horizontalBlockingAngle.floatValue() : 90, Optional.ofNullable(damageTypes), (float) base, @@ -97,7 +97,7 @@ public ShieldDamageReduction build() { } @Override - public ShieldDamageReduction.Builder reset() { + public ShieldDamageReduction.MultiplyAdd.Builder reset() { this.damageTypes = null; this.horizontalBlockingAngle = null; this.base = 0; diff --git a/src/main/java/org/spongepowered/common/item/shield/SpongeShieldItemDamageFunctionFactory.java b/src/main/java/org/spongepowered/common/item/shield/SpongeShieldItemDamageFunctionFactory.java new file mode 100644 index 00000000000..3960fed3119 --- /dev/null +++ b/src/main/java/org/spongepowered/common/item/shield/SpongeShieldItemDamageFunctionFactory.java @@ -0,0 +1,12 @@ +package org.spongepowered.common.item.shield; + +import org.spongepowered.api.data.type.ShieldItemDamageFunction; + +public final class SpongeShieldItemDamageFunctionFactory implements ShieldItemDamageFunction.Factory { + + @Override + public ShieldItemDamageFunction create(ShieldItemDamageFunction.MultiplyAdd config) { + return (ShieldItemDamageFunction) config; + } + +} diff --git a/src/main/java/org/spongepowered/common/item/SpongeShieldItemDamageFunctionBuilder.java b/src/main/java/org/spongepowered/common/item/shield/SpongeShieldItemDamageFunctionMultiplyAddBuilder.java similarity index 76% rename from src/main/java/org/spongepowered/common/item/SpongeShieldItemDamageFunctionBuilder.java rename to src/main/java/org/spongepowered/common/item/shield/SpongeShieldItemDamageFunctionMultiplyAddBuilder.java index 0c1223ca522..85ba5e6f530 100644 --- a/src/main/java/org/spongepowered/common/item/SpongeShieldItemDamageFunctionBuilder.java +++ b/src/main/java/org/spongepowered/common/item/shield/SpongeShieldItemDamageFunctionMultiplyAddBuilder.java @@ -22,19 +22,19 @@ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ -package org.spongepowered.common.item; +package org.spongepowered.common.item.shield; import net.minecraft.world.item.component.BlocksAttacks; import org.spongepowered.api.data.type.ShieldItemDamageFunction; import org.spongepowered.common.util.Preconditions; -public final class SpongeShieldItemDamageFunctionBuilder implements ShieldItemDamageFunction.Builder { +public final class SpongeShieldItemDamageFunctionMultiplyAddBuilder implements ShieldItemDamageFunction.MultiplyAdd.Builder { private double minAttackDamage = 0; private double constantDamage = 0; private double fractionalDamage = 0; @Override - public ShieldItemDamageFunction.Builder minAttackDamage(double minDamage) { + public ShieldItemDamageFunction.MultiplyAdd.Builder minAttackDamage(double minDamage) { Preconditions.checkArgument(minDamage >= 0, "minAttackDamage must be >= 0"); this.minAttackDamage = minDamage; @@ -42,22 +42,22 @@ public ShieldItemDamageFunction.Builder minAttackDamage(double minDamage) { } @Override - public ShieldItemDamageFunction.Builder constantDamage(double constantDamage) { + public ShieldItemDamageFunction.MultiplyAdd.Builder constantDamage(double constantDamage) { this.constantDamage = constantDamage; return this; } @Override - public ShieldItemDamageFunction.Builder fractionalDamage(double fractionalDamage) { + public ShieldItemDamageFunction.MultiplyAdd.Builder fractionalDamage(double fractionalDamage) { this.fractionalDamage = fractionalDamage; return this; } @Override - public ShieldItemDamageFunction build() { - return (ShieldItemDamageFunction) (Object) new BlocksAttacks.ItemDamageFunction( + public ShieldItemDamageFunction.MultiplyAdd build() { + return (ShieldItemDamageFunction.MultiplyAdd) (Object) new BlocksAttacks.ItemDamageFunction( (float) minAttackDamage, (float) constantDamage, (float) fractionalDamage @@ -65,7 +65,7 @@ public ShieldItemDamageFunction build() { } @Override - public ShieldItemDamageFunction.Builder reset() { + public ShieldItemDamageFunction.MultiplyAdd.Builder reset() { this.minAttackDamage = 0; this.constantDamage = 0; this.fractionalDamage = 0; diff --git a/src/main/java/org/spongepowered/common/registry/SpongeBuilderProvider.java b/src/main/java/org/spongepowered/common/registry/SpongeBuilderProvider.java index 44b0a99f5c3..6e81b8bbccd 100644 --- a/src/main/java/org/spongepowered/common/registry/SpongeBuilderProvider.java +++ b/src/main/java/org/spongepowered/common/registry/SpongeBuilderProvider.java @@ -194,8 +194,8 @@ import org.spongepowered.common.inventory.query.SpongeQueryBuilder; import org.spongepowered.common.item.SpongeFireworkEffectBuilder; import org.spongepowered.common.item.SpongeItemStack; -import org.spongepowered.common.item.SpongeShieldDamageReductionBuilder; -import org.spongepowered.common.item.SpongeShieldItemDamageFunctionBuilder; +import org.spongepowered.common.item.shield.SpongeShieldDamageReductionMultiplyAddBuilder; +import org.spongepowered.common.item.shield.SpongeShieldItemDamageFunctionMultiplyAddBuilder; import org.spongepowered.common.item.enchantment.SpongeEnchantmentBuilder; import org.spongepowered.common.item.enchantment.SpongeRandomEnchantmentListBuilder; import org.spongepowered.common.item.generation.SpongeItemStackGenerator; @@ -399,8 +399,8 @@ public void registerDefaultBuilders() { .register(PortalLogic.Builder.class, SpongePortalLogicBuilder::new) .register(ServerWorldProperties.LoadOptions.Builder.class, SpongeServerWorldPropertiesLoadOptions.BuilderImpl::new) .register(WorldArchetype.Builder.class, SpongeWorldArchetype.BuilderImpl::new) - .register(ShieldDamageReduction.Builder.class, SpongeShieldDamageReductionBuilder::new) - .register(ShieldItemDamageFunction.Builder.class, SpongeShieldItemDamageFunctionBuilder::new) + .register(ShieldDamageReduction.MultiplyAdd.Builder.class, SpongeShieldDamageReductionMultiplyAddBuilder::new) + .register(ShieldItemDamageFunction.MultiplyAdd.Builder.class, SpongeShieldItemDamageFunctionMultiplyAddBuilder::new) ; } } diff --git a/src/main/java/org/spongepowered/common/registry/SpongeFactoryProvider.java b/src/main/java/org/spongepowered/common/registry/SpongeFactoryProvider.java index b39affb0bce..bdebce0d637 100644 --- a/src/main/java/org/spongepowered/common/registry/SpongeFactoryProvider.java +++ b/src/main/java/org/spongepowered/common/registry/SpongeFactoryProvider.java @@ -42,6 +42,8 @@ import org.spongepowered.api.command.selector.Selector; import org.spongepowered.api.data.DataManipulator; import org.spongepowered.api.data.type.ItemAction; +import org.spongepowered.api.data.type.ShieldDamageReduction; +import org.spongepowered.api.data.type.ShieldItemDamageFunction; import org.spongepowered.api.data.type.ToolRule; import org.spongepowered.api.data.value.Value; import org.spongepowered.api.effect.ForwardingViewer; @@ -133,6 +135,8 @@ import org.spongepowered.common.item.SpongeToolRuleFactory; import org.spongepowered.common.item.recipe.SpongeRecipeInputFactory; import org.spongepowered.common.item.recipe.smithing.SpongeArmorTrimFactory; +import org.spongepowered.common.item.shield.SpongeShieldDamageReductionFactory; +import org.spongepowered.common.item.shield.SpongeShieldItemDamageFunctionFactory; import org.spongepowered.common.item.util.SpongeItemStackComparatorFactory; import org.spongepowered.common.network.channel.SpongeChannelExceptionHandlerFactory; import org.spongepowered.common.network.status.SpongeFavicon; @@ -292,6 +296,8 @@ public void registerDefaultFactories() { .registerFactory(RecipeInput.Factory.class, new SpongeRecipeInputFactory()) .registerFactory(ArmorTrim.Factory.class, new SpongeArmorTrimFactory()) .registerFactory(RegistryRegistrationSet.Factory.class, new SpongeRegistryRegistrationSet.FactoryImpl()) + .registerFactory(ShieldDamageReduction.Factory.class, new SpongeShieldDamageReductionFactory()) + .registerFactory(ShieldItemDamageFunction.Factory.class, new SpongeShieldItemDamageFunctionFactory()) ; } } diff --git a/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_DamageReductionMixin_API.java b/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_DamageReductionMixin_API.java index fd90575dd37..81a8af84906 100644 --- a/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_DamageReductionMixin_API.java +++ b/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_DamageReductionMixin_API.java @@ -33,14 +33,20 @@ import org.spongepowered.asm.mixin.Shadow; @Mixin(BlocksAttacks.DamageReduction.class) -@Implements(@Interface(iface = ShieldDamageReduction.class, prefix = "shielddamagereduction$")) -public abstract class BlocksAttacks_DamageReductionMixin_API implements ShieldDamageReduction { +@Implements({ + @Interface(iface = ShieldDamageReduction.class, prefix = "shielddamagereduction$"), + @Interface(iface = ShieldDamageReduction.MultiplyAdd.class, prefix = "shielddamagereductionmultiplyadd$") +}) +public abstract class BlocksAttacks_DamageReductionMixin_API { - @Shadow - public abstract float resolve(net.minecraft.world.damagesource.DamageSource $$0, float $$1, double $$2); + @Shadow public abstract float resolve(net.minecraft.world.damagesource.DamageSource $$0, float $$1, double $$2); public double shielddamagereduction$resolve(DamageSource source, double damage, double angle) { return this.resolve((net.minecraft.world.damagesource.DamageSource) source, (float) damage, angle); } + public double shielddamagereductionmultiplyadd$resolve(DamageSource source, double damage, double angle) { + return this.shielddamagereduction$resolve(source, (float) damage, angle); + } + } diff --git a/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_ItemDamageFunction_API.java b/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_ItemDamageFunction_API.java index 8dec3303bef..c4404744422 100644 --- a/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_ItemDamageFunction_API.java +++ b/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_ItemDamageFunction_API.java @@ -30,7 +30,7 @@ import org.spongepowered.asm.mixin.Shadow; @Mixin(BlocksAttacks.ItemDamageFunction.class) -public abstract class BlocksAttacks_ItemDamageFunction_API implements ShieldItemDamageFunction { +public abstract class BlocksAttacks_ItemDamageFunction_API implements ShieldItemDamageFunction.MultiplyAdd, ShieldItemDamageFunction { @Shadow public abstract int apply(float $$0); diff --git a/src/test/java/org/spongepowered/common/data/key/KeysTest.java b/src/test/java/org/spongepowered/common/data/key/KeysTest.java index 8f88ea9d837..5a7f8a4ac9f 100644 --- a/src/test/java/org/spongepowered/common/data/key/KeysTest.java +++ b/src/test/java/org/spongepowered/common/data/key/KeysTest.java @@ -56,17 +56,17 @@ private static Stream testSingleKeys() { Arguments.of(Keys.DISABLE_SHIELD_TICKS, Ticks.of(10)), Arguments.of(Keys.SHIELD_DEPLOY_TICKS, Ticks.of(15)), Arguments.of(Keys.DISABLE_SHIELD_TICKS_SCALE, 2.5), - Arguments.of(Keys.SHIELD_DAMAGE_REDUCTIONS, List.of(ShieldDamageReduction.builder() + Arguments.of(Keys.SHIELD_DAMAGE_REDUCTIONS, List.of(ShieldDamageReduction.of(ShieldDamageReduction.MultiplyAdd.builder() .horizontalBlockingAngle(45) .constantReduction(2) .fractionalReduction(0.5) .damageTypes(Set.of(DamageTypes.ARROW.get(), DamageTypes.PLAYER_ATTACK.get())) - .build())), - Arguments.of(Keys.SHIELD_ITEM_DAMAGE_FUNCTION, ShieldItemDamageFunction.builder() + .build()))), + Arguments.of(Keys.SHIELD_ITEM_DAMAGE_FUNCTION, ShieldItemDamageFunction.of(ShieldItemDamageFunction.MultiplyAdd.builder() .constantDamage(5) .fractionalDamage(2) .minAttackDamage(2.5) - .build()), + .build())), Arguments.of(Keys.SHIELD_BLOCK_SOUND, SoundTypes.ENTITY_SHULKER_HURT.get()), Arguments.of(Keys.SHIELD_DISABLE_SOUND, SoundTypes.ENTITY_ENDER_DRAGON_DEATH.get()) ); From 2bed7887bd60f3b09a65a0aa0ebcc856c6fb9d2f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ossi=20Erkkil=C3=A4?= Date: Mon, 29 Sep 2025 00:04:13 +0300 Subject: [PATCH 11/18] Run spotlessApply --- .../SpongeShieldDamageReductionFactory.java | 24 +++++++++++++++++++ ...SpongeShieldItemDamageFunctionFactory.java | 24 +++++++++++++++++++ .../registry/SpongeBuilderProvider.java | 4 ++-- 3 files changed, 50 insertions(+), 2 deletions(-) diff --git a/src/main/java/org/spongepowered/common/item/shield/SpongeShieldDamageReductionFactory.java b/src/main/java/org/spongepowered/common/item/shield/SpongeShieldDamageReductionFactory.java index f16dadc8e17..1eab9f024fd 100644 --- a/src/main/java/org/spongepowered/common/item/shield/SpongeShieldDamageReductionFactory.java +++ b/src/main/java/org/spongepowered/common/item/shield/SpongeShieldDamageReductionFactory.java @@ -1,3 +1,27 @@ +/* + * This file is part of Sponge, licensed under the MIT License (MIT). + * + * Copyright (c) SpongePowered + * Copyright (c) contributors + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ package org.spongepowered.common.item.shield; import org.spongepowered.api.data.type.ShieldDamageReduction; diff --git a/src/main/java/org/spongepowered/common/item/shield/SpongeShieldItemDamageFunctionFactory.java b/src/main/java/org/spongepowered/common/item/shield/SpongeShieldItemDamageFunctionFactory.java index 3960fed3119..4812c02958e 100644 --- a/src/main/java/org/spongepowered/common/item/shield/SpongeShieldItemDamageFunctionFactory.java +++ b/src/main/java/org/spongepowered/common/item/shield/SpongeShieldItemDamageFunctionFactory.java @@ -1,3 +1,27 @@ +/* + * This file is part of Sponge, licensed under the MIT License (MIT). + * + * Copyright (c) SpongePowered + * Copyright (c) contributors + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ package org.spongepowered.common.item.shield; import org.spongepowered.api.data.type.ShieldItemDamageFunction; diff --git a/src/main/java/org/spongepowered/common/registry/SpongeBuilderProvider.java b/src/main/java/org/spongepowered/common/registry/SpongeBuilderProvider.java index 6e81b8bbccd..3ddcd3873f3 100644 --- a/src/main/java/org/spongepowered/common/registry/SpongeBuilderProvider.java +++ b/src/main/java/org/spongepowered/common/registry/SpongeBuilderProvider.java @@ -194,8 +194,6 @@ import org.spongepowered.common.inventory.query.SpongeQueryBuilder; import org.spongepowered.common.item.SpongeFireworkEffectBuilder; import org.spongepowered.common.item.SpongeItemStack; -import org.spongepowered.common.item.shield.SpongeShieldDamageReductionMultiplyAddBuilder; -import org.spongepowered.common.item.shield.SpongeShieldItemDamageFunctionMultiplyAddBuilder; import org.spongepowered.common.item.enchantment.SpongeEnchantmentBuilder; import org.spongepowered.common.item.enchantment.SpongeRandomEnchantmentListBuilder; import org.spongepowered.common.item.generation.SpongeItemStackGenerator; @@ -208,6 +206,8 @@ import org.spongepowered.common.item.recipe.ingredient.SpongeIngredientBuilder; import org.spongepowered.common.item.recipe.smithing.SpongeSmithingRecipeBuilder; import org.spongepowered.common.item.recipe.stonecutting.SpongeStoneCutterRecipeBuilder; +import org.spongepowered.common.item.shield.SpongeShieldDamageReductionMultiplyAddBuilder; +import org.spongepowered.common.item.shield.SpongeShieldItemDamageFunctionMultiplyAddBuilder; import org.spongepowered.common.map.canvas.SpongeMapCanvasBuilder; import org.spongepowered.common.map.color.SpongeMapColorBuilder; import org.spongepowered.common.map.decoration.SpongeMapDecorationBuilder; From fb5a14f2287ff4a6019687e50f49bf153b71c51b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ossi=20Erkkil=C3=A4?= Date: Mon, 29 Sep 2025 01:31:51 +0300 Subject: [PATCH 12/18] Revise based on feedback --- SpongeAPI | 2 +- .../item/stack/ShieldItemStackData.java | 4 +- ...locksAttacks_DamageReductionMixin_API.java | 46 ++++++++++++++++--- .../BlocksAttacks_ItemDamageFunction_API.java | 28 ++++++++++- 4 files changed, 68 insertions(+), 12 deletions(-) diff --git a/SpongeAPI b/SpongeAPI index f3d8cc566e3..2d23b8758d0 160000 --- a/SpongeAPI +++ b/SpongeAPI @@ -1 +1 @@ -Subproject commit f3d8cc566e308a2ed8f4df8d4768212737d5d35e +Subproject commit 2d23b8758d08ddc7e1b17e62a91a893124e562d5 diff --git a/src/main/java/org/spongepowered/common/data/provider/item/stack/ShieldItemStackData.java b/src/main/java/org/spongepowered/common/data/provider/item/stack/ShieldItemStackData.java index d83cdfe07b4..d0438441f6e 100644 --- a/src/main/java/org/spongepowered/common/data/provider/item/stack/ShieldItemStackData.java +++ b/src/main/java/org/spongepowered/common/data/provider/item/stack/ShieldItemStackData.java @@ -112,7 +112,7 @@ public static void register(final DataProviderRegistrator registrator) { if (blocksAttacks == null) { return null; } - return (List) (Object) List.copyOf(blocksAttacks.damageReductions()); + return (List>) (Object) List.copyOf(blocksAttacks.damageReductions()); }) .set((h, v) -> { final @Nullable BlocksAttacks blocksAttacks = h.getOrDefault(DataComponents.BLOCKS_ATTACKS, BLOCKS_ATTACKS_DEFAULTS); @@ -132,7 +132,7 @@ public static void register(final DataProviderRegistrator registrator) { if (blocksAttacks == null) { return null; } - return (ShieldItemDamageFunction) (Object) blocksAttacks.itemDamage(); + return (ShieldItemDamageFunction) (Object) blocksAttacks.itemDamage(); }) .set((h, v) -> { final @Nullable BlocksAttacks blocksAttacks = h.getOrDefault(DataComponents.BLOCKS_ATTACKS, BLOCKS_ATTACKS_DEFAULTS); diff --git a/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_DamageReductionMixin_API.java b/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_DamageReductionMixin_API.java index 81a8af84906..e5fb291280e 100644 --- a/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_DamageReductionMixin_API.java +++ b/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_DamageReductionMixin_API.java @@ -24,29 +24,61 @@ */ package org.spongepowered.common.mixin.api.minecraft.world.item.component; +import net.minecraft.core.Holder; +import net.minecraft.core.HolderSet; import net.minecraft.world.item.component.BlocksAttacks; import org.spongepowered.api.data.type.ShieldDamageReduction; +import org.spongepowered.api.event.cause.entity.damage.DamageType; import org.spongepowered.api.event.cause.entity.damage.source.DamageSource; -import org.spongepowered.asm.mixin.Implements; -import org.spongepowered.asm.mixin.Interface; -import org.spongepowered.asm.mixin.Mixin; -import org.spongepowered.asm.mixin.Shadow; +import org.spongepowered.asm.mixin.*; + +import java.util.Optional; +import java.util.Set; +import java.util.stream.Collectors; @Mixin(BlocksAttacks.DamageReduction.class) @Implements({ @Interface(iface = ShieldDamageReduction.class, prefix = "shielddamagereduction$"), @Interface(iface = ShieldDamageReduction.MultiplyAdd.class, prefix = "shielddamagereductionmultiplyadd$") }) -public abstract class BlocksAttacks_DamageReductionMixin_API { +public abstract class BlocksAttacks_DamageReductionMixin_API implements ShieldDamageReduction, ShieldDamageReduction.MultiplyAdd { + + @Shadow @Final private Optional> type; + @Shadow @Final private float base; + @Shadow @Final private float factor; + @Shadow @Final private float horizontalBlockingAngle; @Shadow public abstract float resolve(net.minecraft.world.damagesource.DamageSource $$0, float $$1, double $$2); + @Override + public MultiplyAdd configuration() { + return this; + } + public double shielddamagereduction$resolve(DamageSource source, double damage, double angle) { return this.resolve((net.minecraft.world.damagesource.DamageSource) source, (float) damage, angle); } - public double shielddamagereductionmultiplyadd$resolve(DamageSource source, double damage, double angle) { - return this.shielddamagereduction$resolve(source, (float) damage, angle); + @Override + public Optional> damageTypes() { + return this.type.map(set -> set.stream() + .map(Holder::value) + .map(DamageType.class::cast) + .collect(Collectors.toSet())); + } + + public double shielddamagereductionmultiplyadd$horizontalBlockingAngle() { + return this.horizontalBlockingAngle; + } + + @Override + public double constantReduction() { + return this.base; + } + + @Override + public double fractionalReduction() { + return this.factor; } } diff --git a/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_ItemDamageFunction_API.java b/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_ItemDamageFunction_API.java index c4404744422..7d5dab6817f 100644 --- a/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_ItemDamageFunction_API.java +++ b/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_ItemDamageFunction_API.java @@ -26,18 +26,42 @@ import net.minecraft.world.item.component.BlocksAttacks; import org.spongepowered.api.data.type.ShieldItemDamageFunction; +import org.spongepowered.asm.mixin.Final; import org.spongepowered.asm.mixin.Mixin; import org.spongepowered.asm.mixin.Shadow; @Mixin(BlocksAttacks.ItemDamageFunction.class) public abstract class BlocksAttacks_ItemDamageFunction_API implements ShieldItemDamageFunction.MultiplyAdd, ShieldItemDamageFunction { - @Shadow - public abstract int apply(float $$0); + @Shadow @Final private float threshold; + @Shadow @Final private float base; + @Shadow @Final private float factor; + + @Shadow public abstract int apply(float $$0); + + @Override + public MultiplyAdd configuration() { + return this; + } @Override public double resolve(double damage) { return this.apply((float) damage); } + @Override + public double minAttackDamage() { + return this.threshold; + } + + @Override + public double constantDamage() { + return this.base; + } + + @Override + public double fractionalDamage() { + return this.factor; + } + } From 7c95a66dcd373188456d911df9587e5c989aaa73 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ossi=20Erkkil=C3=A4?= <52257907+avaruus1@users.noreply.github.com> Date: Mon, 29 Sep 2025 01:36:14 +0300 Subject: [PATCH 13/18] Apply suggestions from code review Co-authored-by: Joni Aromaa --- .../common/item/shield/SpongeShieldDamageReductionFactory.java | 2 +- .../item/shield/SpongeShieldItemDamageFunctionFactory.java | 2 +- .../SpongeShieldItemDamageFunctionMultiplyAddBuilder.java | 2 +- .../item/component/BlocksAttacks_DamageReductionMixin_API.java | 2 +- .../item/component/BlocksAttacks_ItemDamageFunction_API.java | 2 +- 5 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/main/java/org/spongepowered/common/item/shield/SpongeShieldDamageReductionFactory.java b/src/main/java/org/spongepowered/common/item/shield/SpongeShieldDamageReductionFactory.java index 1eab9f024fd..719ab097f17 100644 --- a/src/main/java/org/spongepowered/common/item/shield/SpongeShieldDamageReductionFactory.java +++ b/src/main/java/org/spongepowered/common/item/shield/SpongeShieldDamageReductionFactory.java @@ -29,7 +29,7 @@ public final class SpongeShieldDamageReductionFactory implements ShieldDamageReduction.Factory { @Override - public ShieldDamageReduction create(ShieldDamageReduction.MultiplyAdd config) { + public ShieldDamageReduction create(final ShieldDamageReduction.MultiplyAdd config) { return (ShieldDamageReduction) config; } diff --git a/src/main/java/org/spongepowered/common/item/shield/SpongeShieldItemDamageFunctionFactory.java b/src/main/java/org/spongepowered/common/item/shield/SpongeShieldItemDamageFunctionFactory.java index 4812c02958e..6174a5cb8c1 100644 --- a/src/main/java/org/spongepowered/common/item/shield/SpongeShieldItemDamageFunctionFactory.java +++ b/src/main/java/org/spongepowered/common/item/shield/SpongeShieldItemDamageFunctionFactory.java @@ -29,7 +29,7 @@ public final class SpongeShieldItemDamageFunctionFactory implements ShieldItemDamageFunction.Factory { @Override - public ShieldItemDamageFunction create(ShieldItemDamageFunction.MultiplyAdd config) { + public ShieldItemDamageFunction create(final ShieldItemDamageFunction.MultiplyAdd config) { return (ShieldItemDamageFunction) config; } diff --git a/src/main/java/org/spongepowered/common/item/shield/SpongeShieldItemDamageFunctionMultiplyAddBuilder.java b/src/main/java/org/spongepowered/common/item/shield/SpongeShieldItemDamageFunctionMultiplyAddBuilder.java index 85ba5e6f530..1b1034740b3 100644 --- a/src/main/java/org/spongepowered/common/item/shield/SpongeShieldItemDamageFunctionMultiplyAddBuilder.java +++ b/src/main/java/org/spongepowered/common/item/shield/SpongeShieldItemDamageFunctionMultiplyAddBuilder.java @@ -35,7 +35,7 @@ public final class SpongeShieldItemDamageFunctionMultiplyAddBuilder implements S @Override public ShieldItemDamageFunction.MultiplyAdd.Builder minAttackDamage(double minDamage) { - Preconditions.checkArgument(minDamage >= 0, "minAttackDamage must be >= 0"); + Preconditions.checkArgument(minDamage >= 0, "minAttackDamage must not be negative"); this.minAttackDamage = minDamage; return this; diff --git a/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_DamageReductionMixin_API.java b/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_DamageReductionMixin_API.java index e5fb291280e..55bd1ceee42 100644 --- a/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_DamageReductionMixin_API.java +++ b/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_DamageReductionMixin_API.java @@ -48,7 +48,7 @@ public abstract class BlocksAttacks_DamageReductionMixin_API implements ShieldDa @Shadow @Final private float factor; @Shadow @Final private float horizontalBlockingAngle; - @Shadow public abstract float resolve(net.minecraft.world.damagesource.DamageSource $$0, float $$1, double $$2); + @Shadow public abstract float shadow$resolve(net.minecraft.world.damagesource.DamageSource $$0, float $$1, double $$2); @Override public MultiplyAdd configuration() { diff --git a/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_ItemDamageFunction_API.java b/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_ItemDamageFunction_API.java index 7d5dab6817f..679624e907c 100644 --- a/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_ItemDamageFunction_API.java +++ b/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_ItemDamageFunction_API.java @@ -45,7 +45,7 @@ public MultiplyAdd configuration() { } @Override - public double resolve(double damage) { + public double resolve(final double damage) { return this.apply((float) damage); } From d33644f6af7de005fb2804a7d70e22ff75cff23d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ossi=20Erkkil=C3=A4?= Date: Mon, 29 Sep 2025 01:38:23 +0300 Subject: [PATCH 14/18] Add missing 'final' from params --- .../SpongeShieldDamageReductionMultiplyAddBuilder.java | 10 +++++----- ...ongeShieldItemDamageFunctionMultiplyAddBuilder.java | 6 +++--- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/src/main/java/org/spongepowered/common/item/shield/SpongeShieldDamageReductionMultiplyAddBuilder.java b/src/main/java/org/spongepowered/common/item/shield/SpongeShieldDamageReductionMultiplyAddBuilder.java index 9f78bf02f74..7e43971aa0c 100644 --- a/src/main/java/org/spongepowered/common/item/shield/SpongeShieldDamageReductionMultiplyAddBuilder.java +++ b/src/main/java/org/spongepowered/common/item/shield/SpongeShieldDamageReductionMultiplyAddBuilder.java @@ -45,7 +45,7 @@ public final class SpongeShieldDamageReductionMultiplyAddBuilder implements Shie private double factor = 0; @Override - public ShieldDamageReduction.MultiplyAdd.Builder damageTypes(Set damageTypes) { + public ShieldDamageReduction.MultiplyAdd.Builder damageTypes(final Set damageTypes) { final Registry registry = (Registry) Sponge.server().registry(RegistryTypes.DAMAGE_TYPE); this.damageTypes = HolderSet.direct(damageTypes.stream() @@ -56,7 +56,7 @@ public ShieldDamageReduction.MultiplyAdd.Builder damageTypes(Set dam } @Override - public ShieldDamageReduction.MultiplyAdd.Builder damageTypes(Tag tag) { + public ShieldDamageReduction.MultiplyAdd.Builder damageTypes(final Tag tag) { final Registry registry = (Registry) Sponge.server().registry(RegistryTypes.DAMAGE_TYPE); final var vanillaTag = ((TagBridge) tag).bridge$asVanillaTag(); this.damageTypes = registry.getOrThrow(vanillaTag); @@ -65,7 +65,7 @@ public ShieldDamageReduction.MultiplyAdd.Builder damageTypes(Tag tag } @Override - public ShieldDamageReduction.MultiplyAdd.Builder horizontalBlockingAngle(double angle) { + public ShieldDamageReduction.MultiplyAdd.Builder horizontalBlockingAngle(final double angle) { Preconditions.checkArgument(angle > 0, "angle must be positive"); this.horizontalBlockingAngle = angle; @@ -73,14 +73,14 @@ public ShieldDamageReduction.MultiplyAdd.Builder horizontalBlockingAngle(double } @Override - public ShieldDamageReduction.MultiplyAdd.Builder constantReduction(double constant) { + public ShieldDamageReduction.MultiplyAdd.Builder constantReduction(final double constant) { this.base = constant; return this; } @Override - public ShieldDamageReduction.MultiplyAdd.Builder fractionalReduction(double fraction) { + public ShieldDamageReduction.MultiplyAdd.Builder fractionalReduction(final double fraction) { this.factor = fraction; return this; diff --git a/src/main/java/org/spongepowered/common/item/shield/SpongeShieldItemDamageFunctionMultiplyAddBuilder.java b/src/main/java/org/spongepowered/common/item/shield/SpongeShieldItemDamageFunctionMultiplyAddBuilder.java index 1b1034740b3..566f7d111aa 100644 --- a/src/main/java/org/spongepowered/common/item/shield/SpongeShieldItemDamageFunctionMultiplyAddBuilder.java +++ b/src/main/java/org/spongepowered/common/item/shield/SpongeShieldItemDamageFunctionMultiplyAddBuilder.java @@ -34,7 +34,7 @@ public final class SpongeShieldItemDamageFunctionMultiplyAddBuilder implements S private double fractionalDamage = 0; @Override - public ShieldItemDamageFunction.MultiplyAdd.Builder minAttackDamage(double minDamage) { + public ShieldItemDamageFunction.MultiplyAdd.Builder minAttackDamage(final double minDamage) { Preconditions.checkArgument(minDamage >= 0, "minAttackDamage must not be negative"); this.minAttackDamage = minDamage; @@ -42,14 +42,14 @@ public ShieldItemDamageFunction.MultiplyAdd.Builder minAttackDamage(double minDa } @Override - public ShieldItemDamageFunction.MultiplyAdd.Builder constantDamage(double constantDamage) { + public ShieldItemDamageFunction.MultiplyAdd.Builder constantDamage(final double constantDamage) { this.constantDamage = constantDamage; return this; } @Override - public ShieldItemDamageFunction.MultiplyAdd.Builder fractionalDamage(double fractionalDamage) { + public ShieldItemDamageFunction.MultiplyAdd.Builder fractionalDamage(final double fractionalDamage) { this.fractionalDamage = fractionalDamage; return this; From 623f10dd21dadb6610334af479a77c5441f1b846 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ossi=20Erkkil=C3=A4?= Date: Mon, 29 Sep 2025 01:49:03 +0300 Subject: [PATCH 15/18] Correctly use the 'shadow$' prefixed method name --- .../item/component/BlocksAttacks_DamageReductionMixin_API.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_DamageReductionMixin_API.java b/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_DamageReductionMixin_API.java index 55bd1ceee42..e753eeb4e6a 100644 --- a/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_DamageReductionMixin_API.java +++ b/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_DamageReductionMixin_API.java @@ -56,7 +56,7 @@ public MultiplyAdd configuration() { } public double shielddamagereduction$resolve(DamageSource source, double damage, double angle) { - return this.resolve((net.minecraft.world.damagesource.DamageSource) source, (float) damage, angle); + return this.shadow$resolve((net.minecraft.world.damagesource.DamageSource) source, (float) damage, angle); } @Override From 629fb3b9dda3141fd11f3abf82d7004df9804d98 Mon Sep 17 00:00:00 2001 From: aromaa Date: Mon, 29 Sep 2025 02:08:13 +0300 Subject: [PATCH 16/18] Bump API --- SpongeAPI | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/SpongeAPI b/SpongeAPI index 2d23b8758d0..214a97c9174 160000 --- a/SpongeAPI +++ b/SpongeAPI @@ -1 +1 @@ -Subproject commit 2d23b8758d08ddc7e1b17e62a91a893124e562d5 +Subproject commit 214a97c9174a315b226bc716c77d7a4d7c7091d2 From 0a49c2d2d009dce6b5a1d06a23a6d94e83335533 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ossi=20Erkkil=C3=A4?= Date: Mon, 29 Sep 2025 02:20:02 +0300 Subject: [PATCH 17/18] Add missing final, this & shadow prefixes --- .../SpongeShieldDamageReductionMultiplyAddBuilder.java | 4 ++-- .../SpongeShieldItemDamageFunctionMultiplyAddBuilder.java | 6 +++--- .../component/BlocksAttacks_DamageReductionMixin_API.java | 2 +- .../component/BlocksAttacks_ItemDamageFunction_API.java | 4 ++-- 4 files changed, 8 insertions(+), 8 deletions(-) diff --git a/src/main/java/org/spongepowered/common/item/shield/SpongeShieldDamageReductionMultiplyAddBuilder.java b/src/main/java/org/spongepowered/common/item/shield/SpongeShieldDamageReductionMultiplyAddBuilder.java index 7e43971aa0c..f50990ab0d7 100644 --- a/src/main/java/org/spongepowered/common/item/shield/SpongeShieldDamageReductionMultiplyAddBuilder.java +++ b/src/main/java/org/spongepowered/common/item/shield/SpongeShieldDamageReductionMultiplyAddBuilder.java @@ -89,8 +89,8 @@ public ShieldDamageReduction.MultiplyAdd.Builder fractionalReduction(final doubl @Override public ShieldDamageReduction.MultiplyAdd build() { return (ShieldDamageReduction.MultiplyAdd) (Object) new BlocksAttacks.DamageReduction( - horizontalBlockingAngle != null ? horizontalBlockingAngle.floatValue() : 90, - Optional.ofNullable(damageTypes), + this.horizontalBlockingAngle != null ? this.horizontalBlockingAngle.floatValue() : 90, + Optional.ofNullable(this.damageTypes), (float) base, (float) factor ); diff --git a/src/main/java/org/spongepowered/common/item/shield/SpongeShieldItemDamageFunctionMultiplyAddBuilder.java b/src/main/java/org/spongepowered/common/item/shield/SpongeShieldItemDamageFunctionMultiplyAddBuilder.java index 566f7d111aa..cb241ad33f6 100644 --- a/src/main/java/org/spongepowered/common/item/shield/SpongeShieldItemDamageFunctionMultiplyAddBuilder.java +++ b/src/main/java/org/spongepowered/common/item/shield/SpongeShieldItemDamageFunctionMultiplyAddBuilder.java @@ -58,9 +58,9 @@ public ShieldItemDamageFunction.MultiplyAdd.Builder fractionalDamage(final doubl @Override public ShieldItemDamageFunction.MultiplyAdd build() { return (ShieldItemDamageFunction.MultiplyAdd) (Object) new BlocksAttacks.ItemDamageFunction( - (float) minAttackDamage, - (float) constantDamage, - (float) fractionalDamage + (float) this.minAttackDamage, + (float) this.constantDamage, + (float) this.fractionalDamage ); } diff --git a/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_DamageReductionMixin_API.java b/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_DamageReductionMixin_API.java index e753eeb4e6a..248bc1f1910 100644 --- a/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_DamageReductionMixin_API.java +++ b/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_DamageReductionMixin_API.java @@ -55,7 +55,7 @@ public MultiplyAdd configuration() { return this; } - public double shielddamagereduction$resolve(DamageSource source, double damage, double angle) { + public double shielddamagereduction$resolve(final DamageSource source, final double damage, final double angle) { return this.shadow$resolve((net.minecraft.world.damagesource.DamageSource) source, (float) damage, angle); } diff --git a/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_ItemDamageFunction_API.java b/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_ItemDamageFunction_API.java index 679624e907c..558458c2460 100644 --- a/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_ItemDamageFunction_API.java +++ b/src/mixins/java/org/spongepowered/common/mixin/api/minecraft/world/item/component/BlocksAttacks_ItemDamageFunction_API.java @@ -37,7 +37,7 @@ public abstract class BlocksAttacks_ItemDamageFunction_API implements ShieldItem @Shadow @Final private float base; @Shadow @Final private float factor; - @Shadow public abstract int apply(float $$0); + @Shadow public abstract int shadow$apply(float $$0); @Override public MultiplyAdd configuration() { @@ -46,7 +46,7 @@ public MultiplyAdd configuration() { @Override public double resolve(final double damage) { - return this.apply((float) damage); + return this.shadow$apply((float) damage); } @Override From 50ab6371eb0717a7b9023423578dcf513c8785ce Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ossi=20Erkkil=C3=A4?= Date: Mon, 29 Sep 2025 02:21:08 +0300 Subject: [PATCH 18/18] More missing this --- .../shield/SpongeShieldDamageReductionMultiplyAddBuilder.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/org/spongepowered/common/item/shield/SpongeShieldDamageReductionMultiplyAddBuilder.java b/src/main/java/org/spongepowered/common/item/shield/SpongeShieldDamageReductionMultiplyAddBuilder.java index f50990ab0d7..194978f163d 100644 --- a/src/main/java/org/spongepowered/common/item/shield/SpongeShieldDamageReductionMultiplyAddBuilder.java +++ b/src/main/java/org/spongepowered/common/item/shield/SpongeShieldDamageReductionMultiplyAddBuilder.java @@ -91,8 +91,8 @@ public ShieldDamageReduction.MultiplyAdd build() { return (ShieldDamageReduction.MultiplyAdd) (Object) new BlocksAttacks.DamageReduction( this.horizontalBlockingAngle != null ? this.horizontalBlockingAngle.floatValue() : 90, Optional.ofNullable(this.damageTypes), - (float) base, - (float) factor + (float) this.base, + (float) this.factor ); }