Bump min Neo version to 21.0.4-beta and account for breaking changes

Author: pupnewfster

build.gradle

@@ -391,7 +391,8 @@ dependencies {
 
     def crt = "com.blamejared.crafttweaker:CraftTweaker-neoforge-${minecraft_version}:${crafttweaker_version}"
     compileOnly(crt)
-    localRuntime(crt)
+    //TODO: Re-enable when it updates to neo changes
+    //localRuntime(crt)
     def jeiTweaker = "com.blamejared.jeitweaker:JeiTweaker-forge-1.20.1:${jeitweaker_version}"
     compileOnly(jeiTweaker)
     //TODO: Re-enable when it updates

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.37-beta
+forge_version=21.0.40-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.31-beta,)
+forge_version_range=[21.0.4-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

src/api/java/mekanism/api/gear/ICustomModule.java

@@ -18,7 +18,7 @@
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.context.UseOnContext;
-import net.neoforged.neoforge.common.ToolAction;
+import net.neoforged.neoforge.common.ItemAbility;
 import net.neoforged.neoforge.event.ItemAttributeModifierEvent;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -285,14 +285,14 @@ default InteractionResult onItemUse(IModule<MODULE> module, UseOnContext context
     }
 
     /**
-     * Called to check if this module allows the Meka-Tool to perform a specific {@link ToolAction}.
+     * Called to check if this module allows the Meka-Tool to perform a specific {@link net.neoforged.neoforge.common.ItemAbility}.
      *
      * @param module          Module instance.
      * @param moduleContainer The container this module is part of.
      * @param stack           The stack this module is installed on.
-     * @param action          Tool action to check.
+     * @param ability         Item ability to check.
      */
-    default boolean canPerformAction(IModule<MODULE> module, IModuleContainer moduleContainer, ItemStack stack, ToolAction action) {
+    default boolean canPerformAction(IModule<MODULE> module, IModuleContainer moduleContainer, ItemStack stack, ItemAbility ability) {
         return false;
     }
 

src/main/java/mekanism/common/content/gear/mekatool/ModuleFarmingUnit.java

@@ -37,6 +37,7 @@
 import net.minecraft.sounds.SoundEvent;
 import net.minecraft.sounds.SoundEvents;
 import net.minecraft.sounds.SoundSource;
+import net.minecraft.tags.BlockTags;
 import net.minecraft.util.ByIdMap;
 import net.minecraft.util.StringRepresentable;
 import net.minecraft.world.InteractionResult;
@@ -52,9 +53,8 @@
 import net.minecraft.world.phys.AABB;
 import net.minecraft.world.phys.BlockHitResult;
 import net.minecraft.world.phys.Vec3;
-import net.neoforged.neoforge.common.IPlantable;
-import net.neoforged.neoforge.common.ToolAction;
-import net.neoforged.neoforge.common.ToolActions;
+import net.neoforged.neoforge.common.ItemAbilities;
+import net.neoforged.neoforge.common.ItemAbility;
 import net.neoforged.neoforge.common.util.Lazy;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -91,9 +91,9 @@ public InteractionResult onItemUse(IModule<ModuleFarmingUnit> module, UseOnConte
         Lazy<BlockState> lazyClickedState = Lazy.of(() -> context.getLevel().getBlockState(context.getClickedPos()));
         return MekanismUtils.performActions(
               //First try to use the disassembler as an axe
-              useAxeAOE(context, lazyClickedState, energyContainer, diameter, ToolActions.AXE_STRIP, SoundEvents.AXE_STRIP, -1),
-              () -> useAxeAOE(context, lazyClickedState, energyContainer, diameter, ToolActions.AXE_SCRAPE, SoundEvents.AXE_SCRAPE, LevelEvent.PARTICLES_SCRAPE),
-              () -> useAxeAOE(context, lazyClickedState, energyContainer, diameter, ToolActions.AXE_WAX_OFF, SoundEvents.AXE_WAX_OFF, LevelEvent.PARTICLES_WAX_OFF),
+              useAxeAOE(context, lazyClickedState, energyContainer, diameter, ItemAbilities.AXE_STRIP, SoundEvents.AXE_STRIP, -1),
+              () -> useAxeAOE(context, lazyClickedState, energyContainer, diameter, ItemAbilities.AXE_SCRAPE, SoundEvents.AXE_SCRAPE, LevelEvent.PARTICLES_SCRAPE),
+              () -> useAxeAOE(context, lazyClickedState, energyContainer, diameter, ItemAbilities.AXE_WAX_OFF, SoundEvents.AXE_WAX_OFF, LevelEvent.PARTICLES_WAX_OFF),
               //Then as a shovel
               () -> flattenAOE(context, lazyClickedState, energyContainer, diameter),
               () -> dowseCampfire(context, lazyClickedState, energyContainer),
@@ -103,18 +103,18 @@ public InteractionResult onItemUse(IModule<ModuleFarmingUnit> module, UseOnConte
     }
 
     @Override
-    public boolean canPerformAction(IModule<ModuleFarmingUnit> module, IModuleContainer moduleContainer, ItemStack stack, ToolAction action) {
-        if (action == ToolActions.AXE_STRIP || action == ToolActions.AXE_SCRAPE || action == ToolActions.AXE_WAX_OFF) {
+    public boolean canPerformAction(IModule<ModuleFarmingUnit> module, IModuleContainer moduleContainer, ItemStack stack, ItemAbility action) {
+        if (action == ItemAbilities.AXE_STRIP || action == ItemAbilities.AXE_SCRAPE || action == ItemAbilities.AXE_WAX_OFF) {
             return module.hasEnoughEnergy(stack, MekanismConfig.gear.mekaToolEnergyUsageAxe);
-        } else if (action == ToolActions.SHOVEL_FLATTEN) {
+        } else if (action == ItemAbilities.SHOVEL_FLATTEN) {
             return module.hasEnoughEnergy(stack, MekanismConfig.gear.mekaToolEnergyUsageShovel);
-        } else if (action == ToolActions.HOE_TILL) {
+        } else if (action == ItemAbilities.HOE_TILL) {
             return module.hasEnoughEnergy(stack, MekanismConfig.gear.mekaToolEnergyUsageHoe);
         }
         //Note: In general when we get here there will be no tool actions known unless mods add more default tool actions
         // This is because we special case the known vanilla types above and the dig variants are already handled by the Meka-Tool itself before
         // it even checks the installed modules
-        return ToolActions.DEFAULT_AXE_ACTIONS.contains(action) || ToolActions.DEFAULT_SHOVEL_ACTIONS.contains(action) || ToolActions.DEFAULT_HOE_ACTIONS.contains(action);
+        return ItemAbilities.DEFAULT_AXE_ACTIONS.contains(action) || ItemAbilities.DEFAULT_SHOVEL_ACTIONS.contains(action) || ItemAbilities.DEFAULT_HOE_ACTIONS.contains(action);
     }
 
     @NothingNullByDefault
@@ -179,7 +179,7 @@ private InteractionResult dowseCampfire(UseOnContext context, Lazy<BlockState> l
     }
 
     private InteractionResult tillAOE(UseOnContext context, Lazy<BlockState> lazyClickedState, IEnergyContainer energyContainer, int diameter) {
-        return useAOE(context, lazyClickedState, energyContainer, diameter, ToolActions.HOE_TILL, SoundEvents.HOE_TILL, -1,
+        return useAOE(context, lazyClickedState, energyContainer, diameter, ItemAbilities.HOE_TILL, SoundEvents.HOE_TILL, -1,
               MekanismConfig.gear.mekaToolEnergyUsageHoe.get(), new HoeToolAOEData());
     }
 
@@ -189,17 +189,17 @@ private InteractionResult flattenAOE(UseOnContext context, Lazy<BlockState> lazy
             //Don't allow flattening a block from underneath
             return InteractionResult.PASS;
         }
-        return useAOE(context, lazyClickedState, energyContainer, diameter, ToolActions.SHOVEL_FLATTEN, SoundEvents.SHOVEL_FLATTEN, -1,
+        return useAOE(context, lazyClickedState, energyContainer, diameter, ItemAbilities.SHOVEL_FLATTEN, SoundEvents.SHOVEL_FLATTEN, -1,
               MekanismConfig.gear.mekaToolEnergyUsageShovel.get(), new ShovelToolAOEData());
     }
 
-    private InteractionResult useAxeAOE(UseOnContext context, Lazy<BlockState> lazyClickedState, IEnergyContainer energyContainer, int diameter, ToolAction action,
+    private InteractionResult useAxeAOE(UseOnContext context, Lazy<BlockState> lazyClickedState, IEnergyContainer energyContainer, int diameter, ItemAbility action,
           SoundEvent sound, int particle) {
         return useAOE(context, lazyClickedState, energyContainer, diameter, action, sound, particle, MekanismConfig.gear.mekaToolEnergyUsageAxe.get(),
               new AxeToolAOEData());
     }
 
-    private InteractionResult useAOE(UseOnContext context, Lazy<BlockState> lazyClickedState, IEnergyContainer energyContainer, int diameter, ToolAction action,
+    private InteractionResult useAOE(UseOnContext context, Lazy<BlockState> lazyClickedState, IEnergyContainer energyContainer, int diameter, ItemAbility action,
           SoundEvent sound, int particle, FloatingLong energyUsage, IToolAOEData toolAOEData) {
         FloatingLong energy = energyContainer.getEnergy();
         if (energy.smallerThan(energyUsage)) {
@@ -326,7 +326,8 @@ public boolean isValid(Level level, BlockPos pos, BlockState state) {
             }
             //Or it is a replaceable plant that is also not solid (such as tall grass)
             //Note: This may not be the most optimal way of checking this, but it gives a decent enough estimate of it
-            if (aboveState.is(MekanismTags.Blocks.FARMING_OVERRIDE) || aboveState.canBeReplaced() && aboveState.getBlock() instanceof IPlantable) {
+            //TODO - 1.21: Do we want to try and come up with a better tag or check for if it is a replaceable plant?
+            if (aboveState.is(MekanismTags.Blocks.FARMING_OVERRIDE) || aboveState.canBeReplaced() && aboveState.is(BlockTags.REPLACEABLE_BY_TREES)) {
                 return aboveState.getFluidState().isEmpty() && !aboveState.isSolidRender(level, abovePos);
             }
             return false;

src/main/java/mekanism/common/content/gear/mekatool/ModuleShearingUnit.java

@@ -37,8 +37,8 @@
 import net.minecraft.world.level.gameevent.GameEvent;
 import net.minecraft.world.phys.AABB;
 import net.neoforged.neoforge.common.IShearable;
-import net.neoforged.neoforge.common.ToolAction;
-import net.neoforged.neoforge.common.ToolActions;
+import net.neoforged.neoforge.common.ItemAbilities;
+import net.neoforged.neoforge.common.ItemAbility;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -50,8 +50,8 @@ public class ModuleShearingUnit implements ICustomModule<ModuleShearingUnit> {
     private static final Predicate<Entity> SHEARABLE = entity -> !entity.isSpectator() && entity instanceof IShearable;
 
     @Override
-    public boolean canPerformAction(IModule<ModuleShearingUnit> module, IModuleContainer container, ItemStack stack, ToolAction action) {
-        if (action == ToolActions.SHEARS_DISARM) {
+    public boolean canPerformAction(IModule<ModuleShearingUnit> module, IModuleContainer container, ItemStack stack, ItemAbility action) {
+        if (action == ItemAbilities.SHEARS_DISARM) {
             if (stack.getItem() instanceof ItemMekaTool) {
                 //Only require energy if we are installed on a Meka-Tool and can thus calculate the energy required to break the block "safely"
                 // Note: We assume hardness is zero like the default is for tripwires as we don't have the target block in our current context
@@ -61,12 +61,12 @@ public boolean canPerformAction(IModule<ModuleShearingUnit> module, IModuleConta
             //Note: If for some reason we are installed on something that is not the Meka-Tool don't stop the action from being enabled
             // as it may not actually require energy
             return true;
-        } else if (action == ToolActions.SHEARS_DIG) {
+        } else if (action == ItemAbilities.SHEARS_DIG) {
             //Note: If for some reason we are installed on something that is not the Meka-Tool don't stop the action from being enabled
             // as it may not actually require energy
             return !(stack.getItem() instanceof ItemMekaTool) || ItemMekaTool.hasEnergyForDigAction(container, module.getEnergyContainer(stack));
         }
-        return ToolActions.DEFAULT_SHEARS_ACTIONS.contains(action);
+        return ItemAbilities.DEFAULT_SHEARS_ACTIONS.contains(action);
     }
 
     @NotNull

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

@@ -70,8 +70,8 @@
 import net.minecraft.world.level.Level;
 import net.minecraft.world.level.block.state.BlockState;
 import net.neoforged.neoforge.client.extensions.common.IClientItemExtensions;
-import net.neoforged.neoforge.common.ToolAction;
-import net.neoforged.neoforge.common.ToolActions;
+import net.neoforged.neoforge.common.ItemAbilities;
+import net.neoforged.neoforge.common.ItemAbility;
 import net.neoforged.neoforge.common.util.Lazy;
 import net.neoforged.neoforge.event.ItemAttributeModifierEvent;
 import net.neoforged.neoforge.registries.holdersets.AnyHolderSet;
@@ -80,8 +80,8 @@
 public class ItemAtomicDisassembler extends ItemEnergized implements IItemHUDProvider, IRadialModeItem<DisassemblerMode>, IHasConditionalAttributes {
 
     //All basic dig actions except shears
-    public static final Set<ToolAction> ALWAYS_SUPPORTED_ACTIONS = Set.of(ToolActions.AXE_DIG, ToolActions.HOE_DIG, ToolActions.SHOVEL_DIG, ToolActions.PICKAXE_DIG,
-          ToolActions.SWORD_DIG);
+    public static final Set<ItemAbility> ALWAYS_SUPPORTED_ACTIONS = Set.of(ItemAbilities.AXE_DIG, ItemAbilities.HOE_DIG, ItemAbilities.SHOVEL_DIG, ItemAbilities.PICKAXE_DIG,
+          ItemAbilities.SWORD_DIG);
     private static final Lazy<RadialData<DisassemblerMode>> LAZY_RADIAL_DATA = Lazy.of(() ->
           IRadialDataHelper.INSTANCE.dataForEnum(Mekanism.rl("disassembler_mode"), DisassemblerMode.NORMAL));
 
@@ -116,7 +116,7 @@ public void appendHoverText(@NotNull ItemStack stack, @NotNull Item.TooltipConte
     }
 
     @Override
-    public boolean canPerformAction(ItemStack stack, ToolAction action) {
+    public boolean canPerformAction(ItemStack stack, ItemAbility action) {
         if (ALWAYS_SUPPORTED_ACTIONS.contains(action)) {
             IEnergyContainer energyContainer = StorageUtils.getEnergyContainer(stack, 0);
             if (energyContainer != null) {

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

@@ -75,8 +75,8 @@
 import net.minecraft.world.level.block.state.BlockState;
 import net.minecraft.world.phys.BlockHitResult;
 import net.minecraft.world.phys.HitResult;
+import net.neoforged.neoforge.common.ItemAbility;
 import net.neoforged.neoforge.common.NeoForge;
-import net.neoforged.neoforge.common.ToolAction;
 import net.neoforged.neoforge.event.ItemAttributeModifierEvent;
 import net.neoforged.neoforge.registries.holdersets.AnyHolderSet;
 import org.jetbrains.annotations.NotNull;
@@ -111,7 +111,7 @@ public void appendHoverText(@NotNull ItemStack stack, @NotNull Item.TooltipConte
     }
 
     @Override
-    public boolean canPerformAction(ItemStack stack, ToolAction action) {
+    public boolean canPerformAction(ItemStack stack, ItemAbility action) {
         if (ItemAtomicDisassembler.ALWAYS_SUPPORTED_ACTIONS.contains(action)) {
             IModuleContainer container = moduleContainer(stack);
             return container != null && hasEnergyForDigAction(container, StorageUtils.getEnergyContainer(stack, 0));
@@ -127,7 +127,7 @@ public boolean canPerformAction(ItemStack stack, ToolAction action) {
         return false;
     }
 
-    private <MODULE extends ICustomModule<MODULE>> boolean canPerformAction(IModule<MODULE> module, IModuleContainer moduleContainer, ItemStack stack, ToolAction action) {
+    private <MODULE extends ICustomModule<MODULE>> boolean canPerformAction(IModule<MODULE> module, IModuleContainer moduleContainer, ItemStack stack, ItemAbility action) {
         return module.getCustomInstance().canPerformAction(module, moduleContainer, stack, action);
     }
 

src/tools/java/mekanism/tools/common/item/ItemMekanismPaxel.java

@@ -32,20 +32,20 @@
 import net.minecraft.world.level.block.LevelEvent;
 import net.minecraft.world.level.block.state.BlockState;
 import net.minecraft.world.level.gameevent.GameEvent;
-import net.neoforged.neoforge.common.ToolAction;
-import net.neoforged.neoforge.common.ToolActions;
+import net.neoforged.neoforge.common.ItemAbilities;
+import net.neoforged.neoforge.common.ItemAbility;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 @ParametersAreNonnullByDefault
 public class ItemMekanismPaxel extends DiggerItem {
 
-    private static final ToolAction PAXEL_DIG = ToolAction.get("paxel_dig");
-    private static final Set<ToolAction> PAXEL_ACTIONS = Util.make(Collections.newSetFromMap(new IdentityHashMap<>()), actions -> {
+    private static final ItemAbility PAXEL_DIG = ItemAbility.get("paxel_dig");
+    private static final Set<ItemAbility> PAXEL_ACTIONS = Util.make(Collections.newSetFromMap(new IdentityHashMap<>()), actions -> {
         actions.add(PAXEL_DIG);
-        actions.addAll(ToolActions.DEFAULT_PICKAXE_ACTIONS);
-        actions.addAll(ToolActions.DEFAULT_SHOVEL_ACTIONS);
-        actions.addAll(ToolActions.DEFAULT_AXE_ACTIONS);
+        actions.addAll(ItemAbilities.DEFAULT_PICKAXE_ACTIONS);
+        actions.addAll(ItemAbilities.DEFAULT_SHOVEL_ACTIONS);
+        actions.addAll(ItemAbilities.DEFAULT_AXE_ACTIONS);
     });
 
     private final IPaxelMaterial material;
@@ -69,7 +69,7 @@ public void appendHoverText(@NotNull ItemStack stack, @NotNull Item.TooltipConte
     }
 
     @Override
-    public boolean canPerformAction(ItemStack stack, ToolAction action) {
+    public boolean canPerformAction(ItemStack stack, ItemAbility action) {
         return PAXEL_ACTIONS.contains(action);
     }
 
@@ -91,7 +91,7 @@ public InteractionResult useOn(UseOnContext context) {
             if (context.getClickedFace() == Direction.DOWN) {
                 return InteractionResult.PASS;
             }
-            BlockState foundResult = blockstate.getToolModifiedState(context, ToolActions.SHOVEL_FLATTEN, false);
+            BlockState foundResult = blockstate.getToolModifiedState(context, ItemAbilities.SHOVEL_FLATTEN, false);
             if (foundResult != null && world.isEmptyBlock(blockpos.above())) {
                 //We can flatten the item as a shovel
                 world.playSound(player, blockpos, SoundEvents.SHOVEL_FLATTEN, SoundSource.BLOCKS, 1.0F, 1.0F);
@@ -127,18 +127,18 @@ private BlockState useAsAxe(BlockState state, UseOnContext context) {
         Level world = context.getLevel();
         BlockPos pos = context.getClickedPos();
         Player player = context.getPlayer();
-        BlockState resultToSet = state.getToolModifiedState(context, ToolActions.AXE_STRIP, false);
+        BlockState resultToSet = state.getToolModifiedState(context, ItemAbilities.AXE_STRIP, false);
         if (resultToSet != null) {
             world.playSound(player, pos, SoundEvents.AXE_STRIP, SoundSource.BLOCKS, 1.0F, 1.0F);
             return resultToSet;
         }
-        resultToSet = state.getToolModifiedState(context, ToolActions.AXE_SCRAPE, false);
+        resultToSet = state.getToolModifiedState(context, ItemAbilities.AXE_SCRAPE, false);
         if (resultToSet != null) {
             world.playSound(player, pos, SoundEvents.AXE_SCRAPE, SoundSource.BLOCKS, 1.0F, 1.0F);
             world.levelEvent(player, LevelEvent.PARTICLES_SCRAPE, pos, 0);
             return resultToSet;
         }
-        resultToSet = state.getToolModifiedState(context, ToolActions.AXE_WAX_OFF, false);
+        resultToSet = state.getToolModifiedState(context, ItemAbilities.AXE_WAX_OFF, false);
         if (resultToSet != null) {
             world.playSound(player, pos, SoundEvents.AXE_WAX_OFF, SoundSource.BLOCKS, 1.0F, 1.0F);
             world.levelEvent(player, LevelEvent.PARTICLES_WAX_OFF, pos, 0);