Update deps, bump min neo version to 21.0.31-beta, and adjust to support the damage pipeline update

Author: pupnewfster

README.md

@@ -86,7 +86,7 @@ dependencies {
 Add the following to your `gradle.properties` file (see [Maven](https://modmaven.dev/mekanism/Mekanism/) for the list of available versions):
 
 ```properties
-mekanism_version=1.21-10.6.0.44
+mekanism_version=1.21-10.6.2.46
 ```
 
 # Credits #

build.gradle

@@ -19,7 +19,7 @@ plugins {
     id('eclipse')
     id('idea')
     id('maven-publish')
-    id('net.neoforged.gradle.userdev') version('7.0.145')//https://projects.neoforged.net/neoforged/neogradle
+    id('net.neoforged.gradle.userdev') version('7.0.149')//https://projects.neoforged.net/neoforged/neogradle
 }
 
 tasks.named('wrapper', Wrapper).configure {
@@ -389,7 +389,8 @@ dependencies {
 
     def crt = "com.blamejared.crafttweaker:CraftTweaker-neoforge-${minecraft_version}:${crafttweaker_version}"
     compileOnly(crt)
-    localRuntime(crt)
+    //TODO: Re-enable when it updates to account for Neo's changes
+    //localRuntime(crt)
     def jeiTweaker = "com.blamejared.jeitweaker:JeiTweaker-forge-1.20.1:${jeitweaker_version}"
     compileOnly(jeiTweaker)
     //TODO: Re-enable when it updates
@@ -404,7 +405,7 @@ dependencies {
     compileOnly("top.theillusivec4.curios:curios-neoforge:${curios_version}:api")
     compileOnly("com.blamejared.recipestages:RecipeStages:${recipe_stages_version}")
     compileOnly("curse.maven:opencomputers2-437654:${oc2_id}")
-    compileOnly("cc.tweaked:cc-tweaked-${previous_minor_minecraft_version}-forge-api:${cc_tweaked_version}")
+    compileOnly("cc.tweaked:cc-tweaked-${minecraft_version}-forge-api:${cc_tweaked_version}")
     //localRuntime("cc.tweaked:cc-tweaked-${minecraft_version}-forge:${cc_tweaked_version}")
     compileOnly("curse.maven:female-gender-forge-481655:${wildfire_gender_mod_id}")
 

gradle.properties

@@ -9,11 +9,11 @@ minecraft_version=1.21
 previous_minecraft_version=1.20.4
 previous_minor_minecraft_version=1.20.6
 loader_version_range=[4,)
-forge_version=21.0.29-beta
+forge_version=21.0.31-beta
 mod_version=10.6.2
 #This determines the minimum version of forge required to use Mekanism
 # Only bump it whenever we need access to a feature in forge that is not available in earlier versions
-forge_version_range=[21.0.28-beta,)
+forge_version_range=[21.0.31-beta,)
 minecraft_version_range=[1.21]
 #This specifies what type of release it will be uploaded to CurseForge and Modrinth as
 # options are: alpha, beta, release
@@ -24,25 +24,26 @@ junit_version=5.10.2
 jqwik_version=1.8.5
 
 #NeoGradle Settings
-neogradle.subsystems.parchment.minecraftVersion=1.20.6
-neogradle.subsystems.parchment.mappingsVersion=2024.06.16
+neogradle.subsystems.parchment.minecraftVersion=1.21
+neogradle.subsystems.parchment.mappingsVersion=2024.06.23
 neogradle.subsystems.conventions.sourcesets.enabled=false
 
 #misc settings
 # recipe viewer, currently accepts: jei, emi, hybrid
-recipe_viewer=none
+recipe_viewer=jei
 
 #datagen
 yamlops_version=1.2.0
 
 #Mod dependencies
-crafttweaker_version=20.0.6
+cc_tweaked_version=1.111.0
+crafttweaker_version=20.0.11
 ctm_version=1.2.0+1
 curios_version=9.0.2+1.21
 emi_version=1.1.7
 jade_api_id=5427895
 jade_id=5444008
-jei_version=19.0.0.9
+jei_version=19.0.0.10
 top_version=1.21_neo-12.0.0-1
 wthit_version=12.2.1
 
@@ -59,7 +60,6 @@ glitchcore_version=2.0.0.1
 terrablender_version=4.0.0.1
 
 #Outdated mod dependencies
-cc_tweaked_version=1.111.0
 flux_networks_id=5234697
 jeitweaker_version=8.0.5
 json_things_version=0.10.0

src/main/java/mekanism/common/CommonPlayerTickHandler.java

@@ -35,6 +35,7 @@
 import net.minecraft.core.BlockPos;
 import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.util.Mth;
+import net.minecraft.world.damagesource.DamageSource;
 import net.minecraft.world.effect.MobEffectInstance;
 import net.minecraft.world.entity.EquipmentSlot;
 import net.minecraft.world.entity.LivingEntity;
@@ -46,10 +47,10 @@
 import net.minecraft.world.phys.Vec3;
 import net.neoforged.bus.api.SubscribeEvent;
 import net.neoforged.neoforge.common.NeoForgeMod;
-import net.neoforged.neoforge.event.entity.living.LivingAttackEvent;
+import net.neoforged.neoforge.common.damagesource.DamageContainer;
 import net.neoforged.neoforge.event.entity.living.LivingEvent.LivingJumpEvent;
 import net.neoforged.neoforge.event.entity.living.LivingFallEvent;
-import net.neoforged.neoforge.event.entity.living.LivingHurtEvent;
+import net.neoforged.neoforge.event.entity.living.LivingIncomingDamageEvent;
 import net.neoforged.neoforge.event.entity.player.PlayerEvent.BreakSpeed;
 import net.neoforged.neoforge.event.tick.PlayerTickEvent;
 import org.jetbrains.annotations.Nullable;
@@ -159,9 +160,12 @@ public static boolean isGravitationalModulationOn(Player player) {
     }
 
     @SubscribeEvent
-    public void onEntityAttacked(LivingAttackEvent event) {
+    @SuppressWarnings("UnstableApiUsage")//Note: DamageContainer isn't actually unstable, they just forgot to unmark it before finalizing the PR
+    public void onEntityAttacked(LivingIncomingDamageEvent event) {
         LivingEntity entity = event.getEntity();
-        if (event.getAmount() <= 0 || !entity.isAlive()) {
+        DamageContainer damageContainer = event.getContainer();
+        float damage = damageContainer.getNewDamage();
+        if (damage <= 0 || !entity.isAlive()) {
             //If some mod does weird things and causes the damage value to be negative or zero then exit
             // as our logic assumes there is actually damage happening and can crash if someone tries to
             // use a negative number as the damage value. We also check to make sure that we don't do
@@ -171,8 +175,9 @@ public void onEntityAttacked(LivingAttackEvent event) {
             // entity can't take damage while dead
             return;
         }
+        DamageSource source = damageContainer.getSource();
         //Gas Mask checks
-        if (event.getSource().is(MekanismAPITags.DamageTypes.IS_PREVENTABLE_MAGIC)) {
+        if (source.is(MekanismAPITags.DamageTypes.IS_PREVENTABLE_MAGIC)) {
             ItemStack headStack = entity.getItemBySlot(EquipmentSlot.HEAD);
             if (!headStack.isEmpty() && headStack.getItem() instanceof ItemScubaMask) {
                 ItemStack chestStack = entity.getItemBySlot(EquipmentSlot.CHEST);
@@ -183,35 +188,16 @@ public void onEntityAttacked(LivingAttackEvent event) {
             }
         }
         if (entity instanceof Player player) {
-            if (ItemMekaSuitArmor.tryAbsorbAll(player, event.getSource(), event.getAmount())) {
-                event.setCanceled(true);
-            }
-        }
-    }
-
-    @SubscribeEvent
-    public void onLivingHurt(LivingHurtEvent event) {
-        LivingEntity entity = event.getEntity();
-        if (event.getAmount() <= 0 || !entity.isAlive()) {
-            //If some mod does weird things and causes the damage value to be negative or zero then exit
-            // as our logic assumes there is actually damage happening and can crash if someone tries to
-            // use a negative number as the damage value. We also check to make sure that we don't do
-            // anything if the entity is dead as living attack is still fired when the entity is dead
-            // for things like fall damage if the entity dies before hitting the ground, and then energy
-            // would be depleted regardless if keep inventory is on even if no damage was stopped as the
-            // entity can't take damage while dead. While living hurt is not fired, we catch this case
-            // just in case anyway because it is a simple boolean check and there is no guarantee that
-            // other mods may not be firing the event manually even when the entity is dead
-            return;
-        }
-        if (entity instanceof Player player) {
-            float ratioAbsorbed = ItemMekaSuitArmor.getDamageAbsorbed(player, event.getSource(), event.getAmount());
+            //TODO - 1.21: Should we rewrite this to try and take advantage of the new reduction system? It would be kind of nice to move this to the
+            // spot that reduction from armor happens. Though then the base armor reduction will apply before our energy based reduction
+            // Is that fine? Maybe it is better, or maybe it is worse from a balance standpoint
+            float ratioAbsorbed = ItemMekaSuitArmor.getDamageAbsorbed(player, damageContainer.getSource(), damage);
             if (ratioAbsorbed > 0) {
-                float damageRemaining = event.getAmount() * Math.max(0, 1 - ratioAbsorbed);
+                float damageRemaining = damage * Math.max(0, 1 - ratioAbsorbed);
                 if (damageRemaining <= 0) {
                     event.setCanceled(true);
                 } else {
-                    event.setAmount(damageRemaining);
+                    damageContainer.setNewDamage(damageRemaining);
                 }
             }
         }

src/main/java/mekanism/common/entity/EntityRobit.java

@@ -125,8 +125,8 @@
 import net.minecraft.world.phys.Vec3;
 import net.neoforged.neoforge.client.model.data.ModelData;
 import net.neoforged.neoforge.client.model.data.ModelProperty;
-import net.neoforged.neoforge.common.CommonHooks;
 import net.neoforged.neoforge.common.NeoForge;
+import net.neoforged.neoforge.common.damagesource.DamageContainer;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -528,15 +528,11 @@ public boolean isInvulnerableTo(@NotNull DamageSource source) {
     }
 
     @Override
-    protected void actuallyHurt(@NotNull DamageSource damageSource, float amount) {
-        amount = CommonHooks.onLivingHurt(this, damageSource, amount);
-        if (amount <= 0) {
-            return;
-        }
-        amount = getDamageAfterArmorAbsorb(damageSource, amount);
-        amount = getDamageAfterMagicAbsorb(damageSource, amount);
-        energyContainer.extract(FloatingLong.create(1_000 * amount), Action.EXECUTE, AutomationType.INTERNAL);
-        getCombatTracker().recordDamage(damageSource, amount);
+    @SuppressWarnings("UnstableApiUsage")//Note: DamageContainer isn't actually unstable, they just forgot to unmark it before finalizing the PR
+    public void onDamageTaken(@NotNull DamageContainer damageContainer) {
+        energyContainer.extract(FloatingLong.create(1_000 * damageContainer.getNewDamage()), Action.EXECUTE, AutomationType.INTERNAL);
+        //Don't actually allow taking damage to reduce the robit's health
+        setHealth(getMaxHealth());
     }
 
     @Override

src/main/java/mekanism/common/item/gear/ItemMekaSuitArmor.java

@@ -433,22 +433,6 @@ public boolean shouldCauseBlockBreakReset(ItemStack oldStack, ItemStack newStack
     }
 
     public static float getDamageAbsorbed(Player player, DamageSource source, float amount) {
-        return getDamageAbsorbed(player, source, amount, null);
-    }
-
-    public static boolean tryAbsorbAll(Player player, DamageSource source, float amount) {
-        List<Runnable> energyUsageCallbacks = new ArrayList<>(4);
-        if (getDamageAbsorbed(player, source, amount, energyUsageCallbacks) >= 1) {
-            //If we can fully absorb it, actually use the energy from the various pieces and then return that we absorbed it all
-            for (Runnable energyUsageCallback : energyUsageCallbacks) {
-                energyUsageCallback.run();
-            }
-            return true;
-        }
-        return false;
-    }
-
-    private static float getDamageAbsorbed(Player player, DamageSource source, float amount, @Nullable List<Runnable> energyUseCallbacks) {
         if (amount <= 0) {
             return 0;
         }
@@ -525,13 +509,7 @@ private static float getDamageAbsorbed(Player player, DamageSource source, float
         }
         for (FoundArmorDetails details : armorDetails) {
             //Use energy/or enqueue usage for each piece as needed
-            if (!details.usageInfo.energyUsed.isZero()) {
-                if (energyUseCallbacks == null) {
-                    details.energyContainer.extract(details.usageInfo.energyUsed, Action.EXECUTE, AutomationType.MANUAL);
-                } else {
-                    energyUseCallbacks.add(details);
-                }
-            }
+            details.drainEnergy();
         }
         return Math.min(ratioAbsorbed, 1);
     }
@@ -569,7 +547,7 @@ private static float absorbDamage(EnergyUsageInfo usageInfo, float amount, float
         return 0;
     }
 
-    private static class FoundArmorDetails implements Runnable {
+    private static class FoundArmorDetails {
 
         private final IEnergyContainer energyContainer;
         private final EnergyUsageInfo usageInfo;
@@ -581,8 +559,7 @@ public FoundArmorDetails(IEnergyContainer energyContainer, ItemMekaSuitArmor arm
             this.armor = armor;
         }
 
-        @Override
-        public void run() {
+        public void drainEnergy() {
             energyContainer.extract(usageInfo.energyUsed, Action.EXECUTE, AutomationType.MANUAL);
         }
     }

src/main/java/mekanism/common/registries/MekanismDamageTypes.java

@@ -8,13 +8,15 @@
 import java.util.Map;
 import mekanism.api.text.IHasTranslationKey;
 import mekanism.common.Mekanism;
+import net.minecraft.core.Holder;
 import net.minecraft.core.RegistryAccess;
 import net.minecraft.core.registries.Registries;
 import net.minecraft.resources.ResourceKey;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.damagesource.DamageSource;
 import net.minecraft.world.damagesource.DamageType;
 import net.minecraft.world.level.Level;
+import net.minecraft.world.phys.Vec3;
 import org.jetbrains.annotations.NotNull;
 
 public class MekanismDamageTypes {
@@ -66,7 +68,19 @@ public DamageSource source(Level level) {
         }
 
         public DamageSource source(RegistryAccess registryAccess) {
-            return new DamageSource(registryAccess.registryOrThrow(Registries.DAMAGE_TYPE).getHolderOrThrow(key()));
+            return new DamageSource(holder(registryAccess));
+        }
+
+        public DamageSource source(Level level, Vec3 position) {
+            return source(level.registryAccess(), position);
+        }
+
+        public DamageSource source(RegistryAccess registryAccess, Vec3 position) {
+            return new DamageSource(holder(registryAccess), position);
+        }
+
+        private Holder<DamageType> holder(RegistryAccess registryAccess) {
+            return registryAccess.registryOrThrow(Registries.DAMAGE_TYPE).getHolderOrThrow(key());
         }
     }
 }