energy items done

src/main/java/com/leclowndu93150/carbort/Carbort.java

@@ -37,6 +37,7 @@ public Carbort(IEventBus modEventBus, ModContainer modContainer) {
         CBItems.ITEMS.register(modEventBus);
         CBBlocks.BLOCKS.register(modEventBus);
         CBBlockEntities.REGISTER.register(modEventBus);
+        CBEntityTypes.ENTITY_TYPES.register(modEventBus);
         CBMobEffects.EFFECTS.register(modEventBus);
         CBMobEffects.POTIONS.register(modEventBus);
         CBDataComponents.DATA_COMPONENTS.register(modEventBus);

src/main/java/com/leclowndu93150/carbort/CarbortClient.java

@@ -5,9 +5,12 @@
 import com.leclowndu93150.carbort.content.screen.ChunkAnalyzerScreen;
 import com.leclowndu93150.carbort.registries.CBBlockEntities;
 import com.leclowndu93150.carbort.data.CBDataComponents;
+import com.leclowndu93150.carbort.registries.CBEntityTypes;
 import com.leclowndu93150.carbort.registries.CBItems;
 import com.leclowndu93150.carbort.registries.CBMenus;
 import net.minecraft.client.model.HumanoidModel;
+import net.minecraft.client.renderer.entity.EntityRenderers;
+import net.minecraft.client.renderer.entity.ThrownItemRenderer;
 import net.minecraft.client.resources.model.ModelResourceLocation;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.util.FastColor;
@@ -17,6 +20,7 @@
 import net.neoforged.api.distmarker.Dist;
 import net.neoforged.bus.api.IEventBus;
 import net.neoforged.fml.common.Mod;
+import net.neoforged.fml.event.lifecycle.FMLClientSetupEvent;
 import net.neoforged.neoforge.client.event.EntityRenderersEvent;
 import net.neoforged.neoforge.client.event.ModelEvent;
 import net.neoforged.neoforge.client.event.RegisterColorHandlersEvent;
@@ -36,12 +40,17 @@ public CarbortClient(IEventBus modEventBus) {
         modEventBus.addListener(this::registerColorHandlers);
         modEventBus.addListener(this::registerClientExtensions);
         modEventBus.addListener(this::registerModels);
+        modEventBus.addListener(this::onClientSetup);
     }
 
     private void registerBERs(EntityRenderersEvent.RegisterRenderers event) {
         event.registerBlockEntityRenderer(CBBlockEntities.BEDROCK_DRILL.get(), BedrockDrillBER::new);
     }
 
+    private void onClientSetup(FMLClientSetupEvent event) {
+        event.enqueueWork(() -> EntityRenderers.register(CBEntityTypes.DYNAMITE.get(), pContext -> new ThrownItemRenderer<>(pContext, 2, false)));
+    }
+
     private void registerMenuScreens(RegisterMenuScreensEvent event) {
         event.register(CBMenus.CHUNK_ANALYZER_MENU.get(), ChunkAnalyzerScreen::new);
     }
@@ -70,7 +79,7 @@ private void registerClientExtensions(RegisterClientExtensionsEvent event) {
             public HumanoidModel.@NotNull ArmPose getArmPose(LivingEntity entityLiving, InteractionHand hand, ItemStack itemStack) {
                 return HumanoidModel.ArmPose.CROSSBOW_CHARGE;
             }
-        }, CBItems.IRON_GREAT_SWORD);
+        }, CBItems.BEDROCKIUM_BLADE);
     }
 
     private void registerBakedModels(ModelEvent.RegisterAdditional event) {

src/main/java/com/leclowndu93150/carbort/CarbortConfig.java

@@ -20,6 +20,10 @@
 public final class CarbortConfig {
     private static final Map<ResourceLocation, Pair<ModConfigSpec.IntValue, ModConfigSpec.IntValue>> ITEM_ENERGY_CONFIGS = new HashMap<>();
     private static final Map<Item, IntIntPair> ITEM_ENERGY_VALUES = new HashMap<>();
+
+    private static final Map<ResourceLocation, Pair<ModConfigSpec.IntValue, ModConfigSpec.IntValue>> ITEM_FLUID_CONFIGS = new HashMap<>();
+    private static final Map<Item, IntIntPair> ITEM_FLUID_VALUES = new HashMap<>();
+
     private static final ModConfigSpec.Builder BUILDER = new ModConfigSpec.Builder();
 
     public static ModConfigSpec SPEC;
@@ -30,6 +34,10 @@ public static void onLoad(final ModConfigEvent event) {
             Pair<ModConfigSpec.IntValue, ModConfigSpec.IntValue> value = config.getValue();
             ITEM_ENERGY_VALUES.put(BuiltInRegistries.ITEM.get(config.getKey()), IntIntPair.of(value.first().getAsInt(), value.second().getAsInt()));
         }
+        for (Map.Entry<ResourceLocation, Pair<ModConfigSpec.IntValue, ModConfigSpec.IntValue>> config : ITEM_FLUID_CONFIGS.entrySet()) {
+            Pair<ModConfigSpec.IntValue, ModConfigSpec.IntValue> value = config.getValue();
+            ITEM_FLUID_VALUES.put(BuiltInRegistries.ITEM.get(config.getKey()), IntIntPair.of(value.first().getAsInt(), value.second().getAsInt()));
+        }
     }
 
     public static int itemEnergyUsage(ItemLike itemLike) {
@@ -40,19 +48,38 @@ public static int itemEnergyCapacity(ItemLike itemLike) {
         return ITEM_ENERGY_VALUES.get(itemLike.asItem()).secondInt();
     }
 
+    public static int itemFluidUsage(ItemLike itemLike) {
+        return ITEM_FLUID_VALUES.get(itemLike.asItem()).firstInt();
+    }
+
+    public static int itemFluidCapacity(ItemLike itemLike) {
+        return ITEM_FLUID_VALUES.get(itemLike.asItem()).secondInt();
+    }
+
     private static void itemEnergyConfigs(String name, ResourceLocation itemLoc, int usageAmount, int energyCapacity) {
-        ModConfigSpec.IntValue energyUsage = BUILDER.comment("Configure how much energy the " + name + " uses.")
-                .defineInRange(name + "_energy_usage", usageAmount, 0, Integer.MAX_VALUE);
+        ModConfigSpec.IntValue energyUsage = BUILDER.comment("Configure how much energy the " + itemLoc.getPath() + " uses.")
+                .defineInRange(itemLoc.getPath() + "_energy_usage", usageAmount, 0, Integer.MAX_VALUE);
         ModConfigSpec.IntValue energyMax = BUILDER.comment("Configure the maximum amount of energy the " + name + " can hold. Setting this to 0 will disable energy on the " + name)
-                .defineInRange(name + "_max_energy", energyCapacity, 0, Integer.MAX_VALUE);
+                .defineInRange(itemLoc.getPath() + "_max_energy", energyCapacity, 0, Integer.MAX_VALUE);
         ITEM_ENERGY_CONFIGS.put(itemLoc, Pair.of(energyUsage, energyMax));
     }
 
+    private static void itemFluidConfigs(String name, ResourceLocation itemLoc, int usageAmount, int fluidCapacity) {
+        ModConfigSpec.IntValue fluidUsage = BUILDER.comment("Configure how much Fluid the " + name + " uses.")
+                .defineInRange(itemLoc.getPath() + "_energy_usage", usageAmount, 0, Integer.MAX_VALUE);
+        ModConfigSpec.IntValue fluidMax = BUILDER.comment("Configure the maximum amount of Fluid the " + name + " can hold. Setting this to 0 will disable Fluid on the " + name)
+                .defineInRange(itemLoc.getPath() + "_max_energy", fluidCapacity, 0, Integer.MAX_VALUE);
+        ITEM_FLUID_CONFIGS.put(itemLoc, Pair.of(fluidUsage, fluidMax));
+    }
+
     static {
         itemEnergyConfigs("Chunk Analyzer", Carbort.rl("chunk_analyzer"), 250, 10_000);
         itemEnergyConfigs("Shrinkinator", Carbort.rl("shrinkinator"), 250, 10_000);
         itemEnergyConfigs("Chunk Vacuum", Carbort.rl("chunk_vacuum"), 25_000, 500_000);
 
+        itemFluidConfigs("Funeral Pickaxe", Carbort.rl("funeral_pickaxe"), 25, 10_000);
+        itemFluidConfigs("Bedrockium Blade", Carbort.rl("bedrockium_blade"), 25, 10_000);
+
         SPEC = BUILDER.build();
     }
 }

src/main/java/com/leclowndu93150/carbort/api/items/SimpleEnergyItem.java

@@ -1,11 +1,17 @@
 package com.leclowndu93150.carbort.api.items;
 
 import com.leclowndu93150.carbort.utils.CapabilityUtils;
+import net.minecraft.ChatFormatting;
+import net.minecraft.network.chat.Component;
 import net.minecraft.util.FastColor;
+import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.Item;
 import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.TooltipFlag;
 import net.neoforged.neoforge.energy.IEnergyStorage;
 
+import java.util.List;
+
 public abstract class SimpleEnergyItem extends Item implements IEnergyItem {
     public SimpleEnergyItem(Properties properties) {
         super(properties);
@@ -29,5 +35,25 @@ public int getBarColor(ItemStack stack) {
         return FastColor.ARGB32.color(235, 7, 7);
     }
 
-    // TODO: Fancy tooltip
+    @Override
+    public void appendHoverText(ItemStack stack, TooltipContext context, List<Component> tooltipComponents, TooltipFlag tooltipFlag) {
+        IEnergyStorage energyStorage = CapabilityUtils.itemEnergyStorage(stack);
+        tooltipComponents.add(Component.literal("Stored: ")
+                .append(energyStorage.getEnergyStored() + "/" + energyStorage.getMaxEnergyStored())
+                        .withStyle(ChatFormatting.GRAY));
+        tooltipComponents.add(Component.literal("Usage: ")
+                .append(String.valueOf(getEnergyUsage()))
+                .withStyle(ChatFormatting.GRAY));
+        super.appendHoverText(stack, context, tooltipComponents, tooltipFlag);
+    }
+
+    public boolean useEnergy(Player player, ItemStack itemStack) {
+        IEnergyStorage energyStorage = CapabilityUtils.itemEnergyStorage(itemStack);
+        if (player.hasInfiniteMaterials() || energyStorage.extractEnergy(getEnergyUsage(), true) == getEnergyUsage()) {
+            energyStorage.extractEnergy(getEnergyUsage(), false);
+            return true;
+        }
+        return false;
+    }
+
 }

src/main/java/com/leclowndu93150/carbort/content/entities/DynamiteEntity.java

@@ -0,0 +1,61 @@
+package com.leclowndu93150.carbort.content.entities;
+
+import com.leclowndu93150.carbort.registries.CBEntityTypes;
+import com.leclowndu93150.carbort.registries.CBItems;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.projectile.Snowball;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.level.Explosion;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.phys.BlockHitResult;
+import net.minecraft.world.phys.EntityHitResult;
+import net.minecraft.world.phys.Vec3;
+import org.jetbrains.annotations.NotNull;
+
+public class DynamiteEntity extends Snowball {
+    public DynamiteEntity(EntityType<? extends Snowball> entityType, Level level) {
+        super(entityType, level);
+    }
+
+    public DynamiteEntity(Level level, LivingEntity livingEntity) {
+        super(level, livingEntity);
+    }
+
+    @Override
+    protected @NotNull Item getDefaultItem() {
+        return CBItems.DYNAMITE.asItem();
+    }
+
+    @Override
+    protected void onHitBlock(BlockHitResult result) {
+        this.level().explode(
+                this,
+                Explosion.getDefaultDamageSource(this.level(), this),
+                null,
+                this.getX(),
+                this.getY(0.0625),
+                this.getZ(),
+                3.0F,
+                false,
+                Level.ExplosionInteraction.TNT
+        );
+    }
+
+    @Override
+    protected void onHitEntity(EntityHitResult result) {
+        super.onHitEntity(result);
+        this.level().explode(
+                        this,
+                        Explosion.getDefaultDamageSource(this.level(), this),
+                        null,
+                        this.getX(),
+                        this.getY(0.0625),
+                        this.getZ(),
+                        4.0F,
+                        false,
+                        Level.ExplosionInteraction.TNT
+                );
+    }
+}

src/main/java/com/leclowndu93150/carbort/content/items/BedrockiumBladeItem.java

@@ -0,0 +1,66 @@
+package com.leclowndu93150.carbort.content.items;
+
+import com.leclowndu93150.carbort.CarbortConfig;
+import com.leclowndu93150.carbort.api.items.IFluidItem;
+import com.leclowndu93150.carbort.data.CBDataComponents;
+import com.leclowndu93150.carbort.utils.CapabilityUtils;
+import net.minecraft.sounds.SoundEvents;
+import net.minecraft.util.FastColor;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.InteractionResultHolder;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.SwordItem;
+import net.minecraft.world.level.Level;
+import net.neoforged.neoforge.common.Tags;
+import net.neoforged.neoforge.fluids.FluidStack;
+import net.neoforged.neoforge.fluids.capability.IFluidHandler;
+
+public class BedrockiumBladeItem extends SwordItem implements IFluidItem {
+    public BedrockiumBladeItem(Properties properties) {
+        super(ToolTiers.BEDROCKIUM, properties);
+    }
+
+    @Override
+    public int getCapacity() {
+        return CarbortConfig.itemFluidCapacity(this);
+    }
+
+    @Override
+    public boolean isBarVisible(ItemStack stack) {
+        return true;
+    }
+
+    @Override
+    public int getBarColor(ItemStack stack) {
+        return FastColor.ARGB32.color(82, 82, 82);
+    }
+
+    @Override
+    public int getBarWidth(ItemStack stack) {
+        IFluidHandler energyStorage = CapabilityUtils.itemFluidHandler(stack);
+        return Math.round(13.0F - ((1 - ((float) energyStorage.getFluidInTank(0).getAmount() / energyStorage.getTankCapacity(0))) * 13.0F));
+    }
+
+    @Override
+    public boolean isFluidValid(int tank, FluidStack stack) {
+        // TODO: Void fluid
+        return stack.is(Tags.Fluids.LAVA);
+    }
+
+    @Override
+    public InteractionResultHolder<ItemStack> use(Level level, Player player, InteractionHand usedHand) {
+        if (player.isShiftKeyDown()) {
+            ItemStack itemInHand = player.getItemInHand(usedHand);
+            itemInHand.set(CBDataComponents.ACTIVE, !itemInHand.getOrDefault(CBDataComponents.ACTIVE, false));
+            player.playSound(SoundEvents.EXPERIENCE_ORB_PICKUP);
+            return InteractionResultHolder.success(itemInHand);
+        }
+        return super.use(level, player, usedHand);
+    }
+
+    @Override
+    public boolean isFoil(ItemStack stack) {
+        return super.isFoil(stack) || stack.getOrDefault(CBDataComponents.ACTIVE, false);
+    }
+}

src/main/java/com/leclowndu93150/carbort/content/items/ChunkVacuumItem.java

@@ -60,27 +60,21 @@ public int getUseDuration(ItemStack stack, LivingEntity entity) {
     @Override
     public ItemStack finishUsingItem(ItemStack stack, Level level, LivingEntity livingEntity) {
         if (level instanceof ServerLevel serverLevel && livingEntity instanceof ServerPlayer serverPlayer) {
-            IEnergyStorage energyStorage = serverPlayer.getMainHandItem().getCapability(Capabilities.EnergyStorage.ITEM);
-
             BlockPos pos = getPlayerPOVHitResult(level, serverPlayer, ClipContext.Fluid.NONE).getBlockPos();
-            if (pos.getY() < level.getMinBuildHeight()
-                    && level.getBlockState(pos).is(Blocks.VOID_AIR)
-                    && level.dimensionTypeRegistration().is(BuiltinDimensionTypes.OVERWORLD)) {
-                ItemStack offhandItem = serverPlayer.getOffhandItem();
-                IFluidHandler fluidHandler = offhandItem.getCapability(Capabilities.FluidHandler.ITEM);
-                level.playSound(null, pos, SoundEvents.WITHER_HURT, SoundSource.BLOCKS);
-                if (fluidHandler != null) {
-                    fluidHandler.fill(new FluidStack(Fluids.LAVA, 50), IFluidHandler.FluidAction.EXECUTE);
-                    serverPlayer.startUsingItem(InteractionHand.MAIN_HAND);
-                }
-                if (!serverPlayer.hasInfiniteMaterials()) {
-                    energyStorage.extractEnergy(getEnergyUsage() / 10, false);
-                }
-            } else {
-                ChunkVacuumHelper helper = new ChunkVacuumHelper(serverLevel, serverPlayer, pos);
-                serverLevel.getServer().doRunTask(new TickTask(0, helper::removeArea));
-                if (!serverPlayer.hasInfiniteMaterials()) {
-                    energyStorage.extractEnergy(getEnergyUsage(), false);
+            if (useEnergy(serverPlayer, stack)) {
+                if (pos.getY() < level.getMinBuildHeight()
+                        && level.getBlockState(pos).is(Blocks.VOID_AIR)
+                        && level.dimensionTypeRegistration().is(BuiltinDimensionTypes.OVERWORLD)) {
+                    ItemStack offhandItem = serverPlayer.getOffhandItem();
+                    IFluidHandler fluidHandler = offhandItem.getCapability(Capabilities.FluidHandler.ITEM);
+                    level.playSound(null, pos, SoundEvents.WITHER_HURT, SoundSource.BLOCKS);
+                    if (fluidHandler != null) {
+                        fluidHandler.fill(new FluidStack(Fluids.LAVA, 50), IFluidHandler.FluidAction.EXECUTE);
+                        serverPlayer.startUsingItem(InteractionHand.MAIN_HAND);
+                    }
+                } else {
+                    ChunkVacuumHelper helper = new ChunkVacuumHelper(serverLevel, serverPlayer, pos);
+                    serverLevel.getServer().doRunTask(new TickTask(0, helper::removeArea));
                 }
             }
         }

src/main/java/com/leclowndu93150/carbort/content/items/DynamiteItem.java

@@ -0,0 +1,43 @@
+package com.leclowndu93150.carbort.content.items;
+
+import com.leclowndu93150.carbort.content.entities.DynamiteEntity;
+import net.minecraft.sounds.SoundEvents;
+import net.minecraft.sounds.SoundSource;
+import net.minecraft.stats.Stats;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.InteractionResultHolder;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.Level;
+
+public class DynamiteItem extends Item {
+    public DynamiteItem(Properties properties) {
+        super(properties);
+    }
+
+    @Override
+    public InteractionResultHolder<ItemStack> use(Level level, Player player, InteractionHand usedHand) {
+        ItemStack itemstack = player.getItemInHand(usedHand);
+        level.playSound(
+                null,
+                player.getX(),
+                player.getY(),
+                player.getZ(),
+                SoundEvents.SNOWBALL_THROW,
+                SoundSource.NEUTRAL,
+                0.5F,
+                0.4F / (level.getRandom().nextFloat() * 0.4F + 0.8F)
+        );
+        if (!level.isClientSide) {
+            DynamiteEntity dynamite = new DynamiteEntity(level, player);
+            dynamite.setItem(itemstack);
+            dynamite.shootFromRotation(player, player.getXRot(), player.getYRot(), 0.0F, 0.5F, 1.0F);
+            level.addFreshEntity(dynamite);
+        }
+
+        player.awardStat(Stats.ITEM_USED.get(this));
+        itemstack.consume(1, player);
+        return InteractionResultHolder.sidedSuccess(itemstack, level.isClientSide());
+    }
+}

src/main/java/com/leclowndu93150/carbort/content/items/FuneralPickaxeItem.java

@@ -1,12 +1,17 @@
 package com.leclowndu93150.carbort.content.items;
 
+import com.leclowndu93150.carbort.CarbortConfig;
 import com.leclowndu93150.carbort.api.items.IFluidItem;
-import com.leclowndu93150.carbort.api.items.ScrollableItem;
+import com.leclowndu93150.carbort.data.CBDataComponents;
 import com.leclowndu93150.carbort.utils.CapabilityUtils;
+import net.minecraft.sounds.SoundEvents;
 import net.minecraft.util.FastColor;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.InteractionResultHolder;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.PickaxeItem;
+import net.minecraft.world.level.Level;
 import net.neoforged.neoforge.common.Tags;
 import net.neoforged.neoforge.fluids.FluidStack;
 import net.neoforged.neoforge.fluids.capability.IFluidHandler;
@@ -18,7 +23,7 @@ public FuneralPickaxeItem(Properties properties) {
 
     @Override
     public int getCapacity() {
-        return 100;
+        return CarbortConfig.itemFluidCapacity(this);
     }
 
     @Override
@@ -42,4 +47,20 @@ public boolean isFluidValid(int tank, FluidStack stack) {
         // TODO: VOid fluid
         return stack.is(Tags.Fluids.LAVA);
     }
+
+    @Override
+    public InteractionResultHolder<ItemStack> use(Level level, Player player, InteractionHand usedHand) {
+        if (player.isShiftKeyDown()) {
+            ItemStack itemInHand = player.getItemInHand(usedHand);
+            itemInHand.set(CBDataComponents.ACTIVE, !itemInHand.getOrDefault(CBDataComponents.ACTIVE, false));
+            player.playSound(SoundEvents.EXPERIENCE_ORB_PICKUP);
+            return InteractionResultHolder.success(itemInHand);
+        }
+        return super.use(level, player, usedHand);
+    }
+
+    @Override
+    public boolean isFoil(ItemStack stack) {
+        return super.isFoil(stack) || stack.getOrDefault(CBDataComponents.ACTIVE, false);
+    }
 }

src/main/java/com/leclowndu93150/carbort/content/items/ShrinkinatorItem.java

@@ -7,6 +7,7 @@
 import com.leclowndu93150.carbort.data.CBDataComponents;
 import com.leclowndu93150.carbort.networking.ShrinkSyncPayload;
 import com.leclowndu93150.carbort.networking.ShrinkinatorSizeSyncPayload;
+import net.minecraft.ChatFormatting;
 import net.minecraft.network.chat.Component;
 import net.minecraft.server.level.ServerLevel;
 import net.minecraft.world.InteractionHand;
@@ -37,10 +38,13 @@ public int getCapacity() {
     @Override
     public InteractionResultHolder<ItemStack> use(Level level, Player player, InteractionHand usedHand) {
         ItemStack itemStack = player.getItemInHand(usedHand);
-        float data = itemStack.getOrDefault(CBDataComponents.SIZE, 1f);
-        player.setData(CBAttachmentTypes.SIZE, data);
-        player.refreshDimensions();
-        PacketDistributor.sendToAllPlayers(new ShrinkSyncPayload(data));
+        if (useEnergy(player, itemStack)) {
+            int size = itemStack.getOrDefault(CBDataComponents.SIZE, 10);
+            player.setData(CBAttachmentTypes.SIZE, size / 10f);
+            player.refreshDimensions();
+            PacketDistributor.sendToAllPlayers(new ShrinkSyncPayload(size / 10f));
+            return InteractionResultHolder.success(itemStack);
+        }
         return super.use(level, player, usedHand);
     }
 
@@ -50,22 +54,24 @@ public void onScroll(ItemStack itemStack, Player player, InteractionHand usedHan
             boolean up = scrollDeltaY == 1;
             boolean down = scrollDeltaY == -1;
 
-            float data = itemStack.getOrDefault(CBDataComponents.SIZE, 1f);
-            if (up && data < 10) {
-                itemStack.set(CBDataComponents.SIZE, data + 0.1f);
-            } else if (down && data > 0) {
-                itemStack.set(CBDataComponents.SIZE, data - 0.1f);
+            int data = itemStack.getOrDefault(CBDataComponents.SIZE, 10);
+            if (up && data < 100) {
+                itemStack.set(CBDataComponents.SIZE, data + 1);
+            } else if (down && data > 1) {
+                itemStack.set(CBDataComponents.SIZE, data - 1);
             }
 
-            float size = itemStack.getOrDefault(CBDataComponents.SIZE, 1f);
+            int size = itemStack.getOrDefault(CBDataComponents.SIZE, 10);
             PacketDistributor.sendToServer(new ShrinkinatorSizeSyncPayload(size, usedHand));
-            player.displayClientMessage(Component.literal("Size: " + size), true);
+            player.displayClientMessage(Component.literal(String.format("Size: %.1f", (float) size / 10)), true);
         }
     }
 
     @Override
     public void appendHoverText(ItemStack stack, TooltipContext context, List<Component> tooltipComponents, TooltipFlag tooltipFlag) {
-        tooltipComponents.add(Component.literal("Size: " + stack.getOrDefault(CBDataComponents.SIZE, 1f)));
+        int size = stack.getOrDefault(CBDataComponents.SIZE, 10);
+        tooltipComponents.add(Component.literal(String.format("Size: %.1f", (float) size / 10))
+                .withStyle(ChatFormatting.DARK_GRAY));
         super.appendHoverText(stack, context, tooltipComponents, tooltipFlag);
     }
 }

src/main/java/com/leclowndu93150/carbort/content/items/ToolTiers.java

@@ -6,7 +6,7 @@
 import net.neoforged.neoforge.common.SimpleTier;
 import net.neoforged.neoforge.common.Tags;
 
-public class ToolTiers {
+public final class ToolTiers {
     public static final Tier PARTY = new SimpleTier(
             Tags.Blocks.NEEDS_NETHERITE_TOOL,
             6512,
@@ -23,4 +23,12 @@ public class ToolTiers {
             50,
             () -> Ingredient.of(CBItems.DEEPSTEAL_INGOT)
     );
+    public static final Tier BEDROCKIUM = new SimpleTier(
+            Tags.Blocks.NEEDS_NETHERITE_TOOL,
+            13024,
+            20f,
+            4f,
+            50,
+            () -> Ingredient.of(CBItems.BEDROCKIUM_INGOT)
+    );
 }

src/main/java/com/leclowndu93150/carbort/data/CBDataComponents.java

@@ -20,12 +20,15 @@ public final class CBDataComponents {
     public static final Supplier<DataComponentType<SimpleFluidContent>> FLUID_STORAGE = DATA_COMPONENTS.register("fluid",
             () -> DataComponentType.<SimpleFluidContent>builder().persistent(SimpleFluidContent.CODEC).networkSynchronized(SimpleFluidContent.STREAM_CODEC).build());
 
+    // UNSTABLE INGOT
     public static final Supplier<DataComponentType<Integer>> TIMER = DATA_COMPONENTS.register("timer",
             () -> DataComponentType.<Integer>builder().persistent(Codec.INT).networkSynchronized(ByteBufCodecs.INT).build());
+    // UNSTABLE INGOT && FUNERAL PICKAXE
     public static final Supplier<DataComponentType<Boolean>> ACTIVE = registerDataComponentType("active",
             () -> builder -> builder.persistent(Codec.BOOL).networkSynchronized(ByteBufCodecs.BOOL));
-    public static final Supplier<DataComponentType<Float>> SIZE = registerDataComponentType("size",
-            () -> builder -> builder.persistent(Codec.FLOAT).networkSynchronized(ByteBufCodecs.FLOAT));
+    // SHRINKINATOR
+    public static final Supplier<DataComponentType<Integer>> SIZE = registerDataComponentType("size",
+            () -> builder -> builder.persistent(Codec.INT).networkSynchronized(ByteBufCodecs.INT));
 
     public static <T> Supplier<DataComponentType<T>> registerDataComponentType(
             String name, Supplier<UnaryOperator<DataComponentType.Builder<T>>> builderOperator) {

src/main/java/com/leclowndu93150/carbort/networking/PayloadActions.java

@@ -28,23 +28,20 @@ public static void chunkAnalyzerAction(ChunkAnalyzerTogglePayload payload, IPayl
         if (payload.payloadType() == 0) {
             Player player = ctx.player();
             player.level().getServer().doRunTask(new TickTask(0, () -> {
-                if (player instanceof ServerPlayer serverPlayer && player.containerMenu instanceof ChunkAnalyzerMenu menu) {
+                if (player instanceof ServerPlayer serverPlayer && player.containerMenu instanceof ChunkAnalyzerMenu) {
                     ItemStack itemStack = getAnalyzer(player);
-                    IEnergyStorage energyStorage = CapabilityUtils.itemEnergyStorage(itemStack);
-                    int energyUsage = ((ChunkAnalyzerItem) itemStack.getItem()).getEnergyUsage();
-                    int drained = energyStorage.extractEnergy(energyUsage, true);
-                    if (drained == energyUsage) {
+                    ChunkAnalyzerItem item = (ChunkAnalyzerItem) itemStack.getItem();
+                    if (item.useEnergy(player, itemStack)) {
                         ChunkAnalyzerHelper helper = new ChunkAnalyzerHelper(player, player.level());
                         Object2IntMap<Block> blocks = helper.scan();
-                        energyStorage.extractEnergy(energyUsage, false);
                         PacketDistributor.sendToPlayer(serverPlayer, new ChunkAnalyzerTogglePayload((byte) 1));
                         List<Integer> blocks1 = blocks.keySet()
                                 .stream()
                                 .map(BuiltInRegistries.BLOCK::getId)
                                 .toList();
                         ChunkAnalyzerDataPayload payload1 = new ChunkAnalyzerDataPayload(blocks1, blocks.values().intStream().boxed().toList());
                         PacketDistributor.sendToPlayer(serverPlayer, payload1);
-                    } else  {
+                    } else {
                         PacketDistributor.sendToPlayer(serverPlayer, new ChunkAnalyzerTogglePayload((byte) 2));
                     }
                 }

src/main/java/com/leclowndu93150/carbort/networking/ShrinkinatorSizeSyncPayload.java

@@ -12,9 +12,9 @@
 import net.minecraft.world.entity.player.Player;
 import net.neoforged.neoforge.network.handling.IPayloadContext;
 
-public record ShrinkinatorSizeSyncPayload(float size, InteractionHand usedHand) implements CustomPacketPayload {
+public record ShrinkinatorSizeSyncPayload(int size, InteractionHand usedHand) implements CustomPacketPayload {
     public static final StreamCodec<ByteBuf, ShrinkinatorSizeSyncPayload> STREAM_CODEC = StreamCodec.composite(
-            ByteBufCodecs.FLOAT,
+            ByteBufCodecs.INT,
             ShrinkinatorSizeSyncPayload::size,
             CodecUtils.enumStreamCodec(InteractionHand.class),
             ShrinkinatorSizeSyncPayload::usedHand,

src/main/java/com/leclowndu93150/carbort/registries/CBEntityTypes.java

@@ -0,0 +1,18 @@
+package com.leclowndu93150.carbort.registries;
+
+import com.leclowndu93150.carbort.Carbort;
+import com.leclowndu93150.carbort.content.entities.DynamiteEntity;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.entity.MobCategory;
+import net.minecraft.world.entity.projectile.Snowball;
+import net.neoforged.neoforge.registries.DeferredRegister;
+
+import java.util.function.Supplier;
+
+public final class CBEntityTypes {
+    public static final DeferredRegister<EntityType<?>> ENTITY_TYPES = DeferredRegister.create(BuiltInRegistries.ENTITY_TYPE, Carbort.MODID);
+
+    public static final Supplier<EntityType<DynamiteEntity>> DYNAMITE = ENTITY_TYPES.register("dynamite",
+            () -> EntityType.Builder.<DynamiteEntity>of(DynamiteEntity::new, MobCategory.MISC).sized(0.25F, 0.25F).clientTrackingRange(4).updateInterval(10).build("dynamite"));
+}

src/main/java/com/leclowndu93150/carbort/registries/CBItems.java

@@ -7,6 +7,7 @@
 import net.minecraft.world.effect.MobEffects;
 import net.minecraft.world.food.FoodProperties;
 import net.minecraft.world.item.*;
+import net.neoforged.neoforge.fluids.SimpleFluidContent;
 import net.neoforged.neoforge.registries.DeferredItem;
 import net.neoforged.neoforge.registries.DeferredRegister;
 
@@ -19,15 +20,20 @@ public final class CBItems {
 
     public static final DeferredRegister.Items ITEMS = DeferredRegister.createItems(Carbort.MODID);
 
-    public static final DeferredItem<SwordItem> IRON_GREAT_SWORD = ITEMS.register("iron_great_sword", () -> new SwordItem(Tiers.DIAMOND, new Item.Properties()
-            .attributes(SwordItem.createAttributes(Tiers.DIAMOND, 3, -3.2F))));
+    public static final DeferredItem<BedrockiumBladeItem> BEDROCKIUM_BLADE = ITEMS.register("bedrockium_blade", () -> new BedrockiumBladeItem(new Item.Properties()
+            .component(CBDataComponents.ACTIVE, false)
+            .component(CBDataComponents.FLUID_STORAGE, SimpleFluidContent.EMPTY)
+            .attributes(SwordItem.createAttributes(ToolTiers.BEDROCKIUM, 7, -3.2F))));
     public static final DeferredItem<PartyPickaxeItem> PARTY_PICKAXE = ITEMS.register("party_pickaxe", () -> new PartyPickaxeItem(new Item.Properties()));
-    public static final DeferredItem<FuneralPickaxeItem> FUNERAL_PICKAXE = ITEMS.register("funeral_pickaxe", () -> new FuneralPickaxeItem(new Item.Properties()));
+    public static final DeferredItem<FuneralPickaxeItem> FUNERAL_PICKAXE = ITEMS.register("funeral_pickaxe", () -> new FuneralPickaxeItem(new Item.Properties()
+            .component(CBDataComponents.ACTIVE, false)
+            .component(CBDataComponents.FLUID_STORAGE, SimpleFluidContent.EMPTY)
+            .attributes(PickaxeItem.createAttributes(ToolTiers.FUNERAL, 3, -2.8F))));
     public static final DeferredItem<Item> BEAN_WAND = ITEMS.register("bean_wand", () -> new Item(new Item.Properties()));
     public static final DeferredItem<ShrinkinatorItem> SHRINKINATOR = ITEMS.register("shrinkinator", () -> new ShrinkinatorItem(new Item.Properties()
             .stacksTo(1)
             .rarity(Rarity.RARE)
-            .component(CBDataComponents.SIZE, 1f)
+            .component(CBDataComponents.SIZE, 10)
             .component(CBDataComponents.ENERGY_STORAGE, 0)));
     public static final DeferredItem<HealingAxeItem> HEALING_AXE = ITEMS.register("healing_axe", () -> new HealingAxeItem(new Item.Properties()));
     public static final DeferredItem<ChunkAnalyzerItem> CHUNK_ANALYZER = ITEMS.register("chunk_analyzer",
@@ -61,7 +67,7 @@ public final class CBItems {
     public static final DeferredItem<UnstableIngotItem> UNSTABLE_INGOT = ITEMS.register("unstable_ingot", () -> new UnstableIngotItem(new Item.Properties()));
     public static final DeferredItem<Item> BEDROCKIUM_INGOT = ITEMS.register("bedrockium_ingot", () -> new Item(new Item.Properties()));
     public static final DeferredItem<Item> DEEPSTEAL_INGOT = ITEMS.register("deepsteal_ingot", () -> new Item(new Item.Properties()));
-    public static final DeferredItem<Item> DYNAMITE = ITEMS.register("dynamite", () -> new Item(new Item.Properties()));
+    public static final DeferredItem<DynamiteItem> DYNAMITE = ITEMS.register("dynamite", () -> new DynamiteItem(new Item.Properties()));
 
     public static final DeferredItem<EmpItem> EMP = ITEMS.register("emp", () -> new EmpItem(new Item.Properties()));
 

src/main/resources/assets/carbort/models/item/bedrockium_blade.json

@@ -0,0 +1,21 @@
+{
+  "parent": "minecraft:item/handheld",
+  "loader": "neoforge:separate_transforms",
+  "textures": {
+    "layer0": "carbort:item/bedrockium_blade_gui"
+  },
+  "base": {
+    "parent": "carbort:item/bedrockium_blade_handheld"
+  },
+  "perspectives": {
+    "gui": {
+      "parent": "carbort:item/bedrockium_blade_gui"
+    },
+    "fixed": {
+      "parent": "carbort:item/bedrockium_blade_gui"
+    },
+    "ground": {
+      "parent": "carbort:item/bedrockium_blade_gui"
+    }
+  }
+}

src/main/resources/assets/carbort/models/item/iron_great_sword_gui.json → src/main/resources/assets/carbort/models/item/bedrockium_blade_gui.json

@@ -1,6 +1,6 @@
 {
   "parent": "minecraft:item/handheld",
   "textures": {
-    "layer0": "carbort:item/iron_great_sword_gui"
+    "layer0": "carbort:item/bedrockium_blade_gui"
   }
 }

src/main/resources/assets/carbort/models/item/iron_great_sword_handheld.json → src/main/resources/assets/carbort/models/item/bedrockium_blade_handheld.json

@@ -1,7 +1,7 @@
 {
   "parent": "minecraft:item/handheld",
   "textures": {
-    "layer0": "carbort:item/iron_great_sword"
+    "layer0": "carbort:item/bedrockium_blade"
   },
   "display": {
     "thirdperson_righthand": {