Crea LÍQUIDOS o Fluidos en Minecraft

package dev.polv.cursofabric.fluid;  
  
import net.minecraft.block.Block;  
import net.minecraft.block.BlockState;  
import net.minecraft.block.entity.BlockEntity;  
import net.minecraft.fluid.FlowableFluid;  
import net.minecraft.fluid.Fluid;  
import net.minecraft.fluid.FluidState;  
import net.minecraft.util.math.BlockPos;  
import net.minecraft.util.math.Direction;  
import net.minecraft.world.BlockView;  
import net.minecraft.world.World;  
import net.minecraft.world.WorldAccess;  
import net.minecraft.world.WorldView;  
  
public abstract class ModFluid extends FlowableFluid {  
    /**  
     * @return whether the given fluid an instance of this fluid  
     */    @Override  
    public boolean matchesType(Fluid fluid) {  
        return fluid == getStill() || fluid == getFlowing();  
    }  
  
    /**  
     * @return whether the fluid is infinite (which means can be infinitely created like water). In vanilla, it depends on the game rule.  
     */    @Override  
    protected boolean isInfinite(World world) {  
        return false;  
    }  
  
    /**  
     * Perform actions when the fluid flows into a replaceable block. Water drops     * the block's loot table. Lava plays the "block.lava.extinguish" sound.     */    @Override  
    protected void beforeBreakingBlock(WorldAccess world, BlockPos pos, BlockState state) {  
        final BlockEntity blockEntity = state.hasBlockEntity() ? world.getBlockEntity(pos) : null;  
        Block.dropStacks(state, world, pos, blockEntity);  
    }  
  
    /**  
     * Lava returns true if it's FluidState is above a certain height and the     * Fluid is Water.     *     * @return whether the given Fluid can flow into this FluidState  
     */    @Override  
    protected boolean canBeReplacedWith(FluidState fluidState, BlockView blockView, BlockPos blockPos, Fluid fluid, Direction direction) {  
        return false;  
    }  
  
    /**  
     * Possibly related to the distance checks for flowing into nearby holes?     * Water returns 4. Lava returns 2 in the Overworld and 4 in the Nether.     */    @Override  
    protected int getFlowSpeed(WorldView worldView) {  
        return 4;  
    }  
  
    /**  
     * Water returns 1. Lava returns 2 in the Overworld and 1 in the Nether.     */    @Override  
    protected int getLevelDecreasePerBlock(WorldView worldView) {  
        return 1;  
    }  
  
    /**  
     * Water returns 5. Lava returns 30 in the Overworld and 10 in the Nether.     */    @Override  
    public int getTickRate(WorldView worldView) {  
        return 5;  
    }  
  
    /**  
     * Water and Lava both return 100.0F.     */    @Override  
    protected float getBlastResistance() {  
        return 100.0F;  
    }  
}

package dev.polv.cursofabric.fluid;  
  
import net.minecraft.block.BlockState;  
import net.minecraft.fluid.Fluid;  
import net.minecraft.fluid.FluidState;  
import net.minecraft.item.Item;  
import net.minecraft.state.StateManager;  
import net.minecraft.state.property.Properties;  
  
public abstract class UraniumFluid extends ModFluid {  
  
    @Override  
    public Fluid getStill() {  
        return ModFluids.URANIUM_FLUID.staticFluid();  
    }  
  
    @Override  
    public Fluid getFlowing() {  
        return ModFluids.URANIUM_FLUID.flowingFluid();  
    }  
  
    @Override  
    public Item getBucketItem() {  
        return ModFluids.URANIUM_FLUID.fluidBucket();  
    }  
  
    @Override  
    protected BlockState toBlockState(FluidState fluidState) {  
        return ModFluids.URANIUM_FLUID_BLOCK.getDefaultState().with(Properties.LEVEL_15, getBlockStateLevel(fluidState));  
    }  
  
    public static class Flowing extends UraniumFluid {  
        @Override  
        protected void appendProperties(StateManager.Builder<Fluid, FluidState> builder) {  
            super.appendProperties(builder);  
            builder.add(LEVEL);  
        }  
  
        @Override  
        public int getLevel(FluidState fluidState) {  
            return fluidState.get(LEVEL);  
        }  
  
        @Override  
        public boolean isStill(FluidState fluidState) {  
            return false;  
        }  
    }  
  
    public static class Still extends UraniumFluid {  
        @Override  
        public int getLevel(FluidState fluidState) {  
            return 8;  
        }  
  
        @Override  
        public boolean isStill(FluidState fluidState) {  
            return true;  
        }  
    }  
  
}

private static RegisteredFluid registeredFluid(String fluidId, Fluid staticFluid, Fluid flowingFluid) {  
    Fluid registeredStaticFluid = Registry.register(Registries.FLUID, new Identifier(CursoFabric.MODID, "static_" + fluidId), staticFluid);  
    Fluid registeredFlowingFluid = Registry.register(Registries.FLUID, new Identifier(CursoFabric.MODID, "flowing_" + fluidId), flowingFluid);  
    BucketItem bucketItem = Registry.register(Registries.ITEM, new Identifier(CursoFabric.MODID, fluidId + "_bucket"), new BucketItem(registeredFlowingFluid, new Item.Settings().maxCount(1)));  
  
    return new RegisteredFluid(registeredStaticFluid, registeredFlowingFluid, bucketItem);  
}  
  
public static void registerFluids() {  
    CursoFabric.LOGGER.info("Registrando fluidos...");  
}

public static final RegisteredFluid URANIUM_FLUID = registeredFluid(  
        "uranium",  
        new UraniumFluid.Still(),  
        new UraniumFluid.Flowing()  
);

public static final FluidBlock URANIUM_FLUID_BLOCK = registeredFluidBlock(  
        "uranium",  
        URANIUM_FLUID.staticFluid()  
);
 
private static FluidBlock registeredFluidBlock(String fluidId, Fluid staticFluid) {  
    FluidBlock fluidBlock = Registry.register(Registries.BLOCK, new Identifier(CursoFabric.MODID, fluidId + "_liquid"), new FluidBlock((FlowableFluid) staticFluid, FabricBlockSettings.copy(Blocks.WATER)));  
  
    return fluidBlock;  
}

@Override  
public void onInitializeClient() {  
    FluidRenderHandlerRegistry.INSTANCE.register(ModFluids.URANIUM_FLUID.staticFluid(), ModFluids.URANIUM_FLUID.flowingFluid(), new SimpleFluidRenderHandler(  
          new Identifier("minecraft:block/water_still"),  
          new Identifier("minecraft:block/water_flow"),  
          0x00ff00  
    ));  
  
    BlockRenderLayerMap.INSTANCE.putFluids(RenderLayer.getTranslucent(), ModFluids.URANIUM_FLUID.staticFluid(), ModFluids.URANIUM_FLUID.flowingFluid());  
}