add optional Draconic Evolution configurable integration

dependencies.gradle

@@ -4,6 +4,7 @@ dependencies {
     api("com.github.GTNewHorizons:GTNHLib:0.9.39:dev")
     devOnlyNonPublishable("com.github.GTNewHorizons:NotEnoughItems:2.8.75-GTNH:dev")
 
+    compileOnly("com.github.GTNewHorizons:Draconic-Evolution:1.5.26-GTNH:dev") {transitive = false}
     compileOnly("com.github.GTNewHorizons:ForestryMC:4.11.8:api") {transitive = false}
     compileOnly("com.github.GTNewHorizons:Botania:1.13.16-GTNH:dev") {transitive = false}
     compileOnly("com.github.GTNewHorizons:Mantle:0.5.1:dev") {transitive = false}

src/main/java/fox/spiteful/avaritia/LudicrousEvents.java

@@ -28,7 +28,9 @@
 import net.minecraftforge.event.entity.player.PlayerInteractEvent;
 import net.minecraftforge.oredict.OreDictionary;
 
+import cpw.mods.fml.common.eventhandler.EventPriority;
 import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import fox.spiteful.avaritia.compat.draconicevolution.InfinityArmorSetConfigHelpers;
 import fox.spiteful.avaritia.items.ItemFracturedOre;
 import fox.spiteful.avaritia.items.ItemMatterCluster;
 import fox.spiteful.avaritia.items.LudicrousItems;
@@ -192,23 +194,31 @@ public void onTooltip(ItemTooltipEvent event) {
         }
     }
 
-    @SubscribeEvent
+    @SubscribeEvent(priority = EventPriority.LOWEST)
     public void onGetHurt(LivingHurtEvent event) {
         if (!(event.entityLiving instanceof EntityPlayer player)) return;
         if (player.getHeldItem() != null && player.getHeldItem().getItem() == LudicrousItems.infinity_sword
                 && player.isUsingItem())
             event.setCanceled(true);
-        if (LudicrousItems.isInfinite(player) && !event.source.damageType.equals("infinity")) event.setCanceled(true);
+        if (InfinityArmorSetConfigHelpers.isInfinitySetEquipped(player)
+                && InfinityArmorSetConfigHelpers.isDamageImmune(player)
+                && !event.source.damageType.equals("infinity")) {
+            event.setCanceled(true);
+        }
     }
 
-    @SubscribeEvent
+    @SubscribeEvent(priority = EventPriority.LOWEST)
     public void onAttacked(LivingAttackEvent event) {
         if (!(event.entityLiving instanceof EntityPlayer player)) return;
         if (event.source.getEntity() != null && event.source.getEntity() instanceof EntityPlayer) return;
         if (player.getHeldItem() != null && player.getHeldItem().getItem() == LudicrousItems.infinity_sword
                 && player.isUsingItem())
             event.setCanceled(true);
-        if (LudicrousItems.isInfinite(player) && !event.source.damageType.equals("infinity")) event.setCanceled(true);
+        if (InfinityArmorSetConfigHelpers.isInfinitySetEquipped(player)
+                && InfinityArmorSetConfigHelpers.isDamageImmune(player)
+                && !event.source.damageType.equals("infinity")) {
+            event.setCanceled(true);
+        }
     }
 
     @SubscribeEvent
@@ -287,10 +297,12 @@ private static boolean isGarbageBlock(Block block) {
         return false;
     }
 
