chore(git): merge upstream changes

gabizou · gabizou · commit 1e5c9168abfe · 2025-09-30T19:52:50.000-07:00
Signed-off-by: Gabriel Harris-Rouquette &lt;gabizou@me.com&gt;
diff --git a/src/main/java/org/spongepowered/api/data/Keys.java b/src/main/java/org/spongepowered/api/data/Keys.java
@@ -91,6 +91,8 @@
 import org.spongepowered.api.data.type.RailDirection;
 import org.spongepowered.api.data.type.SalmonSize;
 import org.spongepowered.api.data.type.SculkSensorState;
+import org.spongepowered.api.data.type.ShieldDamageReduction;
+import org.spongepowered.api.data.type.ShieldItemDamageFunction;
 import org.spongepowered.api.data.type.SkinPart;
 import org.spongepowered.api.data.type.SlabPortion;
 import org.spongepowered.api.data.type.SpellType;
@@ -226,6 +228,7 @@
 import org.spongepowered.api.entity.vehicle.minecart.Minecart;
 import org.spongepowered.api.entity.vehicle.minecart.MinecartLike;
 import org.spongepowered.api.entity.weather.LightningBolt;
+import org.spongepowered.api.event.cause.entity.damage.DamageType;
 import org.spongepowered.api.event.cause.entity.damage.source.DamageSource;
 import org.spongepowered.api.event.cause.entity.damage.source.DamageSources;
 import org.spongepowered.api.fluid.FluidStackSnapshot;
