Expose minecraft:blocks_attacks related Keys

Author: avaruus1

src/main/java/org/spongepowered/api/data/Keys.java

@@ -89,6 +89,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;
@@ -223,6 +225,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;
@@ -3655,6 +3658,43 @@ public final class Keys {
      */
     public static final Key<Value<Ticks>> DISABLE_BLOCKING_TICKS = Keys.key(ResourceKey.sponge("disable_blocking_ticks"), Ticks.class);
 
+    /**
+     * The amount of {@link Ticks} player must use this {@link ItemStack} for to block attacks successfully.
+     */
+    public static final Key<Value<Ticks>> BLOCK_DELAY_TICKS = Keys.key(ResourceKey.sponge("block_delay_ticks"), Ticks.class);
+
+    /**
+     * Multiplier applied to the cooldown during which blocking using this item is disabled.
+     *
+     * @see <a href="https://minecraft.wiki/w/Data_component_format#blocks_attacks">blocks_attacks</a>
+     */
+    public static final Key<Value<Float>> DISABLED_BLOCKING_COOLDOWN_SCALE = Keys.key(ResourceKey.sponge("disabled_blocking_cooldown_scale"), Float.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"), ShieldDamageReduction.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"), ShieldItemDamageFunction.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<>() {});
+
+    /**
+     * 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 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);
+
     // SORTFIELDS:OFF
 
     // @formatter:on

src/main/java/org/spongepowered/api/data/type/ShieldDamageReduction.java

@@ -0,0 +1,67 @@
+package org.spongepowered.api.data.type;
+
+import org.spongepowered.api.Sponge;
+import org.spongepowered.api.event.cause.entity.damage.DamageType;
+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}.
+ * The final amount of blocked damage will be {@code constantReduction + fractionalReduction * damage}
+ */
+public interface ShieldDamageReduction {
+
+    /**
+     * 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();
+
+    static Builder builder() {
+        return Sponge.game().builderProvider().provide(Builder.class);
+    }
+
+    interface Builder extends ResettableBuilder<ShieldDamageReduction, Builder> {
+
+        Builder damageTypes(Set<DamageType> damageTypes);
+
+        Builder damageTypes(Tag<DamageType> tag);
+
+        Builder horizontalBlockingAngle(double angle);
+
+        Builder constantReduction(double constant);
+
+        Builder fractionalReduction(double fraction);
+
+        ShieldDamageReduction build();
+
+    }
+
+}

src/main/java/org/spongepowered/api/data/type/ShieldItemDamageFunction.java

@@ -0,0 +1,51 @@
+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.
+ * The final amount of damage will be {@code constantDamage + fractionalDamage * attackDamage}
+ */
+public interface ShieldItemDamageFunction {
+
+    /**
+     * 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();
+
+    static Builder builder() {
+        return Sponge.game().builderProvider().provide(Builder.class);
+    }
+
+    interface Builder extends ResettableBuilder<ShieldItemDamageFunction, Builder> {
+
+        Builder minAttackDamage(double minDamage);
+
+        Builder constantDamage(double constantDamage);
+
+        Builder fractionalDamage(double fractionalDamage);
+
+        ShieldItemDamageFunction build();
+
+    }
+
+}