poison / honey (rendering by replacing the vanilla fluid renderer),

update of most textures to fit the style of 1.14

src/main/java/me/km/Client.java

@@ -23,8 +23,6 @@ import net.minecraft.client.gui.screen.Screen;
 import net.minecraft.client.renderer.color.BlockColors;
 import net.minecraft.client.renderer.color.IBlockColor;
 import net.minecraft.client.renderer.color.ItemColors;
-import net.minecraft.client.renderer.entity.EntityRenderer;
-import net.minecraft.entity.Entity;
 import net.minecraft.item.Item;
 import net.minecraft.item.ArmorItem;
 import net.minecraft.item.BlockItem;
@@ -57,6 +55,7 @@ public class Client
         MinecraftForge.EVENT_BUS.register(new KeyManager());
         registerColors();
         ClientReflectionUtils.updatePlayerRenderer();
+        ClientReflectionUtils.updateFluidRenderer();
     }
     
     private static void registerColors()

src/main/java/me/km/ObjectRegistry.java

@@ -8,6 +8,7 @@ import me.km.world.WorldManager;
 import net.minecraft.block.Block;
 import net.minecraft.block.Blocks;
 import net.minecraft.entity.EntityType;
+import net.minecraft.fluid.Fluid;
 import net.minecraft.item.Item;
 import net.minecraft.item.Items;
 import net.minecraft.tileentity.TileEntityType;
@@ -93,4 +94,10 @@ public class ObjectRegistry
     {
         e.getRegistry().register(WorldManager.MOD_DIMENSION);
     }
+    
+    @SubscribeEvent
+    public static void onFluidRegistry(RegistryEvent.Register<Fluid> e) 
+    {
+        ModBlocks.initFluids(e.getRegistry());
+    }
 }

src/main/java/me/km/blocks/FluidHoney.java

@@ -0,0 +1,93 @@
+package me.km.blocks;
+
+import me.km.items.ModItems;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.FlowingFluidBlock;
+import net.minecraft.fluid.Fluid;
+import net.minecraft.fluid.IFluidState;
+import net.minecraft.fluid.WaterFluid;
+import net.minecraft.item.Item;
+import net.minecraft.state.StateContainer;
+import net.minecraft.world.IWorldReader;
+
+public abstract class FluidHoney extends WaterFluid
+{
+    @Override
+    public Fluid getFlowingFluid()
+    {
+        return ModBlocks.FLOWING_HONEY;
+    }
+
+    @Override
+    public Fluid getStillFluid()
+    {
+        return ModBlocks.SOURCE_HONEY;
+    }
+
+    @Override
+    public Item getFilledBucket()
+    {
+        return ModItems.bucketHoney;
+    }
+
+    @Override
+    public BlockState getBlockState(IFluidState state)
+    {
+        return ModBlocks.honey.getDefaultState().with(FlowingFluidBlock.LEVEL, getLevelFromState(state));
+    }
+
+    @Override
+    public boolean isEquivalentTo(Fluid fluidIn)
+    {
+        return fluidIn == ModBlocks.SOURCE_HONEY || fluidIn == ModBlocks.FLOWING_HONEY;
+    }
+
+    @Override
+    public int getLevelDecreasePerBlock(IWorldReader worldIn)
+    {
+        return 2;
+    }
+
+    @Override
+    public int getTickRate(IWorldReader p_205569_1_)
+    {
+        return 20;
+    }
+
+    public static class Flowing extends FluidHoney
+    {
+        @Override
+        protected void fillStateContainer(StateContainer.Builder<Fluid, IFluidState> builder)
+        {
+            super.fillStateContainer(builder);
+            builder.add(LEVEL_1_8);
+        }
+
+        @Override
+        public int getLevel(IFluidState p_207192_1_)
+        {
+            return p_207192_1_.get(LEVEL_1_8);
+        }
+
+        @Override
+        public boolean isSource(IFluidState state)
+        {
+            return false;
+        }
+    }
+
+    public static class Source extends FluidHoney
+    {
+        @Override
+        public int getLevel(IFluidState state)
+        {
+            return 8;
+        }
+
+        @Override
+        public boolean isSource(IFluidState state)
+        {
+            return true;
+        }
+    }
+}

src/main/java/me/km/blocks/FluidPoison.java

