迁移方块

src/main/java/dev/dubhe/anvilcraft/block/AbstractCakeBlock.java

@@ -1,8 +1,12 @@
 package dev.dubhe.anvilcraft.block;
 
+import dev.dubhe.anvilcraft.util.Utils;
+import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.ServerLevel;
 import net.minecraft.world.InteractionHand;
 import net.minecraft.world.InteractionResult;
+import net.minecraft.world.ItemInteractionResult;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.ShovelItem;
@@ -13,56 +17,78 @@
 import net.minecraft.world.level.gameevent.GameEvent;
 import net.minecraft.world.level.material.PushReaction;
 import net.minecraft.world.phys.BlockHitResult;
-import org.jetbrains.annotations.NotNull;
 
+import javax.annotation.ParametersAreNonnullByDefault;
+import java.util.function.Function;
+
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
 public class AbstractCakeBlock extends Block {
     public AbstractCakeBlock(Properties properties) {
         super(properties.pushReaction(PushReaction.NORMAL));
     }
 
-    @SuppressWarnings("deprecation")
     @Override
-    public @NotNull InteractionResult use(
-        @NotNull BlockState state,
-        @NotNull Level level,
-        @NotNull BlockPos pos,
-        @NotNull Player player,
-        @NotNull InteractionHand hand,
-        @NotNull BlockHitResult hit
+    protected InteractionResult useWithoutItem(
+        BlockState pState,
+        Level pLevel,
+        BlockPos pPos,
+        Player pPlayer,
+        BlockHitResult pHitResult
     ) {
-        ItemStack itemStack = player.getItemInHand(hand);
-        if (!(itemStack.getItem() instanceof ShovelItem)) return InteractionResult.PASS;
-        if (level.isClientSide) {
-            if (eat(level, pos, player, getFoodLevel(), getSaturationLevel()).consumesAction()) {
+        if (pLevel.isClientSide) {
+            if (eat(pLevel, pPos, pPlayer, getFoodLevel(), getSaturationLevel(), it -> it).consumesAction()) {
                 return InteractionResult.SUCCESS;
             }
+            return InteractionResult.CONSUME;
+        }
+        return eat(pLevel, pPos, pPlayer, getFoodLevel(), getSaturationLevel(), it -> it);
+    }
+
+    @Override
+    protected ItemInteractionResult useItemOn(
+        ItemStack pStack,
+        BlockState pState,
+        Level pLevel,
+        BlockPos pPos,
+        Player pPlayer,
+        InteractionHand pHand,
+        BlockHitResult pHitResult
+    ) {
+        ItemStack itemStack = pPlayer.getItemInHand(pHand);
+        if (!(itemStack.getItem() instanceof ShovelItem))
+            return ItemInteractionResult.PASS_TO_DEFAULT_BLOCK_INTERACTION;
+        if (pLevel.isClientSide) {
+            if (eat(pLevel, pPos, pPlayer, getFoodLevel(), getSaturationLevel(),Utils.interactionResultConverter()).consumesAction()) {
+                return ItemInteractionResult.SUCCESS;
+            }
 
             if (itemStack.isEmpty()) {
-                return InteractionResult.CONSUME;
+                return ItemInteractionResult.CONSUME;
             }
         } else {
-            itemStack.hurtAndBreak(1, player, (p) -> {
-                p.broadcastBreakEvent(hand);
+            itemStack.hurtAndBreak(1, (ServerLevel) pLevel, pPlayer, p -> {
+
             });
         }
-
-        return eat(level, pos, player, getFoodLevel(), getSaturationLevel());
+        return eat(pLevel, pPos, pPlayer, getFoodLevel(), getSaturationLevel(), Utils.interactionResultConverter());
     }
 
-    private static InteractionResult eat(
+    private static <T> T eat(
         LevelAccessor level,
         BlockPos pos,
         Player player,
         int foodLevel,
-        float saturationLevel
+        float saturationLevel,
+        Function<InteractionResult, T> converter
     ) {
         if (!player.canEat(false)) {
-            return InteractionResult.PASS;
+            return converter.apply(InteractionResult.PASS);
         } else {
             player.getFoodData().eat(foodLevel, saturationLevel);
             level.removeBlock(pos, false);
             level.gameEvent(player, GameEvent.BLOCK_DESTROY, pos);
-            return InteractionResult.SUCCESS;
+            return converter.apply(InteractionResult.SUCCESS);
         }
     }
 

src/main/java/dev/dubhe/anvilcraft/block/AbstractMultiplePartBlock.java

@@ -1,10 +1,15 @@
 package dev.dubhe.anvilcraft.block;
 
 import dev.dubhe.anvilcraft.block.state.MultiplePartBlockState;
+import dev.dubhe.anvilcraft.util.Utils;
+import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
 import net.minecraft.core.Vec3i;
 import net.minecraft.data.loot.BlockLootSubProvider;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.ItemInteractionResult;
 import net.minecraft.world.entity.LivingEntity;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.ItemStack;
@@ -17,9 +22,14 @@
 import net.minecraft.world.level.block.state.BlockState;
 import net.minecraft.world.level.block.state.properties.Property;
 import net.minecraft.world.level.material.Fluids;
+import net.minecraft.world.phys.BlockHitResult;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import javax.annotation.ParametersAreNonnullByDefault;
+
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
 public abstract class AbstractMultiplePartBlock<P extends Enum<P> & MultiplePartBlockState<P>> extends Block {
     public AbstractMultiplePartBlock(Properties properties) {
         super(properties);
@@ -76,13 +86,13 @@ protected BlockState placedState(P part, @NotNull BlockState state) {
     }
 
     @Override
-    public void playerWillDestroy(
+    public @NotNull BlockState playerWillDestroy(
         @NotNull Level level, @NotNull BlockPos pos, @NotNull BlockState state, @NotNull Player player
     ) {
         if (!level.isClientSide && player.isCreative()) {
             this.preventCreativeDropFromMainPart(level, pos, state, player);
         }
-        super.playerWillDestroy(level, pos, state, player);
+        return super.playerWillDestroy(level, pos, state, player);
     }
 
     private void preventCreativeDropFromMainPart(
@@ -114,7 +124,15 @@ public static <T extends Enum<T> & MultiplePartBlockState<T>> void loot(
     ) {
         for (T part : block.getParts()) {
             if (part.getOffset().distSqr(block.getMainPartOffset()) == 0) {
-                provider.add(block, provider.createSinglePropConditionTable(block, block.getPart(), part));
+
+                provider.add(
+                    block,
+                    provider.createSinglePropConditionTable(
+                        block,
+                        block.getPart(),
+                        part
+                    )
+                );
                 break;
             }
         }
@@ -146,4 +164,53 @@ public boolean hasEnoughSpace(BlockPos pos, LevelReader level) {
         }
         return true;
     }
+
+    @Override
+    protected ItemInteractionResult useItemOn(
+        ItemStack pStack,
+        BlockState pState,
+        Level pLevel,
+        BlockPos pPos,
+        Player pPlayer,
+        InteractionHand pHand,
+        BlockHitResult pHitResult
+    ) {
+        return Utils.interactionResultConverter().apply(this.use(
+            pState,
+            pLevel,
+            pPos,
+            pPlayer,
+            pHand,
+            pHitResult
+        ));
+    }
+
+    @Override
+    protected InteractionResult useWithoutItem(
+        BlockState pState,
+        Level pLevel,
+        BlockPos pPos,
+        Player pPlayer,
+        BlockHitResult pHitResult
+    ) {
+        return this.use(
+            pState,
+            pLevel,
+            pPos,
+            pPlayer,
+            InteractionHand.MAIN_HAND,
+            pHitResult
+        );
+    }
+
+    public InteractionResult use(
+        BlockState state,
+        Level level,
+        BlockPos pos,
+        Player player,
+        InteractionHand hand,
+        BlockHitResult hit
+    ) {
+        return InteractionResult.PASS;
+    }
 }

src/main/java/dev/dubhe/anvilcraft/block/ActiveSilencerBlock.java

@@ -1,16 +1,21 @@
 package dev.dubhe.anvilcraft.block;
 
+import com.mojang.serialization.MapCodec;
 import dev.dubhe.anvilcraft.api.hammer.IHammerRemovable;
 import dev.dubhe.anvilcraft.block.entity.ActiveSilencerBlockEntity;
 import dev.dubhe.anvilcraft.init.ModBlockEntities;
 import dev.dubhe.anvilcraft.init.ModItems;
 import dev.dubhe.anvilcraft.init.ModMenuTypes;
 import dev.dubhe.anvilcraft.network.MutedSoundSyncPacket;
+import dev.dubhe.anvilcraft.util.Utils;
+import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.core.BlockPos;
 import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.world.InteractionHand;
 import net.minecraft.world.InteractionResult;
+import net.minecraft.world.ItemInteractionResult;
 import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.level.Level;
 import net.minecraft.world.level.block.BaseEntityBlock;
 import net.minecraft.world.level.block.RenderShape;
@@ -21,49 +26,71 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import javax.annotation.ParametersAreNonnullByDefault;
 import java.util.ArrayList;
 
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
 public class ActiveSilencerBlock extends BaseEntityBlock implements IHammerRemovable {
     public ActiveSilencerBlock(Properties properties) {
         super(properties);
     }
 
+    @Override
+    protected @NotNull MapCodec<? extends BaseEntityBlock> codec() {
+        return simpleCodec(ActiveSilencerBlock::new);
+    }
+
     @Nullable
     @Override
     public BlockEntity newBlockEntity(@NotNull BlockPos pos, @NotNull BlockState state) {
         return new ActiveSilencerBlockEntity(ModBlockEntities.ACTIVE_SILENCER.get(), pos, state);
     }
 
     @Override
-    @SuppressWarnings({"deprecation", "UnreachableCode"})
-    public @NotNull InteractionResult use(
-            @NotNull BlockState state,
-            @NotNull Level level,
-            @NotNull BlockPos pos,
-            @NotNull Player player,
-            @NotNull InteractionHand hand,
-            @NotNull BlockHitResult hit
+    protected ItemInteractionResult useItemOn(
+        ItemStack pStack,
+        BlockState pState,
+        Level pLevel,
+        BlockPos pPos,
+        Player pPlayer,
+        InteractionHand pHand,
+        BlockHitResult pHitResult
     ) {
-        if (level.isClientSide) {
+        if (pLevel.isClientSide)return ItemInteractionResult.SUCCESS;
+        if (pPlayer instanceof ServerPlayer serverPlayer){
+            BlockEntity be = pLevel.getBlockEntity(pPos);
+            if (be instanceof ActiveSilencerBlockEntity asbe && pPlayer.getItemInHand(pHand).is(ModItems.DISK.get())){
+                return Utils.interactionResultConverter().apply(asbe.useDisk(
+                    pLevel,
+                    serverPlayer,
+                    pHand,
+                    serverPlayer.getItemInHand(pHand),
+                    pHitResult
+                ));
+            }
+        }
+        return super.useItemOn(pStack, pState, pLevel, pPos, pPlayer, pHand, pHitResult);
+    }
+
+    @Override
+    protected InteractionResult useWithoutItem(
+        BlockState pState,
+        Level pLevel,
+        BlockPos pPos,
+        Player pPlayer,
+        BlockHitResult pHitResult
+    ) {
+        if (pLevel.isClientSide) {
             return InteractionResult.SUCCESS;
         }
-        BlockEntity blockEntity = level.getBlockEntity(pos);
-        if (blockEntity instanceof ActiveSilencerBlockEntity eb) {
-            if (player instanceof ServerPlayer serverPlayer) {
-                if (player.getItemInHand(hand).is(ModItems.DISK.get())) {
-                    return eb.useDisk(
-                            level,
-                            player,
-                            hand,
-                            player.getItemInHand(hand),
-                            hit
-                    );
-                }
-                ModMenuTypes.open(serverPlayer, eb, pos);
-                PacketDistributor.sendToPlayer(serverPlayer, new MutedSoundSyncPacket(new ArrayList<>(eb.getMutedSound())));
-            }
+        BlockEntity be = pLevel.getBlockEntity(pPos);
+        if (be instanceof ActiveSilencerBlockEntity asbe && pPlayer instanceof ServerPlayer sp){
+            ModMenuTypes.open(sp, asbe, pPos);
+            PacketDistributor.sendToPlayer(sp, new MutedSoundSyncPacket(new ArrayList<>(asbe.getMutedSound())));
+            return InteractionResult.SUCCESS;
         }
-        return InteractionResult.SUCCESS;
+        return InteractionResult.FAIL;
     }
 
     @Override

src/main/java/dev/dubhe/anvilcraft/block/ArrowBlock.java

@@ -1,5 +1,6 @@
 package dev.dubhe.anvilcraft.block;
 
+import com.mojang.serialization.MapCodec;
 import dev.dubhe.anvilcraft.api.hammer.IHammerRemovable;
 import net.minecraft.core.Direction;
 import net.minecraft.world.item.context.BlockPlaceContext;
@@ -17,6 +18,11 @@ public ArrowBlock(Properties properties) {
         registerDefaultState(getStateDefinition().any().setValue(FACING, Direction.NORTH));
     }
 
+    @Override
+    protected MapCodec<? extends DirectionalBlock> codec() {
+        return null;
+    }
+
     @Override
     protected void createBlockStateDefinition(StateDefinition.@NotNull Builder<Block, BlockState> builder) {
         super.createBlockStateDefinition(builder);