Revise based on feedback

Author: avaruus1

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

@@ -3073,7 +3073,7 @@ public final class Keys {
     /**
      * 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);
+    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.
@@ -3088,7 +3088,7 @@ public final class Keys {
     /**
      * 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);
+    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}.

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

@@ -30,6 +30,7 @@
 import org.spongepowered.api.tag.Tag;
 import org.spongepowered.api.util.ResettableBuilder;
 
+import java.util.Optional;
 import java.util.Set;
 
 
@@ -38,12 +39,14 @@
  */
 public interface ShieldDamageReduction<T> {
 
-    double resolve(DamageSource source, double damage, double angle);
-
     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);
@@ -55,12 +58,40 @@ interface Factory {
      */
     interface MultiplyAdd {
 
-        double resolve(DamageSource source, double damage, double angle);
-
         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> {
 
             /**

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

@@ -33,12 +33,14 @@
  */
 public interface ShieldItemDamageFunction<T> {
 
-    double resolve(double damage);
-
     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);
@@ -50,12 +52,32 @@ interface Factory {
      */
     interface MultiplyAdd {
 
-        double resolve(double damage);
-
         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> {
 
             /**