@@ -0,0 +1,81 @@
+package me.km.blocks;
+
+import me.km.items.ModItems;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.FlowingFluidBlock;
+import static net.minecraft.fluid.FlowingFluid.LEVEL_1_8;
+import net.minecraft.fluid.Fluid;
+import net.minecraft.fluid.IFluidState;
+import net.minecraft.fluid.WaterFluid;
+import net.minecraft.item.Item;
+import net.minecraft.state.StateContainer;
+
+public abstract class FluidPoison extends WaterFluid
+{
+    @Override
+    public Fluid getFlowingFluid()
+    {
+        return ModBlocks.FLOWING_POISON;
+    }
+
+    @Override
+    public Fluid getStillFluid()
+    {
+        return ModBlocks.SOURCE_POISON;
+    }
+
+    @Override
+    public Item getFilledBucket()
+    {
+        return ModItems.bucketPoison;
+    }
+
+    @Override
+    public BlockState getBlockState(IFluidState state)
+    {
+        return ModBlocks.poison.getDefaultState().with(FlowingFluidBlock.LEVEL, getLevelFromState(state));
+    }
+
+    @Override
+    public boolean isEquivalentTo(Fluid fluidIn)
+    {
+        return fluidIn == ModBlocks.SOURCE_POISON || fluidIn == ModBlocks.FLOWING_POISON;
+    }
+
+    public static class Flowing extends FluidPoison
+    {
+        @Override
+        protected void fillStateContainer(StateContainer.Builder<Fluid, IFluidState> builder)
+        {
+            super.fillStateContainer(builder);
+            builder.add(LEVEL_1_8);
+        }
+
+        @Override
+        public int getLevel(IFluidState p_207192_1_)
+        {
+            return p_207192_1_.get(LEVEL_1_8);
+        }
+
+        @Override
+        public boolean isSource(IFluidState state)
+        {
+            return false;
+        }
+    }
+
+    public static class Source extends FluidPoison
+    {
+        @Override
+        public int getLevel(IFluidState state)
+        {
+            return 8;
+        }
+
+        @Override
+        public boolean isSource(IFluidState state)
+        {
+            return true;
+        }
+    }
+}

src/main/java/me/km/blocks/ModBlocks.java

@@ -1,18 +1,22 @@
 package me.km.blocks;
 
+import me.km.KajetansMod;
 import me.km.blocks.cookingpot.BlockCookingPot;
 import net.minecraft.block.Block;
 import net.minecraft.block.Block.Properties;
-import net.minecraft.block.SlabBlock;
 import net.minecraft.block.SoundType;
 import net.minecraft.block.material.Material;
 import net.minecraft.block.material.MaterialColor;
 import net.minecraft.block.BlockState;
 import net.minecraft.block.Blocks;
 import net.minecraft.block.LeavesBlock;
+import net.minecraft.fluid.FlowingFluid;
+import net.minecraft.fluid.Fluid;
 import net.minecraft.item.Item;
 import net.minecraft.item.BlockItem;
 import net.minecraft.item.ItemGroup;
+import net.minecraft.potion.Effect;
+import net.minecraft.potion.Effects;
 import net.minecraftforge.registries.IForgeRegistry;
 
 public class ModBlocks 
@@ -55,7 +59,16 @@ public class ModBlocks
     public static Block spikesIron;
     
     // fluids
+    private static FlowingFluid createFluid(String registry, FlowingFluid fluid)
+    {
+        fluid.setRegistryName(KajetansMod.MODID, registry);
+        return fluid;
+    }
+    public static final FlowingFluid FLOWING_POISON = createFluid("flowing_poison", new FluidPoison.Flowing());
+    public static final FlowingFluid SOURCE_POISON = createFluid("poison", new FluidPoison.Source());
     public static Block poison;
+    public static final FlowingFluid FLOWING_HONEY = createFluid("flowing_honey", new FluidHoney.Flowing());
+    public static final FlowingFluid SOURCE_HONEY = createFluid("honey", new FluidHoney.Source());
     public static Block honey;
     
     // slabs
@@ -115,6 +128,18 @@ public class ModBlocks
         return b;
     }
     