@@ -642,6 +645,11 @@ public final class Keys {
      */
     public static final Key<Value<Integer>> BURN_TIME = Keys.key(ResourceKey.sponge("burn_time"), Integer.class);
 
+    /**
+     * The {@link DamageType} tag that bypasses a shield-like {@link ItemStack}.
+     */
+    public static final Key<Value<Tag<DamageType>>> BYPASS_DAMAGE_TAG = Keys.key(ResourceKey.sponge("bypass_damage_tag"), new TypeToken<>() {});
+
     /**
      * Whether an {@link ItemStack} can always be eaten.
      */
@@ -986,6 +994,17 @@ public final class Keys {
      */
     public static final Key<Value<Direction>> DIRECTION = Keys.key(ResourceKey.sponge("direction"), Direction.class);
 
+    /**
+     * The amount of {@link Ticks} this {@link ItemStack} disables blocking with a shield-like {@link ItemStack} on a successful attack.
+     */
+    public static final Key<Value<Ticks>> DISABLE_SHIELD_TICKS = Keys.key(ResourceKey.sponge("disable_shield_ticks"), Ticks.class);
+
+    /**
+     * The multiplier applied to the cooldown time during which blocking using this shield-like {@link ItemStack} is disabled.
+     * If set to 0, this item can never be disabled by attacks.
+     */
+    public static final Key<Value<Double>> DISABLE_SHIELD_TICKS_SCALE = Keys.key(ResourceKey.sponge("disable_shield_ticks_scale"), Double.class);
+
     /**
      * The display name of an {@link Entity}, {@link ItemStack} or {@link BlockEntity}.
      *
@@ -3056,6 +3075,31 @@ public final class Keys {
      */
     public static final Key<Value<Double>> SHADOW_STRENGTH = Keys.key(ResourceKey.sponge("shadow_strength"), Double.class);
 
+    /**
+     * The sound played when blocking an attack with a shield-like {@link ItemStack}.
+     */
+    public static final Key<Value<SoundType>> SHIELD_BLOCK_SOUND = Keys.key(ResourceKey.sponge("shield_block_sound"), SoundType.class);
+
+    /**
+     * The amount of attack damage a shield-like {@link ItemStack} reduces for certain {@link DamageType}s
+     */
+    public static final Key<ListValue<ShieldDamageReduction<?>>> SHIELD_DAMAGE_REDUCTIONS = Keys.listKey(ResourceKey.sponge("shield_damage_reductions"), new TypeToken<>() {});
+
+    /**
+     * The amount of {@link Ticks} player must use this shield-like {@link ItemStack} for to block attacks successfully.
+     */
+    public static final Key<Value<Ticks>> SHIELD_DEPLOY_TICKS = Keys.key(ResourceKey.sponge("shield_deploy_ticks"), Ticks.class);
+
+    /**
+     * The sound played when a shield-like {@link ItemStack} is disabled.
+     */
+    public static final Key<Value<SoundType>> SHIELD_DISABLE_SOUND = Keys.key(ResourceKey.sponge("shield_disable_sound"), SoundType.class);
+
+    /**
+     * Function for the amount of {@link Keys#ITEM_DURABILITY} damage a shield-like {@link ItemStack} takes when blocking an attack.
+     */
+    public static final Key<Value<ShieldItemDamageFunction<?>>> SHIELD_ITEM_DAMAGE_FUNCTION = Keys.key(ResourceKey.sponge("shield_item_damage_function"), new TypeToken<>() {});
+
     /**
      * The shooter of a {@link Projectile}.
      */
@@ -3550,6 +3594,11 @@ public final class Keys {
      */
     public static final Key<Value<Boolean>> WAXED = Keys.key(ResourceKey.sponge("waxed"), Boolean.class);
 
+    /**
+     * The {@link #ITEM_DURABILITY} damage an {@link ItemStack} takes per attack.
+     */
+    public static final Key<Value<Integer>> WEAPON_DAMAGE_PER_ATTACK = Keys.key(ResourceKey.sponge("weapon_damage_per_attack"), Integer.class);
+
     /**
      * The weather of a {@link ServerWorldProperties}.
      */
diff --git a/src/main/java/org/spongepowered/api/data/type/ShieldDamageReduction.java b/src/main/java/org/spongepowered/api/data/type/ShieldDamageReduction.java
@@ -0,0 +1,144 @@
+/*
+ * This file is part of SpongeAPI, licensed under the MIT License (MIT).
+ *
+ * Copyright (c) SpongePowered <https://www.spongepowered.org>
+ * 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.api.data.type;
+
+import org.spongepowered.api.Sponge;
+import org.spongepowered.api.event.cause.entity.damage.DamageType;
+import org.spongepowered.api.event.cause.entity.damage.source.DamageSource;
+import org.spongepowered.api.tag.Tag;
+import org.spongepowered.api.util.ResettableBuilder;
+
+import java.util.Optional;
+import java.util.Set;
+
+
+/**
+ * Defines the amount of damage reduced when blocking with a shield-like {@link org.spongepowered.api.item.inventory.ItemStack}.
+ */
+public interface ShieldDamageReduction<T> {
+
+    static ShieldDamageReduction<MultiplyAdd> of(MultiplyAdd config) {
+        return Sponge.game().factoryProvider().provide(Factory.class).create(config);
+    }
+
+    T configuration();
+
+    double resolve(DamageSource source, double damage, double angle);
+
+    interface Factory {
+
+        ShieldDamageReduction<MultiplyAdd> create(MultiplyAdd config);
+
+    }
+
+    /**
+     * The final amount of blocked damage will be {@code constantReduction + fractionalReduction * damage}
+     */
+    interface MultiplyAdd {
+
+        static Builder builder() {
+            return Sponge.game().builderProvider().provide(Builder.class);
+        }
+
+        /**
+         * Returns the {@link DamageType damage types} this reduction applies to.
+         * {@link Optional#empty()} means this reduction is not restricted to any given damage type.
+         *
+         * @return the affected damage types
+         */
+        Optional<Set<DamageType>> damageTypes();
+
+        /**
+         * Returns the maximum angle between the users facing direction and the direction of the incoming attack.
+         *
+         * @return the maximum angle
+         */
+        double horizontalBlockingAngle();
+
+        /**
+         * Returns the constant amount of damage to be blocked.
+         *
+         * @return a constant amount of damage to block
+         */
+        double constantReduction();
+
+        /**
+         * Returns fractional amount of damage to block, where a factor of 1 means that all damage is blocked,
+         * and a factor of 0 that no damage is blocked.
+         *
+         * @return fractional amount of damage to block
+         */
+        double fractionalReduction();
+
+        interface Builder extends ResettableBuilder<MultiplyAdd, Builder> {
+
+            /**
+             * Limits the {@link DamageType damage types} this reduction applies to.
+             *
+             * @param damageTypes the affected damage types
+             * @return This builder, for chaining
+             */
+            Builder damageTypes(Set<DamageType> damageTypes);
+
+            /**
+             * Limits the {@link DamageType damage types} this reduction applies to.
+             *
+             * @param tag the tag defining affected damage types
+             * @return This builder, for chaining
+             */
+            Builder damageTypes(Tag<DamageType> tag);
+
+            /**
+             * Sets the maximum angle between the users facing direction and the direction of the incoming attack.
+             *
+             * @param angle the maximum angle
+             * @return This builder, for chaining
+             */
+            Builder horizontalBlockingAngle(double angle);
+
+            /**
+             * Sets the constant amount of damage to be blocked.
+             *
+             * @param constant a constant amount of damage to block
+             * @return This builder, for chaining
+             */
+            Builder constantReduction(double constant);
+
+            /**
+             * Sets fractional amount of damage to block, where a factor of 1 means that all damage is blocked,
+             * and a factor of 0 that no damage is blocked.
+             *
+             * @param fraction fractional amount of damage to block
+             * @return This builder, for chaining
+             */
+            Builder fractionalReduction(double fraction);
+
+            MultiplyAdd build();
+
+        }
+
+    }
+
+}
diff --git a/src/main/java/org/spongepowered/api/data/type/ShieldItemDamageFunction.java b/src/main/java/org/spongepowered/api/data/type/ShieldItemDamageFunction.java
@@ -0,0 +1,114 @@
+/*
+ * This file is part of SpongeAPI, licensed under the MIT License (MIT).
+ *
+ * Copyright (c) SpongePowered <https://www.spongepowered.org>
+ * 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.api.data.type;
+
+import org.spongepowered.api.Sponge;
+import org.spongepowered.api.util.ResettableBuilder;
+
+/**
+ * Defines the amount of {@link org.spongepowered.api.data.Keys#ITEM_DURABILITY} damage a shield-like
+ * {@link org.spongepowered.api.item.inventory.ItemStack} takes, when blocking an attack.
+ */
+public interface ShieldItemDamageFunction<T> {
+
+    static ShieldItemDamageFunction<MultiplyAdd> of(MultiplyAdd config) {
+        return Sponge.game().factoryProvider().provide(Factory.class).create(config);
+    }
+
+    T configuration();
+
+    double resolve(double damage);
+
+    interface Factory {
+
+        ShieldItemDamageFunction<MultiplyAdd> create(MultiplyAdd config);
+
+    }
+
+    /**
+     * The final amount of damage will be {@code constantDamage + fractionalDamage * attackDamage}
+     */
+    interface MultiplyAdd {
+
+        static Builder builder() {
+            return Sponge.game().builderProvider().provide(Builder.class);
+        }
+
+        /**
+         * Returns the minimum amount of damage blocked attack must have had, for the item to take damage at all.
+         *
+         * @return minimum attack damage required for any durability loss
+         */
+        double minAttackDamage();
+
+        /**
+         * Returns the constant amount of damage taken.
+         *
+         * @return a constant amount of damage to take
+         */
+        double constantDamage();
+
+        /**
+         * Returns fractional amount of damage to take, where a factor of 1 means that the amount of durability lost is equal to attack damage,
+         * and a factor of 0 that no durability is lost.
+         *
+         * @return fractional amount of damage to take
+         */
+        double fractionalDamage();
+
+        interface Builder extends ResettableBuilder<MultiplyAdd, Builder> {
+
+            /**
+             * Sets the minimum amount of damage blocked attack must have had, for the item to take damage at all.
+             *
+             * @param minDamage minimum attack damage required for any durability loss
+             * @return This builder, for chaining
+             */
+            Builder minAttackDamage(double minDamage);
+
+            /**
+             * Sets the constant amount of damage taken.
+             *
+             * @param constantDamage a constant amount of damage to take
+             * @return This builder, for chaining
+             */
+            Builder constantDamage(double constantDamage);
+
+            /**
+             * Sets fractional amount of damage to take, where a factor of 1 means that the amount of durability lost is equal to attack damage,
+             * and a factor of 0 that no durability is lost.
+             *
+             * @param fractionalDamage fractional amount of damage to take
+             * @return This builder, for chaining
+             */
+            Builder fractionalDamage(double fractionalDamage);
+
+            MultiplyAdd build();
+
+        }
+
+    }
+
+}