-    @SubscribeEvent
+    @SubscribeEvent(priority = EventPriority.LOWEST)
     public void onDeath(LivingDeathEvent event) {
         if (event.entityLiving instanceof EntityPlayer player) {
-            if (LudicrousItems.isInfinite(player) && !event.source.getDamageType().equals("infinity")) {
+            if (InfinityArmorSetConfigHelpers.isInfinitySetEquipped(player)
+                    && InfinityArmorSetConfigHelpers.isDeathImmune(player)
+                    && !event.source.getDamageType().equals("infinity")) {
                 event.setCanceled(true);
                 player.setHealth(player.getMaxHealth());
             }

src/main/java/fox/spiteful/avaritia/compat/Compat.java

@@ -43,6 +43,7 @@ public class Compat {
     public static boolean am2 = false;
     public static boolean forestry = false;
     public static boolean te = false;
+    public static boolean draconicEvolution = false;
 
     public static void census() {
         nei = Loader.isModLoaded("NotEnoughItems");
@@ -65,6 +66,7 @@ public static void census() {
         am2 = Loader.isModLoaded("arsmagica2") && Config.am2;
         forestry = Loader.isModLoaded("Forestry") && Config.forestry;
         te = Loader.isModLoaded("ThermalExpansion") && Config.te;
+        draconicEvolution = Loader.isModLoaded("DraconicEvolution");
 
         if (thaumic) {
             Lucrum.initTermination();

src/main/java/fox/spiteful/avaritia/compat/draconicevolution/InfinityArmorAbilityResolver.java

@@ -0,0 +1,63 @@
+package fox.spiteful.avaritia.compat.draconicevolution;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+
+public class InfinityArmorAbilityResolver {
+
+    private static final float LEGACY_SPEED_MULTIPLIER = 0F;
+    private static final float LEGACY_JUMP_MULTIPLIER = 0F;
+    private static final float LEGACY_FLIGHT_SPEED_MULTIPLIER = 1F;
+    private static final float LEGACY_VERTICAL_ACCELERATION = 0F;
+
+    private InfinityArmorAbilityResolver() {}
+
+    public static float getSpeedModifier(ItemStack stack, EntityPlayer player) {
+        return InfinityArmorConfigHelpers.getConditionalMultiplier(
+                stack,
+                player,
+                InfinityArmorConfigKeys.ARMOR_SPEED_MULT,
+                LEGACY_SPEED_MULTIPLIER);
+    }
+
+    public static float getJumpModifier(ItemStack stack, EntityPlayer player) {
+        return InfinityArmorConfigHelpers.getConditionalMultiplier(
+                stack,
+                player,
+                InfinityArmorConfigKeys.ARMOR_JUMP_MULT,
+                LEGACY_JUMP_MULTIPLIER);
+    }
+
+    public static boolean hasHillStep(ItemStack stack, EntityPlayer player) {
+        if (!InfinityArmorConfigHelpers.getBoolean(stack, InfinityArmorConfigKeys.ARMOR_HILL_STEP, true)) {
+            return false;
+        }
+        if (!InfinityArmorConfigHelpers.getBoolean(stack, InfinityArmorConfigKeys.ARMOR_SPRINT_ONLY, false)) {
+            return true;
+        }
+        return InfinityArmorConfigHelpers.isSprintConditionActive(stack, player);
+    }
+
+    public static boolean[] getFlightState(ItemStack stack) {
+        return new boolean[] { true,
+                InfinityArmorConfigHelpers.getBoolean(stack, InfinityArmorConfigKeys.ARMOR_FLIGHT_LOCK, false),
+                InfinityArmorConfigHelpers
+                        .getBoolean(stack, InfinityArmorConfigKeys.ARMOR_INERTIA_CANCELLATION, false) };
+    }
+
+    public static float getFlightSpeedModifier(ItemStack stack, EntityPlayer player) {
+        return InfinityArmorConfigHelpers.getConditionalFlightMultiplier(
+                stack,
+                player,
+                InfinityArmorConfigKeys.ARMOR_FLIGHT_SPEED_MULT,
+                LEGACY_FLIGHT_SPEED_MULTIPLIER);
+    }
+
+    public static float getFlightVerticalModifier(ItemStack stack, EntityPlayer player) {
+        return InfinityArmorConfigHelpers.getConditionalFlightMultiplier(
+                stack,
+                player,
+                InfinityArmorConfigKeys.ARMOR_VERTICAL_ACCELERATION,
+                LEGACY_VERTICAL_ACCELERATION);
+    }
+}

src/main/java/fox/spiteful/avaritia/compat/draconicevolution/InfinityArmorConfigFactory.java

@@ -0,0 +1,80 @@
+package fox.spiteful.avaritia.compat.draconicevolution;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import net.minecraft.item.ItemStack;
+
+import com.brandon3055.draconicevolution.common.lib.References;
+import com.brandon3055.draconicevolution.common.utils.ItemConfigField;
+
+public class InfinityArmorConfigFactory {
+
+    private InfinityArmorConfigFactory() {}
+
+    public static List<ItemConfigField> createFields(ItemStack stack, int slot, int armorType) {
+        List<ItemConfigField> fields = new ArrayList<>();
+
+        if (armorType == 0) {
+            fields.add(
+                    new ItemConfigField(References.BOOLEAN_ID, slot, InfinityArmorConfigKeys.ARMOR_NIGHT_VISION_ACTIVE)
+                            .readFromItem(stack, true));
+            fields.add(
+                    new ItemConfigField(References.BOOLEAN_ID, slot, InfinityArmorConfigKeys.ARMOR_NIGHT_VISION_LOCK)
+                            .readFromItem(stack, true));
+            fields.add(
+                    new ItemConfigField(References.BOOLEAN_ID, slot, InfinityArmorConfigKeys.ARMOR_WATER_BREATHING)
+                            .readFromItem(stack, true));
+            fields.add(
+                    new ItemConfigField(References.BOOLEAN_ID, slot, InfinityArmorConfigKeys.ARMOR_AUTO_FEED)
+                            .readFromItem(stack, true));
+        } else if (armorType == 1) {
+            fields.add(
+                    new ItemConfigField(References.FLOAT_ID, slot, InfinityArmorConfigKeys.ARMOR_VERTICAL_ACCELERATION)
+                            .setMinMaxAndIncromente(0F, 8F, 0.1F).readFromItem(stack, 0F).setModifier("PLUSPERCENT"));
+            fields.add(
+                    new ItemConfigField(References.FLOAT_ID, slot, InfinityArmorConfigKeys.ARMOR_FLIGHT_SPEED_MULT)
+                            .setMinMaxAndIncromente(0F, 6F, 0.1F).readFromItem(stack, 1F).setModifier("PLUSPERCENT"));
+            fields.add(
+                    new ItemConfigField(References.BOOLEAN_ID, slot, InfinityArmorConfigKeys.ARMOR_EFFECTIVE_ON_SPRINT)
+                            .readFromItem(stack, false));
+            fields.add(
+                    new ItemConfigField(References.BOOLEAN_ID, slot, InfinityArmorConfigKeys.ARMOR_FLIGHT_LOCK)
+                            .readFromItem(stack, false));
+            fields.add(
+                    new ItemConfigField(References.BOOLEAN_ID, slot, InfinityArmorConfigKeys.ARMOR_INERTIA_CANCELLATION)
+                            .readFromItem(stack, false));
+            fields.add(
+                    new ItemConfigField(References.BOOLEAN_ID, slot, InfinityArmorConfigKeys.ARMOR_REMOVE_NEGATIVE)
+                            .readFromItem(stack, true));
+            fields.add(
+                    new ItemConfigField(References.BOOLEAN_ID, slot, InfinityArmorConfigKeys.ARMOR_DAMAGE_IMMUNITY)
+                            .readFromItem(stack, true));
+            fields.add(
+                    new ItemConfigField(References.BOOLEAN_ID, slot, InfinityArmorConfigKeys.ARMOR_DEATH_IMMUNITY)
+                            .readFromItem(stack, true));
+        } else if (armorType == 2) {
+            fields.add(
+                    new ItemConfigField(References.FLOAT_ID, slot, InfinityArmorConfigKeys.ARMOR_SPEED_MULT)
+                            .setMinMaxAndIncromente(0F, 8F, 0.1F).readFromItem(stack, 0F).setModifier("PLUSPERCENT"));
+            fields.add(
+                    new ItemConfigField(References.BOOLEAN_ID, slot, InfinityArmorConfigKeys.ARMOR_SPRINT_ONLY)
+                            .readFromItem(stack, false));
+            fields.add(
+                    new ItemConfigField(References.BOOLEAN_ID, slot, InfinityArmorConfigKeys.ARMOR_EXTINGUISH)
+                            .readFromItem(stack, true));
+        } else if (armorType == 3) {
+            fields.add(
+                    new ItemConfigField(References.FLOAT_ID, slot, InfinityArmorConfigKeys.ARMOR_JUMP_MULT)
+                            .setMinMaxAndIncromente(0F, 15F, 0.1F).readFromItem(stack, 0F).setModifier("PLUSPERCENT"));
+            fields.add(
+                    new ItemConfigField(References.BOOLEAN_ID, slot, InfinityArmorConfigKeys.ARMOR_SPRINT_ONLY)
+                            .readFromItem(stack, false));
+            fields.add(
+                    new ItemConfigField(References.BOOLEAN_ID, slot, InfinityArmorConfigKeys.ARMOR_HILL_STEP)
+                            .readFromItem(stack, true));
+        }
+
+        return fields;
+    }
+}

src/main/java/fox/spiteful/avaritia/compat/draconicevolution/InfinityArmorConfigHelpers.java

@@ -0,0 +1,46 @@
+package fox.spiteful.avaritia.compat.draconicevolution;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+
+import fox.spiteful.avaritia.compat.Compat;
+
+public class InfinityArmorConfigHelpers {
+
+    private InfinityArmorConfigHelpers() {}
+
+    public static boolean getBoolean(ItemStack stack, String key, boolean defaultValue) {
+        if (!Compat.draconicEvolution || stack == null) {
+            return defaultValue;
+        }
+        return InfinityConfigProfileBridge.getBoolean(stack, key, defaultValue);
+    }
+
+    public static float getFloat(ItemStack stack, String key, float defaultValue) {
+        if (!Compat.draconicEvolution || stack == null) {
+            return defaultValue;
+        }
+        return InfinityConfigProfileBridge.getFloat(stack, key, defaultValue);
+    }
+
+    public static boolean isSprintConditionActive(ItemStack stack, EntityPlayer player) {
+        return player.isSprinting() || player.isSneaking();
+    }
+
+    public static float getConditionalMultiplier(ItemStack stack, EntityPlayer player, String key, float defaultValue) {
+        float configuredValue = getFloat(stack, key, defaultValue);
+        if (!getBoolean(stack, InfinityArmorConfigKeys.ARMOR_SPRINT_ONLY, false)) {
+            return configuredValue;
+        }
+        return isSprintConditionActive(stack, player) ? configuredValue : configuredValue / 5F;
+    }
+
+    public static float getConditionalFlightMultiplier(ItemStack stack, EntityPlayer player, String key,
+            float defaultValue) {
+        float configuredValue = getFloat(stack, key, defaultValue);
+        if (!getBoolean(stack, InfinityArmorConfigKeys.ARMOR_EFFECTIVE_ON_SPRINT, false)) {
+            return configuredValue;
+        }
+        return isSprintConditionActive(stack, player) ? configuredValue : 0F;
+    }
+}

src/main/java/fox/spiteful/avaritia/compat/draconicevolution/InfinityArmorConfigKeys.java

@@ -0,0 +1,24 @@
+package fox.spiteful.avaritia.compat.draconicevolution;
+
+public class InfinityArmorConfigKeys {
+
+    public static final String ARMOR_NIGHT_VISION_ACTIVE = "ArmorNVActive";
+    public static final String ARMOR_NIGHT_VISION_LOCK = "ArmorNVLock";
+    public static final String ARMOR_VERTICAL_ACCELERATION = "VerticalAcceleration";
+    public static final String ARMOR_FLIGHT_SPEED_MULT = "ArmorFlightSpeedMult";
+    public static final String ARMOR_EFFECTIVE_ON_SPRINT = "EffectiveOnSprint";
+    public static final String ARMOR_FLIGHT_LOCK = "ArmorFlightLock";
+    public static final String ARMOR_INERTIA_CANCELLATION = "ArmorInertiaCancellation";
+    public static final String ARMOR_SPEED_MULT = "ArmorSpeedMult";
+    public static final String ARMOR_SPRINT_ONLY = "ArmorSprintOnly";
+    public static final String ARMOR_JUMP_MULT = "ArmorJumpMult";
+    public static final String ARMOR_HILL_STEP = "ArmorHillStep";
+    public static final String ARMOR_AUTO_FEED = "AvaritiaArmorAutoFeed";
+    public static final String ARMOR_REMOVE_NEGATIVE = "AvaritiaArmorRemoveNegative";
+    public static final String ARMOR_EXTINGUISH = "AvaritiaArmorExtinguish";
+    public static final String ARMOR_WATER_BREATHING = "AvaritiaArmorWaterBreathing";
+    public static final String ARMOR_DAMAGE_IMMUNITY = "AvaritiaArmorDamageImmunity";
+    public static final String ARMOR_DEATH_IMMUNITY = "AvaritiaArmorDeathImmunity";
+
+    private InfinityArmorConfigKeys() {}
+}

src/main/java/fox/spiteful/avaritia/compat/draconicevolution/InfinityArmorEffectHandler.java

@@ -0,0 +1,88 @@
+package fox.spiteful.avaritia.compat.draconicevolution;
+
+import java.util.Collection;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.potion.Potion;
+import net.minecraft.potion.PotionEffect;
+
+import it.unimi.dsi.fastutil.ints.IntArrayList;
+
+public class InfinityArmorEffectHandler {
+
+    private InfinityArmorEffectHandler() {}
+
+    public static void handleArmorTick(EntityPlayer player, ItemStack stack, int armorType) {
+        if (armorType == 0) {
+            handleHelmetTick(player, stack);
+            return;
+        }
+        if (armorType == 1) {
+            handleChestTick(player, stack);
+            return;
+        }
+        if (armorType == 2) {
+            handleLeggingsTick(player, stack);
+        }
+    }
+
+    private static void handleHelmetTick(EntityPlayer player, ItemStack stack) {
+        boolean nightVisionActive = InfinityArmorConfigHelpers
+                .getBoolean(stack, InfinityArmorConfigKeys.ARMOR_NIGHT_VISION_ACTIVE, true);
+        boolean nightVisionLock = InfinityArmorConfigHelpers
+                .getBoolean(stack, InfinityArmorConfigKeys.ARMOR_NIGHT_VISION_LOCK, true);
+        boolean lowLight = player.worldObj
+                .getBlockLightValue((int) Math.floor(player.posX), (int) player.posY + 1, (int) Math.floor(player.posZ))
+                < 5;
+
+        if (nightVisionActive && (nightVisionLock || lowLight)) {
+            player.addPotionEffect(new PotionEffect(Potion.nightVision.id, 419, 0, true));
+        } else if (player.isPotionActive(Potion.nightVision.id)) {
+            player.removePotionEffect(Potion.nightVision.id);
+        }
+
+        if (InfinityArmorConfigHelpers.getBoolean(stack, InfinityArmorConfigKeys.ARMOR_WATER_BREATHING, true)) {
+            player.setAir(300);
+        }
+        if (InfinityArmorConfigHelpers.getBoolean(stack, InfinityArmorConfigKeys.ARMOR_AUTO_FEED, true)) {
+            player.getFoodStats().addStats(20, 20F);
+        }
+    }
+
+    private static void handleChestTick(EntityPlayer player, ItemStack stack) {
+        if (!InfinityArmorConfigHelpers.getBoolean(stack, InfinityArmorConfigKeys.ARMOR_REMOVE_NEGATIVE, true)) {
+            return;
+        }
+
+        Collection<PotionEffect> effects = player.getActivePotionEffects();
+        if (effects.isEmpty()) {
+            return;
+        }
+
+        IntArrayList negativeEffectIds = null;
+        for (PotionEffect potion : effects) {
+            if (Potion.potionTypes[potion.getPotionID()].isBadEffect) {
+                if (negativeEffectIds == null) {
+                    negativeEffectIds = new IntArrayList();
+                }
+                negativeEffectIds.add(potion.getPotionID());
+            }
+        }
+
+        if (negativeEffectIds == null || negativeEffectIds.isEmpty()) {
+            return;
+        }
+
+        for (int potionId : negativeEffectIds) {
+            player.removePotionEffect(potionId);
+        }
+    }
+
+    private static void handleLeggingsTick(EntityPlayer player, ItemStack stack) {
+        if (InfinityArmorConfigHelpers.getBoolean(stack, InfinityArmorConfigKeys.ARMOR_EXTINGUISH, true)
+                && player.isBurning()) {
+            player.extinguish();
+        }
+    }
+}