+    private static Block createFluidBlock(String registry, Effect effect, FlowingFluid fluid)
+    {
+        Block b = new ModFlowingFluidBlock(fluid, effect, Block.Properties.create(Material.WATER).doesNotBlockMovement().hardnessAndResistance(100.0F)/*.noDrops()*/);
+        b.setRegistryName(registry);
+        return b;
+    }
+    
+    public static void initFluids(IForgeRegistry<Fluid> r) 
+    {
+        r.registerAll(FLOWING_POISON, SOURCE_POISON, FLOWING_HONEY, SOURCE_HONEY);
+    }
+    
     public static void initBlocks(IForgeRegistry<Block> r) 
     {
         // ores + blocks
@@ -153,9 +178,9 @@ public class ModBlocks
         spikesIron = register(r, new BlockSpikes("spikes_iron", Properties.create(Material.IRON).hardnessAndResistance(5.0f, 6.0f)));
         
         // fluids
-        poison = register(r, create("poison", Material.WATER, 0.0f, 0.0f));
-        honey = register(r, create("honey", Material.WATER, 0.0f, 0.0f));
-        
+        poison = register(r, createFluidBlock("poison", Effects.POISON, SOURCE_POISON));
+        honey = register(r, createFluidBlock("honey", Effects.REGENERATION, SOURCE_HONEY));
+
         // slabs
         gravelSlab = register(r, new BlockGravelSlab(Properties.create(Material.SAND, MaterialColor.STONE)
                 .sound(SoundType.GROUND).hardnessAndResistance(0.6f)).setRegistryName("gravel_slab"));
@@ -210,11 +235,7 @@ public class ModBlocks
         register(r, spikesBronze, getItemBlock(spikesBronze, ItemGroup.DECORATIONS));
         register(r, spikesGold, getItemBlock(spikesGold, ItemGroup.DECORATIONS));
         register(r, spikesIron, getItemBlock(spikesIron, ItemGroup.DECORATIONS));
-        
-        // fluids
-        register(r, poison, getItemBlock(poison, ItemGroup.BUILDING_BLOCKS));
-        register(r, honey, getItemBlock(honey, ItemGroup.BUILDING_BLOCKS));
-        
+
         // slabs
         register(r, gravelSlab, getItemBlock(gravelSlab, ItemGroup.BUILDING_BLOCKS));
         

src/main/java/me/km/blocks/ModFlowingFluidBlock.java

@@ -0,0 +1,32 @@
+package me.km.blocks;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.FlowingFluidBlock;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.fluid.FlowingFluid;
+import net.minecraft.potion.Effect;
+import net.minecraft.potion.EffectInstance;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+
+public class ModFlowingFluidBlock extends FlowingFluidBlock
+{
+    private final Effect effect;
+    
+    public ModFlowingFluidBlock(FlowingFluid fluid, Effect effect, Block.Properties builder)
+    {
+        super(fluid, builder);
+        this.effect = effect; 
+    }
+    
+    @Override
+    public void onEntityCollision(BlockState state, World w, BlockPos pos, Entity ent) 
+    {
+        if(ent instanceof LivingEntity)
+        {
+            ((LivingEntity) ent).addPotionEffect(new EffectInstance(effect, 60));
+        }
+    }
+}

src/main/java/me/km/items/ModItems.java

@@ -1,6 +1,7 @@
 package me.km.items;
 
 import me.km.blocks.ModBlocks;
+import net.minecraft.fluid.FlowingFluid;
 import net.minecraft.item.Items;
 import net.minecraft.inventory.EquipmentSlotType;
 import net.minecraft.item.IArmorMaterial;
@@ -9,6 +10,7 @@ import net.minecraft.item.Item;
 import net.minecraft.item.Item.Properties;
 import net.minecraft.item.ArmorItem;
 import net.minecraft.item.BedItem;
+import net.minecraft.item.BucketItem;
 import net.minecraft.item.Food;
 import net.minecraft.item.ItemGroup;
 import net.minecraft.item.HoeItem;
@@ -178,6 +180,10 @@ public class ModItems
     public static Item herbBreathing;
     public static Item herbFire;
     
+    // buckets
+    public static Item bucketPoison;
+    public static Item bucketHoney;
+    
     private static Item newSword(IItemTier tier)
     {
         return new SwordItem(tier, 3, -2.4f, (new Item.Properties()).group(ItemGroup.COMBAT));
@@ -258,6 +264,11 @@ public class ModItems
                 new Food.Builder().hunger(food).saturation(saturation).build()));
     }
     
+    private static Item newBucket(FlowingFluid fluid)
+    {
+        return new BucketItem(fluid, (new Item.Properties()).containerItem(Items.BUCKET).maxStackSize(1).group(ItemGroup.MISC));
+    }
+    
     public static void init(IForgeRegistry<Item> r) 
     {
         // nuggets and ingots
@@ -415,6 +426,10 @@ public class ModItems
         herbBreathing = register(r, newEffectHerb(Effects.WATER_BREATHING, 2400, 0), "herb_breathing");
         herbFire = register(r, newEffectHerb(Effects.FIRE_RESISTANCE, 2400, 0), "herb_fire");
         
+        // buckets
+        bucketPoison = register(r, newBucket(ModBlocks.SOURCE_POISON), "poison_bucket");
+        bucketHoney = register(r, newBucket(ModBlocks.SOURCE_HONEY), "honey_bucket");
+        
         // block overrides
         try
         {

src/main/java/me/km/overrides/ModFluidBlockRenderer.java

@@ -0,0 +1,367 @@
+package me.km.overrides;
+
+import me.km.blocks.ModBlocks;
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.Blocks;
+import net.minecraft.block.StainedGlassBlock;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.BufferBuilder;
+import net.minecraft.client.renderer.FluidBlockRenderer;
+import net.minecraft.client.renderer.model.ModelBakery;
+import net.minecraft.client.renderer.texture.AtlasTexture;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.fluid.Fluid;
+import net.minecraft.fluid.IFluidState;
+import net.minecraft.tags.FluidTags;
+import net.minecraft.util.Direction;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.MathHelper;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.util.math.shapes.VoxelShape;
+import net.minecraft.util.math.shapes.VoxelShapes;
+import net.minecraft.world.IBlockReader;
+import net.minecraft.world.IEnviromentBlockReader;
+import net.minecraft.world.biome.BiomeColors;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+@OnlyIn(Dist.CLIENT)
+public class ModFluidBlockRenderer extends FluidBlockRenderer
+{
+    private final TextureAtlasSprite[] atlasSpritesLava = new TextureAtlasSprite[2];
+    private final TextureAtlasSprite[] atlasSpritesWater = new TextureAtlasSprite[2];
+    private TextureAtlasSprite atlasSpriteWaterOverlay;
+
+    @Override
+    protected void initAtlasSprites()
+    {
+        AtlasTexture atlastexture = Minecraft.getInstance().getTextureMap();
+        this.atlasSpritesLava[0] = Minecraft.getInstance().getModelManager().getBlockModelShapes().getModel(Blocks.LAVA.getDefaultState()).getParticleTexture();
+        this.atlasSpritesLava[1] = atlastexture.getSprite(ModelBakery.LOCATION_LAVA_FLOW);
+        this.atlasSpritesWater[0] = Minecraft.getInstance().getModelManager().getBlockModelShapes().getModel(Blocks.WATER.getDefaultState()).getParticleTexture();
+        this.atlasSpritesWater[1] = atlastexture.getSprite(ModelBakery.LOCATION_WATER_FLOW);
+        this.atlasSpriteWaterOverlay = atlastexture.getSprite(ModelBakery.LOCATION_WATER_OVERLAY);
+    }
+    
+    private static boolean isAdjacentFluidSameAs(IBlockReader worldIn, BlockPos pos, Direction side, IFluidState state)
+    {
+        BlockPos blockpos = pos.offset(side);
+        IFluidState ifluidstate = worldIn.getFluidState(blockpos);
+        return ifluidstate.getFluid().isEquivalentTo(state.getFluid());
+    }
+
+    private static boolean func_209556_a(IBlockReader reader, BlockPos pos, Direction face, float heightIn)
+    {
+        BlockPos blockpos = pos.offset(face);
+        BlockState blockstate = reader.getBlockState(blockpos);
+        if(blockstate.isSolid())
+        {
+            VoxelShape voxelshape = VoxelShapes.create(0.0D, 0.0D, 0.0D, 1.0D, (double) heightIn, 1.0D);
+            VoxelShape voxelshape1 = blockstate.getRenderShape(reader, blockpos);
+            return VoxelShapes.isCubeSideCovered(voxelshape, voxelshape1, face);
+        }
+        else
+        {
+            return false;
+        }
+    }    
+    
+    @Override
+    public boolean render(IEnviromentBlockReader reader, BlockPos pos, BufferBuilder bufferBuilderIn, IFluidState fluidStateIn)
+    {
+        boolean flag = fluidStateIn.isTagged(FluidTags.LAVA);
+        TextureAtlasSprite[] atextureatlassprite = flag ? this.atlasSpritesLava : this.atlasSpritesWater;
+        int i;
+        if(flag)
+        {
+            i = 0x00FFFFFF;
+        }
+        else if(ModBlocks.SOURCE_POISON.isEquivalentTo(fluidStateIn.getFluid()))
+        {
+            i = 0x008A099D;
+        }
+        else if(ModBlocks.SOURCE_HONEY.isEquivalentTo(fluidStateIn.getFluid()))
+        {
+            i = 0xFFA76D09;
+        }
+        else
+        {
+            i = BiomeColors.getWaterColor(reader, pos);
+        }
+        float red = (float) (i >> 16 & 255) / 255.0F;
+        float green = (float) (i >> 8 & 255) / 255.0F;
+        float blue = (float) (i & 255) / 255.0F;
+        boolean flag1 = !isAdjacentFluidSameAs(reader, pos, Direction.UP, fluidStateIn);
+        boolean flag2 = !isAdjacentFluidSameAs(reader, pos, Direction.DOWN, fluidStateIn) && !func_209556_a(reader, pos, Direction.DOWN, 0.8888889F);
+        boolean flag3 = !isAdjacentFluidSameAs(reader, pos, Direction.NORTH, fluidStateIn);
+        boolean flag4 = !isAdjacentFluidSameAs(reader, pos, Direction.SOUTH, fluidStateIn);
+        boolean flag5 = !isAdjacentFluidSameAs(reader, pos, Direction.WEST, fluidStateIn);
+        boolean flag6 = !isAdjacentFluidSameAs(reader, pos, Direction.EAST, fluidStateIn);
+        if(!flag1 && !flag2 && !flag6 && !flag5 && !flag3 && !flag4)
+        {
+            return false;
+        }
+        else
+        {
+            boolean flag7 = false;
+            float f3 = 0.5F;
+            float f4 = 1.0F;
+            float f5 = 0.8F;
+            float f6 = 0.6F;
+            float f7 = this.getFluidHeight(reader, pos, fluidStateIn.getFluid());
+            float f8 = this.getFluidHeight(reader, pos.south(), fluidStateIn.getFluid());
+            float f9 = this.getFluidHeight(reader, pos.east().south(), fluidStateIn.getFluid());
+            float f10 = this.getFluidHeight(reader, pos.east(), fluidStateIn.getFluid());
+            double d0 = (double) pos.getX();
+            double d1 = (double) pos.getY();
+            double d2 = (double) pos.getZ();
+            float f11 = 0.001F;
+            if(flag1 && !func_209556_a(reader, pos, Direction.UP, Math.min(Math.min(f7, f8), Math.min(f9, f10))))
+            {
+                flag7 = true;
+                f7 -= 0.001F;
+                f8 -= 0.001F;
+                f9 -= 0.001F;
+                f10 -= 0.001F;
+                Vec3d vec3d = fluidStateIn.getFlow(reader, pos);
+                float f12;
+                float f13;
+                float f14;
+                float f15;
+                float f16;
+                float f17;
+                float f18;
+                float f19;
+                if(vec3d.x == 0.0D && vec3d.z == 0.0D)
+                {
+                    TextureAtlasSprite textureatlassprite1 = atextureatlassprite[0];
+                    f12 = textureatlassprite1.getInterpolatedU(0.0D);
+                    f16 = textureatlassprite1.getInterpolatedV(0.0D);
+                    f13 = f12;
+                    f17 = textureatlassprite1.getInterpolatedV(16.0D);
+                    f14 = textureatlassprite1.getInterpolatedU(16.0D);
+                    f18 = f17;
+                    f15 = f14;
+                    f19 = f16;
+                }
+                else
+                {
+                    TextureAtlasSprite textureatlassprite = atextureatlassprite[1];
+                    float f20 = (float) MathHelper.atan2(vec3d.z, vec3d.x) - ((float) Math.PI / 2F);
+                    float f21 = MathHelper.sin(f20) * 0.25F;
+                    float f22 = MathHelper.cos(f20) * 0.25F;
+                    float f23 = 8.0F;
+                    f12 = textureatlassprite.getInterpolatedU((double) (8.0F + (-f22 - f21) * 16.0F));
+                    f16 = textureatlassprite.getInterpolatedV((double) (8.0F + (-f22 + f21) * 16.0F));
+                    f13 = textureatlassprite.getInterpolatedU((double) (8.0F + (-f22 + f21) * 16.0F));
+                    f17 = textureatlassprite.getInterpolatedV((double) (8.0F + (f22 + f21) * 16.0F));
+                    f14 = textureatlassprite.getInterpolatedU((double) (8.0F + (f22 + f21) * 16.0F));
+                    f18 = textureatlassprite.getInterpolatedV((double) (8.0F + (f22 - f21) * 16.0F));
+                    f15 = textureatlassprite.getInterpolatedU((double) (8.0F + (f22 - f21) * 16.0F));
+                    f19 = textureatlassprite.getInterpolatedV((double) (8.0F + (-f22 - f21) * 16.0F));
+                }
+
+                float f39 = (f12 + f13 + f14 + f15) / 4.0F;
+                float f41 = (f16 + f17 + f18 + f19) / 4.0F;
+                float f42 = (float) atextureatlassprite[0].getWidth() / (atextureatlassprite[0].getMaxU() - atextureatlassprite[0].getMinU());
+                float f43 = (float) atextureatlassprite[0].getHeight() / (atextureatlassprite[0].getMaxV() - atextureatlassprite[0].getMinV());
+                float f44 = 4.0F / Math.max(f43, f42);
+                f12 = MathHelper.lerp(f44, f12, f39);
+                f13 = MathHelper.lerp(f44, f13, f39);
+                f14 = MathHelper.lerp(f44, f14, f39);
+                f15 = MathHelper.lerp(f44, f15, f39);
+                f16 = MathHelper.lerp(f44, f16, f41);
+                f17 = MathHelper.lerp(f44, f17, f41);
+                f18 = MathHelper.lerp(f44, f18, f41);
+                f19 = MathHelper.lerp(f44, f19, f41);
+                int j = this.getCombinedLightUpMax(reader, pos);
+                int k = j >> 16 & '\uffff';
+                int l = j & '\uffff';
+                float f24 = 1.0F * red;
+                float f25 = 1.0F * green;
+                float f26 = 1.0F * blue;
+                bufferBuilderIn.pos(d0 + 0.0D, d1 + (double) f7, d2 + 0.0D).color(f24, f25, f26, 1.0F).tex((double) f12, (double) f16).lightmap(k, l).endVertex();
+                bufferBuilderIn.pos(d0 + 0.0D, d1 + (double) f8, d2 + 1.0D).color(f24, f25, f26, 1.0F).tex((double) f13, (double) f17).lightmap(k, l).endVertex();
+                bufferBuilderIn.pos(d0 + 1.0D, d1 + (double) f9, d2 + 1.0D).color(f24, f25, f26, 1.0F).tex((double) f14, (double) f18).lightmap(k, l).endVertex();
+                bufferBuilderIn.pos(d0 + 1.0D, d1 + (double) f10, d2 + 0.0D).color(f24, f25, f26, 1.0F).tex((double) f15, (double) f19).lightmap(k, l).endVertex();
+                if(fluidStateIn.shouldRenderSides(reader, pos.up()))
+                {
+                    bufferBuilderIn.pos(d0 + 0.0D, d1 + (double) f7, d2 + 0.0D).color(f24, f25, f26, 1.0F).tex((double) f12, (double) f16).lightmap(k, l).endVertex();
+                    bufferBuilderIn.pos(d0 + 1.0D, d1 + (double) f10, d2 + 0.0D).color(f24, f25, f26, 1.0F).tex((double) f15, (double) f19).lightmap(k, l).endVertex();
+                    bufferBuilderIn.pos(d0 + 1.0D, d1 + (double) f9, d2 + 1.0D).color(f24, f25, f26, 1.0F).tex((double) f14, (double) f18).lightmap(k, l).endVertex();
+                    bufferBuilderIn.pos(d0 + 0.0D, d1 + (double) f8, d2 + 1.0D).color(f24, f25, f26, 1.0F).tex((double) f13, (double) f17).lightmap(k, l).endVertex();
+                }
+            }
+
+            if(flag2)
+            {
+                float f31 = atextureatlassprite[0].getMinU();
+                float f32 = atextureatlassprite[0].getMaxU();
+                float f34 = atextureatlassprite[0].getMinV();
+                float f36 = atextureatlassprite[0].getMaxV();
+                int i2 = this.getCombinedLightUpMax(reader, pos.down());
+                int j2 = i2 >> 16 & '\uffff';
+                int k2 = i2 & '\uffff';
+                float f37 = 0.5F * red;
+                float f38 = 0.5F * green;
+                float f40 = 0.5F * blue;
+                bufferBuilderIn.pos(d0, d1, d2 + 1.0D).color(f37, f38, f40, 1.0F).tex((double) f31, (double) f36).lightmap(j2, k2).endVertex();
+                bufferBuilderIn.pos(d0, d1, d2).color(f37, f38, f40, 1.0F).tex((double) f31, (double) f34).lightmap(j2, k2).endVertex();
+                bufferBuilderIn.pos(d0 + 1.0D, d1, d2).color(f37, f38, f40, 1.0F).tex((double) f32, (double) f34).lightmap(j2, k2).endVertex();
+                bufferBuilderIn.pos(d0 + 1.0D, d1, d2 + 1.0D).color(f37, f38, f40, 1.0F).tex((double) f32, (double) f36).lightmap(j2, k2).endVertex();
+                flag7 = true;
+            }
+
+            for(int l1 = 0; l1 < 4; ++l1)
+            {
+                float f33;
+                float f35;
+                double d3;
+                double d4;
+                double d5;
+                double d6;
+                Direction direction;
+                boolean flag8;
+                if(l1 == 0)
+                {
+                    f33 = f7;
+                    f35 = f10;
+                    d3 = d0;
+                    d5 = d0 + 1.0D;
+                    d4 = d2 + (double) 0.001F;
+                    d6 = d2 + (double) 0.001F;
+                    direction = Direction.NORTH;
+                    flag8 = flag3;
+                }
+                else if(l1 == 1)
+                {
+                    f33 = f9;
+                    f35 = f8;
+                    d3 = d0 + 1.0D;
+                    d5 = d0;
+                    d4 = d2 + 1.0D - (double) 0.001F;
+                    d6 = d2 + 1.0D - (double) 0.001F;
+                    direction = Direction.SOUTH;
+                    flag8 = flag4;
+                }
+                else if(l1 == 2)
+                {
+                    f33 = f8;
+                    f35 = f7;
+                    d3 = d0 + (double) 0.001F;
+                    d5 = d0 + (double) 0.001F;
+                    d4 = d2 + 1.0D;
+                    d6 = d2;
+                    direction = Direction.WEST;
+                    flag8 = flag5;
+                }
+                else
+                {
+                    f33 = f10;
+                    f35 = f9;
+                    d3 = d0 + 1.0D - (double) 0.001F;
+                    d5 = d0 + 1.0D - (double) 0.001F;
+                    d4 = d2;
+                    d6 = d2 + 1.0D;
+                    direction = Direction.EAST;
+                    flag8 = flag6;
+                }
+
+                if(flag8 && !func_209556_a(reader, pos, direction, Math.max(f33, f35)))
+                {
+                    flag7 = true;
+                    BlockPos blockpos = pos.offset(direction);
+                    TextureAtlasSprite textureatlassprite2 = atextureatlassprite[1];
+                    if(!flag)
+                    {
+                        Block block = reader.getBlockState(blockpos).getBlock();
+                        if(block == Blocks.GLASS || block instanceof StainedGlassBlock)
+                        {
+                            textureatlassprite2 = this.atlasSpriteWaterOverlay;
+                        }
+                    }
+
+                    float f45 = textureatlassprite2.getInterpolatedU(0.0D);
+                    float f46 = textureatlassprite2.getInterpolatedU(8.0D);
+                    float f47 = textureatlassprite2.getInterpolatedV((double) ((1.0F - f33) * 16.0F * 0.5F));
+                    float f48 = textureatlassprite2.getInterpolatedV((double) ((1.0F - f35) * 16.0F * 0.5F));
+                    float f49 = textureatlassprite2.getInterpolatedV(8.0D);
+                    int i1 = this.getCombinedLightUpMax(reader, blockpos);
+                    int j1 = i1 >> 16 & '\uffff';
+                    int k1 = i1 & '\uffff';
+                    float f27 = l1 < 2 ? 0.8F : 0.6F;
+                    float f28 = 1.0F * f27 * red;
+                    float f29 = 1.0F * f27 * green;
+                    float f30 = 1.0F * f27 * blue;
+                    bufferBuilderIn.pos(d3, d1 + (double) f33, d4).color(f28, f29, f30, 1.0F).tex((double) f45, (double) f47).lightmap(j1, k1).endVertex();
+                    bufferBuilderIn.pos(d5, d1 + (double) f35, d6).color(f28, f29, f30, 1.0F).tex((double) f46, (double) f48).lightmap(j1, k1).endVertex();
+                    bufferBuilderIn.pos(d5, d1 + 0.0D, d6).color(f28, f29, f30, 1.0F).tex((double) f46, (double) f49).lightmap(j1, k1).endVertex();
+                    bufferBuilderIn.pos(d3, d1 + 0.0D, d4).color(f28, f29, f30, 1.0F).tex((double) f45, (double) f49).lightmap(j1, k1).endVertex();
+                    if(textureatlassprite2 != this.atlasSpriteWaterOverlay)
+                    {
+                        bufferBuilderIn.pos(d3, d1 + 0.0D, d4).color(f28, f29, f30, 1.0F).tex((double) f45, (double) f49).lightmap(j1, k1).endVertex();
+                        bufferBuilderIn.pos(d5, d1 + 0.0D, d6).color(f28, f29, f30, 1.0F).tex((double) f46, (double) f49).lightmap(j1, k1).endVertex();
+                        bufferBuilderIn.pos(d5, d1 + (double) f35, d6).color(f28, f29, f30, 1.0F).tex((double) f46, (double) f48).lightmap(j1, k1).endVertex();
+                        bufferBuilderIn.pos(d3, d1 + (double) f33, d4).color(f28, f29, f30, 1.0F).tex((double) f45, (double) f47).lightmap(j1, k1).endVertex();
+                    }
+                }
+            }
+
+            return flag7;
+        }
+    }
+    
+    private int getCombinedLightUpMax(IEnviromentBlockReader reader, BlockPos pos)
+    {
+        int i = reader.getCombinedLight(pos, 0);
+        int j = reader.getCombinedLight(pos.up(), 0);
+        int k = i & 255;
+        int l = j & 255;
+        int i1 = i >> 16 & 255;
+        int j1 = j >> 16 & 255;
+        return (k > l ? k : l) | (i1 > j1 ? i1 : j1) << 16;
+    }
+
+    private boolean isBothWater(Fluid neighbour, Fluid fluid)
+    {
+        return FluidTags.WATER.contains(neighbour) && FluidTags.WATER.contains(fluid);
+    }
+    
+    private float getFluidHeight(IBlockReader reader, BlockPos pos, Fluid fluidIn)
+    {
+        int i = 0;
+        float f = 0.0F;
+
+        for(int j = 0; j < 4; ++j)
+        {
+            BlockPos blockpos = pos.add(-(j & 1), 0, -(j >> 1 & 1));
+            if(reader.getFluidState(blockpos.up()).getFluid().isEquivalentTo(fluidIn))
+            {
+                return 1.0F;
+            }
+
+            IFluidState ifluidstate = reader.getFluidState(blockpos);
+            if(ifluidstate.getFluid().isEquivalentTo(fluidIn) || isBothWater(ifluidstate.getFluid(), fluidIn))
+            {
+                float f1 = ifluidstate.func_215679_a(reader, blockpos);
+                if(f1 >= 0.8F)
+                {
+                    f += f1 * 10.0F;
+                    i += 10;
+                }
+                else
+                {
+                    f += f1;
+                    ++i;
+                }
+            }
+            else if(!reader.getBlockState(blockpos).getMaterial().isSolid())
+            {
+                ++i;
+            }
+        }
+
+        return f / (float) i;
+    }
+}

src/main/java/me/km/utils/ClientReflectionUtils.java

@@ -2,10 +2,12 @@ package me.km.utils;
 
 import java.lang.reflect.Field;
 import java.util.Map;
+import me.km.overrides.ModFluidBlockRenderer;
 import me.km.overrides.ModPlayerRenderer;
 import static me.km.utils.ReflectionUtils.getField;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.overlay.BossOverlayGui;
+import net.minecraft.client.renderer.BlockRendererDispatcher;
 import net.minecraft.client.renderer.entity.EntityRendererManager;
 import net.minecraft.client.renderer.entity.PlayerRenderer;
 import net.minecraftforge.api.distmarker.Dist;
@@ -36,14 +38,16 @@ public class ClientReflectionUtils
         
         ReflectionUtils.setFieldValue(erm, PLAYER_RENDERER, normal);
         Map<String, PlayerRenderer> map = 
-                ReflectionUtils.getFieldValue(Map.class, erm, SKIN_MAP);
-        
-        org.apache.logging.log4j.LogManager.getLogger().warn("______________________________________________");
-        org.apache.logging.log4j.LogManager.getLogger().warn(map);
-        
+                ReflectionUtils.getFieldValue(Map.class, erm, SKIN_MAP);       
         map.put("default", normal);
         map.put("slim", slim);
-
-        org.apache.logging.log4j.LogManager.getLogger().warn(map);
+    }
+    
+    private final static Field FLUID_RENDERER = getField(BlockRendererDispatcher.class, "field_175025_e"); // fluidRenderer
+    
+    public static void updateFluidRenderer()
+    {
+        ModFluidBlockRenderer mfbr = new ModFluidBlockRenderer();
+        ReflectionUtils.setFieldValue(Minecraft.getInstance().getBlockRendererDispatcher(), FLUID_RENDERER, mfbr);
     }
 }

src/main/resources/assets/km/lang/en_us.json

@@ -74,6 +74,14 @@
     "block.km.apricot_sapling": "Apricot Sapling", 
     "block.km.pear_sapling": "Pear Sapling", 
     "block.km.plum_sapling": "Plum Sapling", 
+    
+    "block.km.poison": "Poison",
+    "block.km.honey": "Honey",
+    "block.km.flowing_poison": "Flowing Poison",
+    "block.km.flowing_honey": "Flowing Honey",
+    
+    "item.km.poison_bucket": "Poison Bucket",
+    "item.km.honey_bucket": "Honey Bucket",
 
     "item.km.wooden_stick": "Wooden Stick", 
     "item.km.stone_stick": "Stone Stick", 

src/main/resources/assets/km/models/block/artefact.json

@@ -1,6 +1,6 @@
 {
     "textures": {
-        "particle": "km:block/honey_still"
+        "particle": "block/water_still"
     }
 }
 

src/main/resources/assets/km/models/block/poison.json

@@ -1,5 +1,5 @@
 {
     "textures": {
-        "particle": "km:block/poison_still"
+        "particle": "block/water_still"
     }
-}
+}

src/main/resources/assets/km/models/block/real_hay.json

@@ -0,0 +1,6 @@
+{
+    "parent": "item/generated",
+    "textures": {
+        "layer0": "km:item/honey_bucket"
+    }
+}

src/main/resources/assets/km/models/item/poison_bucket.json

@@ -0,0 +1,6 @@
+{
+    "parent": "item/generated",
+    "textures": {
+        "layer0": "km:item/poison_bucket"
+    }
+}

src/main/resources/assets/km/textures/block/honey_flow.png.mcmeta

@@ -1,3 +0,0 @@
-{
-  "animation": {}
-}

src/main/resources/assets/km/textures/block/honey_still.png.mcmeta

@@ -1,5 +0,0 @@
-{
-  "animation": {
-    "frametime": 2
-  }
-}

src/main/resources/assets/km/textures/block/poison_flow.png.mcmeta

@@ -1,3 +0,0 @@
-{
-  "animation": {}
-}

src/main/resources/assets/km/textures/block/poison_still.png.mcmeta

@@ -1,5 +0,0 @@
-{
-  "animation": {
-    "frametime": 2
-  }
-}