VisualOverhaul 3.0.0 - Puddles & Colors

Switched to MidnightConfig
(No need to seperately download AutoConfig & ClothConfig anymore)

Adds puddles which spawn during rain and can be used to fill a water bottle.
(Game rule: "puddleSpawnRate")
Also, snow layers can now pile up during snow storms.
(Game rule: "snowStackChance")

Items which are colored in their block form also show the color corresponding to the biome as an item. (Toggleable via config)

build.gradle

@@ -25,12 +25,6 @@ dependencies {
 
 	modCompile "net.fabricmc.fabric-api:fabric-api:${project.fabric_version}"
 	
-	modImplementation ("me.sargunvohra.mcmods:autoconfig1u:${project.auto_config_version}") {
-		exclude group: "net.fabricmc.fabric-api"
-	}
-	modImplementation ("me.shedaniel.cloth:config-2:${project.cloth_config_version}") {
-		exclude group: "net.fabricmc.fabric-api"
-	}
 	modImplementation ("io.github.prospector:modmenu:${project.mod_menu_version}") {
 		exclude group: "net.fabricmc.fabric-api"
 	}

gradle.properties

@@ -3,19 +3,17 @@ org.gradle.jvmargs=-Xmx1G
 
 # Fabric Properties
 	# check these on https://fabricmc.net/use
-	minecraft_version=1.16.4
-	yarn_mappings=1.16.4+build.7
-	loader_version=0.10.8
+	minecraft_version=1.16.5
+	yarn_mappings=1.16.5+build.3
+	loader_version=0.11.1
 
 # Mod Properties
-	mod_version = 1.0.0
+	mod_version = 3.0.0
 	maven_group = eu.midnightdust
 	archives_base_name = visualoverhaul
 
 # Dependencies
 	# currently not on the main fabric site, check on the maven: https://maven.fabricmc.net/net/fabricmc/fabric-api/fabric-api
-	fabric_version=0.28.4+1.16
+	fabric_version=0.29.4+1.16
 	
-	auto_config_version = 3.2.0-unstable
-	cloth_config_version = 4.7.0-unstable
 	mod_menu_version = 1.14.6+build.31

src/main/java/eu/midnightdust/visualoverhaul/VisualOverhaul.java

@@ -1,8 +1,33 @@
 package eu.midnightdust.visualoverhaul;
 
+import eu.midnightdust.visualoverhaul.block.PuddleBlock;
+import net.fabricmc.api.ModInitializer;
+import net.fabricmc.fabric.api.gamerule.v1.GameRuleFactory;
+import net.fabricmc.fabric.api.gamerule.v1.GameRuleRegistry;
+import net.fabricmc.fabric.api.object.builder.v1.block.FabricBlockSettings;
+import net.minecraft.block.Block;
+import net.minecraft.block.Material;
+import net.minecraft.fluid.Fluids;
+import net.minecraft.item.BlockItem;
+import net.minecraft.item.Item;
 import net.minecraft.util.Identifier;
+import net.minecraft.util.registry.Registry;
+import net.minecraft.world.GameRules;
+
+public class VisualOverhaul implements ModInitializer {
+    public static final String MOD_ID = "visualoverhaul";
+    public static final Block Puddle = new PuddleBlock(Fluids.WATER, FabricBlockSettings.of(Material.WATER));
+    public static GameRules.Key<GameRules.IntRule> PUDDLE_SPAWN_RATE;
+    public static GameRules.Key<GameRules.IntRule> SNOW_STACK_CHANCE;
 
-public class VisualOverhaul {
     public static final Identifier UPDATE_POTION_BOTTLES = new Identifier("visualoverhaul", "brewingstand");
     public static final Identifier UPDATE_RECORD = new Identifier("visualoverhaul", "record");
+    public static final Identifier UPDATE_FURNACE_ITEMS = new Identifier("visualoverhaul", "furnace");
+
+    public void onInitialize() {
+        PUDDLE_SPAWN_RATE = GameRuleRegistry.register("puddleSpawnRate", GameRules.Category.SPAWNING, GameRuleFactory.createIntRule(1));
+        SNOW_STACK_CHANCE = GameRuleRegistry.register("snowStackChance", GameRules.Category.SPAWNING, GameRuleFactory.createIntRule(1));
+        Registry.register(Registry.BLOCK, new Identifier(MOD_ID,"puddle"), Puddle);
+        Registry.register(Registry.ITEM, new Identifier(MOD_ID,"puddle"), new BlockItem(Puddle, new Item.Settings()));
+    }
 }

src/main/java/eu/midnightdust/visualoverhaul/VisualOverhaulClient.java

@@ -2,46 +2,63 @@ package eu.midnightdust.visualoverhaul;
 
 import eu.midnightdust.visualoverhaul.block.JukeboxTop;
 import eu.midnightdust.visualoverhaul.block.renderer.BrewingStandBlockEntityRenderer;
+import eu.midnightdust.visualoverhaul.block.renderer.FurnaceBlockEntityRenderer;
 import eu.midnightdust.visualoverhaul.block.renderer.JukeboxBlockEntityRenderer;
 import eu.midnightdust.visualoverhaul.config.VOConfig;
-import me.sargunvohra.mcmods.autoconfig1u.AutoConfig;
-import me.sargunvohra.mcmods.autoconfig1u.serializer.JanksonConfigSerializer;
 import net.fabricmc.api.ClientModInitializer;
+import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents;
 import net.fabricmc.fabric.api.client.rendereregistry.v1.BlockEntityRendererRegistry;
+import net.fabricmc.fabric.api.client.rendering.v1.ColorProviderRegistry;
 import net.fabricmc.fabric.api.object.builder.v1.client.model.FabricModelPredicateProviderRegistry;
 import net.fabricmc.fabric.api.resource.ResourceManagerHelper;
+import net.fabricmc.fabric.impl.blockrenderlayer.BlockRenderLayerMapImpl;
+import net.fabricmc.fabric.impl.client.rendering.ColorProviderRegistryImpl;
 import net.fabricmc.fabric.impl.networking.ClientSidePacketRegistryImpl;
 import net.fabricmc.loader.api.FabricLoader;
 import net.minecraft.block.Block;
+import net.minecraft.block.Blocks;
 import net.minecraft.block.entity.BlockEntityType;
 import net.minecraft.block.entity.BrewingStandBlockEntity;
+import net.minecraft.block.entity.FurnaceBlockEntity;
 import net.minecraft.block.entity.JukeboxBlockEntity;
 import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.render.RenderLayer;
 import net.minecraft.item.ItemStack;
+import net.minecraft.item.Items;
 import net.minecraft.item.MusicDiscItem;
+import net.minecraft.potion.PotionUtil;
+import net.minecraft.potion.Potions;
 import net.minecraft.util.Identifier;
 import net.minecraft.util.collection.DefaultedList;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.registry.Registry;
+import net.minecraft.world.biome.Biome;
+import net.minecraft.world.biome.BuiltinBiomes;
 
-import static eu.midnightdust.visualoverhaul.VisualOverhaul.UPDATE_POTION_BOTTLES;
-import static eu.midnightdust.visualoverhaul.VisualOverhaul.UPDATE_RECORD;
+import java.util.Objects;
 
+import static eu.midnightdust.visualoverhaul.VisualOverhaul.*;
+
+@SuppressWarnings("deprecation")
 public class VisualOverhaulClient implements ClientModInitializer {
-    public static VOConfig VO_CONFIG;
-    public static Block JukeBoxTop = new JukeboxTop();
 
+    public static Block JukeBoxTop = new JukeboxTop();
+    private final MinecraftClient client = MinecraftClient.getInstance();
 
     @Override
     public void onInitializeClient() {
-        AutoConfig.register(VOConfig.class, JanksonConfigSerializer::new);
-        VO_CONFIG = AutoConfig.getConfigHolder(VOConfig.class).getConfig();
+        VOConfig.init("visualoverhaul", VOConfig.class);
 
         // Block only registered on client, because it's just used for the renderer //
         Registry.register(Registry.BLOCK, new Identifier("visualoverhaul","jukebox_top"), JukeBoxTop);
 
+        BlockRenderLayerMapImpl.INSTANCE.putBlock(Blocks.JUKEBOX, RenderLayer.getCutout());
+        BlockRenderLayerMapImpl.INSTANCE.putBlock(JukeBoxTop, RenderLayer.getCutout());
+        BlockRenderLayerMapImpl.INSTANCE.putBlock(Blocks.FURNACE, RenderLayer.getCutout());
+
         BlockEntityRendererRegistry.INSTANCE.register(BlockEntityType.BREWING_STAND, BrewingStandBlockEntityRenderer::new);
         BlockEntityRendererRegistry.INSTANCE.register(BlockEntityType.JUKEBOX, JukeboxBlockEntityRenderer::new);
+        BlockEntityRendererRegistry.INSTANCE.register(BlockEntityType.FURNACE, FurnaceBlockEntityRenderer::new);
 
         Registry.ITEM.forEach((item) -> {
             if(item instanceof MusicDiscItem) {
@@ -57,12 +74,14 @@ public class VisualOverhaulClient implements ClientModInitializer {
                         inv.set(i, attachedData.readItemStack());
                     }
                     packetContext.getTaskQueue().execute(() -> {
-                        BrewingStandBlockEntity blockEntity = (BrewingStandBlockEntity) MinecraftClient.getInstance().world.getBlockEntity(pos);
-                        blockEntity.setStack(0,inv.get(0));
-                        blockEntity.setStack(1,inv.get(1));
-                        blockEntity.setStack(2,inv.get(2));
-                        blockEntity.setStack(3,inv.get(3));
-                        blockEntity.setStack(4,inv.get(4));
+                        if (client.world != null && client.world.getBlockEntity(pos) != null && client.world.getBlockEntity(pos) instanceof BrewingStandBlockEntity) {
+                            BrewingStandBlockEntity blockEntity = (BrewingStandBlockEntity) client.world.getBlockEntity(pos);
+                            blockEntity.setStack(0, inv.get(0));
+                            blockEntity.setStack(1, inv.get(1));
+                            blockEntity.setStack(2, inv.get(2));
+                            blockEntity.setStack(3, inv.get(3));
+                            blockEntity.setStack(4, inv.get(4));
+                        }
                     });
                 });
         ClientSidePacketRegistryImpl.INSTANCE.register(UPDATE_RECORD,
@@ -70,13 +89,68 @@ public class VisualOverhaulClient implements ClientModInitializer {
                     BlockPos pos = attachedData.readBlockPos();
                     ItemStack record = attachedData.readItemStack();
                     packetContext.getTaskQueue().execute(() -> {
-                        JukeboxBlockEntity blockEntity = (JukeboxBlockEntity)MinecraftClient.getInstance().world.getBlockEntity(pos);
-                        blockEntity.setRecord(record);
+                        if (client.world != null && client.world.getBlockEntity(pos) != null && client.world.getBlockEntity(pos) instanceof JukeboxBlockEntity) {
+                            JukeboxBlockEntity blockEntity = (JukeboxBlockEntity) client.world.getBlockEntity(pos);
+                            blockEntity.setRecord(record);
+                        }
+                    });
+                });
+        ClientSidePacketRegistryImpl.INSTANCE.register(UPDATE_FURNACE_ITEMS,
+                (packetContext, attachedData) -> {
+                    BlockPos pos = attachedData.readBlockPos();
+                    DefaultedList<ItemStack> inv = DefaultedList.ofSize(3, ItemStack.EMPTY);
+                    for (int i = 0; i < 2; i++) {
+                        inv.set(i, attachedData.readItemStack());
+                    }
+                    packetContext.getTaskQueue().execute(() -> {
+                        if (client.world != null && client.world.getBlockEntity(pos) != null && client.world.getBlockEntity(pos) instanceof FurnaceBlockEntity) {
+                            FurnaceBlockEntity blockEntity = (FurnaceBlockEntity) client.world.getBlockEntity(pos);
+                            blockEntity.setStack(0, inv.get(0));
+                            blockEntity.setStack(1, inv.get(1));
+                            blockEntity.setStack(2, inv.get(2));
+                        }
                     });
                 });
 
+        // Register builtin resourcepacks
         FabricLoader.getInstance().getModContainer("visualoverhaul").ifPresent(modContainer -> {
-            ResourceManagerHelper.registerBuiltinResourcePack(new Identifier("visualoverhaul:nobottles"), "resourcepacks/visualoverhaul", modContainer, true);
+            ResourceManagerHelper.registerBuiltinResourcePack(new Identifier("visualoverhaul:nobottles"), "resourcepacks/nobrewingbottles", modContainer, true);
+            ResourceManagerHelper.registerBuiltinResourcePack(new Identifier("visualoverhaul:fancyfurnace"), "resourcepacks/fancyfurnace", modContainer, true);
+            ResourceManagerHelper.registerBuiltinResourcePack(new Identifier("visualoverhaul:coloredwaterbucket"), "resourcepacks/coloredwaterbucket", modContainer, true);
         });
+
+        // Context Colored Items
+        if (VOConfig.coloredItems) {
+            ClientTickEvents.END_CLIENT_TICK.register(client -> {
+                int waterColor;
+                int foliageColor;
+                if (client.world != null) {
+                    Biome biome = client.world.getBiome(client.player.getBlockPos());
+                    waterColor = biome.getWaterColor();
+                    foliageColor = biome.getFoliageColor();
+                } else {
+                    waterColor = BuiltinBiomes.PLAINS.getWaterColor();
+                    foliageColor = BuiltinBiomes.PLAINS.getFoliageColor();
+                }
+                ColorProviderRegistry.ITEM.register((stack, tintIndex) -> waterColor, VisualOverhaul.Puddle);
+                ColorProviderRegistry.ITEM.register((stack, tintIndex) -> tintIndex == 0 ? -1 : waterColor, Items.WATER_BUCKET);
+                ColorProviderRegistry.ITEM.register((stack, tintIndex) -> foliageColor, Items.GRASS_BLOCK);
+                ColorProviderRegistry.ITEM.register((stack, tintIndex) -> foliageColor, Items.ACACIA_LEAVES);
+                ColorProviderRegistry.ITEM.register((stack, tintIndex) -> foliageColor, Items.DARK_OAK_LEAVES);
+                ColorProviderRegistry.ITEM.register((stack, tintIndex) -> foliageColor, Items.JUNGLE_LEAVES);
+                ColorProviderRegistry.ITEM.register((stack, tintIndex) -> foliageColor, Items.OAK_LEAVES);
+                ColorProviderRegistry.ITEM.register((stack, tintIndex) -> {
+                    if (PotionUtil.getPotion(stack) == Potions.WATER && tintIndex == 0) {
+                        return waterColor;
+                    }
+                    return tintIndex > 0 ? -1 : PotionUtil.getColor(stack);
+                }, Items.POTION);
+            });
+        }
+        // Else just register a static color for our puddle item
+        else {
+            ColorProviderRegistry.ITEM.register((stack, tintIndex) -> BuiltinBiomes.PLAINS.getWaterColor(), Puddle);
+        }
+        ColorProviderRegistry.BLOCK.register((state, view, pos, tintIndex) -> Objects.requireNonNull(ColorProviderRegistryImpl.BLOCK.get(Blocks.WATER)).getColor(state, view, pos, tintIndex), Puddle);
     }
 }

src/main/java/eu/midnightdust/visualoverhaul/block/PuddleBlock.java

@@ -0,0 +1,134 @@
+package eu.midnightdust.visualoverhaul.block;
+
+import net.fabricmc.api.EnvType;
+import net.fabricmc.api.Environment;
+import net.minecraft.block.*;
+import net.minecraft.entity.ai.pathing.NavigationType;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.fluid.*;
+import net.minecraft.item.*;
+import net.minecraft.loot.context.LootContext;
+import net.minecraft.potion.PotionUtil;
+import net.minecraft.potion.Potions;
+import net.minecraft.server.network.ServerPlayerEntity;
+import net.minecraft.server.world.ServerWorld;
+import net.minecraft.sound.BlockSoundGroup;
+import net.minecraft.sound.SoundCategory;
+import net.minecraft.sound.SoundEvents;
+import net.minecraft.stat.Stats;
+import net.minecraft.util.ActionResult;
+import net.minecraft.util.Hand;
+import net.minecraft.util.hit.BlockHitResult;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Direction;
+import net.minecraft.util.shape.VoxelShape;
+import net.minecraft.util.shape.VoxelShapes;
+import net.minecraft.world.BlockView;
+import net.minecraft.world.World;
+import net.minecraft.world.WorldAccess;
+import net.minecraft.world.WorldView;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Random;
+
+public class PuddleBlock extends Block {
+
+    protected final FlowableFluid fluid;
+    public static final VoxelShape COLLISION_SHAPE;
+
+    public PuddleBlock(FlowableFluid fluid, AbstractBlock.Settings settings) {
+        super(settings);
+        this.fluid = fluid;
+    }
+    @Override
+    public ActionResult onUse(BlockState state, World world, BlockPos pos, PlayerEntity player, Hand hand, BlockHitResult hit) {
+        ItemStack itemStack = player.getStackInHand(hand);
+        if (itemStack.isEmpty()) {
+            return ActionResult.PASS;
+        } else {
+            Item item = itemStack.getItem();
+            ItemStack waterBottleStack;
+            if (item == Items.GLASS_BOTTLE) {
+                if (!world.isClient) {
+                    if (!player.abilities.creativeMode) {
+                        waterBottleStack = PotionUtil.setPotion(new ItemStack(Items.POTION), Potions.WATER);
+                        player.incrementStat(Stats.USE_CAULDRON);
+                        itemStack.decrement(1);
+                        if (itemStack.isEmpty()) {
+                            player.setStackInHand(hand, waterBottleStack);
+                        } else if (!player.inventory.insertStack(waterBottleStack)) {
+                            player.dropItem(waterBottleStack, false);
+                        } else if (player instanceof ServerPlayerEntity) {
+                            ((ServerPlayerEntity)player).refreshScreenHandler(player.playerScreenHandler);
+                        }
+                    }
+
+                    world.playSound(null, pos, SoundEvents.ITEM_BOTTLE_FILL, SoundCategory.BLOCKS, 1.0F, 1.0F);
+                    world.setBlockState(pos, Blocks.AIR.getDefaultState());
+                }
+                return ActionResult.success(world.isClient);
+            }
+            else return ActionResult.FAIL;
+        }
+
+    }
+    @Override
+    public boolean hasRandomTicks(BlockState state) {
+        return true;
+    }
+    @Override
+    public void randomTick(BlockState state, ServerWorld world, BlockPos pos, Random random) {
+        if (!world.isRaining() && random.nextInt(2000) == 0) {
+            world.setBlockState(pos, Blocks.AIR.getDefaultState());
+        }
+
+        this.scheduledTick(state, world, pos, random);
+    }
+
+    @Override
+    public VoxelShape getCollisionShape(BlockState state, BlockView world, BlockPos pos, ShapeContext context) {
+        return context.isAbove(COLLISION_SHAPE, pos, true) ? COLLISION_SHAPE : VoxelShapes.empty();
+    }
+    @Override
+    public VoxelShape getOutlineShape(BlockState state, BlockView world, BlockPos pos, ShapeContext context) {
+        return  COLLISION_SHAPE;
+    }
+    @Override
+    public VoxelShape getCullingShape(BlockState state, BlockView world, BlockPos pos) {
+        return VoxelShapes.empty();
+    }
+
+    public boolean canPathfindThrough(BlockState state, BlockView world, BlockPos pos, NavigationType type) {
+        return true;
+    }
+
+    public FluidState getFluidState(BlockState state) {
+        return fluid.getFlowing(1,false);
+    }
+
+    @Environment(EnvType.CLIENT)
+    public boolean isSideInvisible(BlockState state, BlockState stateFrom, Direction direction) {
+        return stateFrom.getFluidState().getFluid().matchesType(this.fluid);
+    }
+
+    public BlockRenderType getRenderType(BlockState state) {
+        return BlockRenderType.INVISIBLE;
+    }
+
+    public List<ItemStack> getDroppedStacks(BlockState state, LootContext.Builder builder) {
+        return Collections.emptyList();
+    }
+
+    public boolean canPlaceAt(BlockState state, WorldView world, BlockPos pos) {
+        return world.getBlockState(pos.down()).isSideSolidFullSquare(world,pos,Direction.UP);
+    }
+    public BlockState getStateForNeighborUpdate(BlockState state, Direction direction, BlockState newState, WorldAccess world, BlockPos pos, BlockPos posFrom) {
+        return !state.canPlaceAt(world, pos) ? Blocks.AIR.getDefaultState() : super.getStateForNeighborUpdate(state, direction, newState, world, pos, posFrom);
+    }
+
+    static {
+        COLLISION_SHAPE = net.minecraft.block.Block.createCuboidShape(0.0D, 0.0D, 0.0D, 16.0D, 0.5D, 16.0D);
+    }
+}
+

src/main/java/eu/midnightdust/visualoverhaul/block/renderer/BrewingStandBlockEntityRenderer.java

@@ -1,7 +1,6 @@
 package eu.midnightdust.visualoverhaul.block.renderer;
 
-import eu.midnightdust.visualoverhaul.VisualOverhaul;
-import eu.midnightdust.visualoverhaul.VisualOverhaulClient;
+import eu.midnightdust.visualoverhaul.config.VOConfig;
 import net.fabricmc.api.EnvType;
 import net.fabricmc.api.Environment;
 import net.minecraft.block.entity.BrewingStandBlockEntity;
@@ -26,7 +25,7 @@ public class BrewingStandBlockEntityRenderer extends BlockEntityRenderer<Brewing
     @Override
     public void render(BrewingStandBlockEntity blockEntity, float tickDelta, MatrixStack matrices, VertexConsumerProvider vertexConsumers, int light, int overlay) {
 
-        if (VisualOverhaulClient.VO_CONFIG.brewingstand) {
+        if (VOConfig.brewingstand) {
             int lightAtBlock = WorldRenderer.getLightmapCoordinates(blockEntity.getWorld(), blockEntity.getPos());
             ItemStack item1 = blockEntity.getStack(0);
             ItemStack item2 = blockEntity.getStack(1);

src/main/java/eu/midnightdust/visualoverhaul/block/renderer/FurnaceBlockEntityRenderer.java

@@ -0,0 +1,116 @@
+package eu.midnightdust.visualoverhaul.block.renderer;
+
+import eu.midnightdust.visualoverhaul.config.VOConfig;
+import net.fabricmc.api.EnvType;
+import net.fabricmc.api.Environment;
+import net.minecraft.block.*;
+import net.minecraft.block.entity.FurnaceBlockEntity;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.model.ModelPart;
+import net.minecraft.client.render.RenderLayer;
+import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.render.VertexConsumerProvider;
+import net.minecraft.client.render.WorldRenderer;
+import net.minecraft.client.render.block.entity.BlockEntityRenderDispatcher;
+import net.minecraft.client.render.block.entity.BlockEntityRenderer;
+import net.minecraft.client.render.model.json.ModelTransformation;
+import net.minecraft.client.texture.Sprite;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.client.util.math.Vector3f;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tag.ItemTags;
+import net.minecraft.util.Identifier;
+
+@Environment(EnvType.CLIENT)
+public class FurnaceBlockEntityRenderer extends BlockEntityRenderer<FurnaceBlockEntity> {
+    private static final ModelPart bb_main;
+    private static final ModelPart cube_r1;
+    private static final ModelPart cube_r2;
+    private static final ModelPart cube_r3;
+
+    static  {
+        bb_main = new ModelPart(16, 16, 0, 0);
+        bb_main.setPivot(0.0F, 24.0F, 0.0F);
+
+        cube_r1 = new ModelPart(16, 16, 0, 0);
+        cube_r1.setPivot(6.0F, 1.0F, -2.0F);
+        bb_main.addChild(cube_r1);
+        setRotationAngle(cube_r1, 0.0F, -0.5672F, 0.0F);
+        cube_r1.setTextureOffset(0, 0).addCuboid(-10.0F, -3.0F, 0.0F, 10.0F, 1.0F, 1.0F, 0.0F, false);
+
+        cube_r2 = new ModelPart(16, 16, 0, 0);
+        cube_r2.setPivot(5.0F, 0.0F, -5.0F);
+        bb_main.addChild(cube_r2);
+        setRotationAngle(cube_r2, 0.0F, -0.1309F, 0.0F);
+        cube_r2.setTextureOffset(0, 0).addCuboid(-10.0F, -2.5F, 0.0F, 10.0F, 2.0F, 2.0F, 0.0F, false);
+
+        cube_r3 = new ModelPart(16, 16, 0, 0);
+        cube_r3.setPivot(5.0F, -1.0F, -7.0F);
+        bb_main.addChild(cube_r3);
+        setRotationAngle(cube_r3, 0.0F, 0.2618F, 0.0F);
+        cube_r3.setTextureOffset(0, 0).addCuboid(-10.0F, -2.0F, 0.0F, 10.0F, 2.0F, 2.0F, 0.0F, false);
+    }
+    public static void setRotationAngle(ModelPart bone, float x, float y, float z) {
+        bone.pitch = x;
+        bone.yaw = y;
+        bone.roll = z;
+    }
+
+    public FurnaceBlockEntityRenderer(BlockEntityRenderDispatcher blockEntityRenderDispatcher) {
+        super(blockEntityRenderDispatcher);
+    }
+
+    @Override
+    public void render(FurnaceBlockEntity blockEntity, float tickDelta, MatrixStack matrices, VertexConsumerProvider vertexConsumers, int light, int overlay) {
+        if (VOConfig.furnace && blockEntity.getCachedState().getBlock().is(Blocks.FURNACE)) {
+            BlockState blockState = blockEntity.getCachedState();
+            int lightAtBlock = WorldRenderer.getLightmapCoordinates(blockEntity.getWorld(), blockEntity.getPos().offset(blockState.get(AbstractFurnaceBlock.FACING)));
+            ItemStack item1 = blockEntity.getStack(0);
+            ItemStack item2 = blockEntity.getStack(1);
+            float angle = (blockState.get(AbstractFurnaceBlock.FACING)).asRotation();
+
+            matrices.push();
+
+            matrices.translate(0.5f, 0.58f, 0.5f);
+            matrices.scale(1f, 1f, 1f);
+            matrices.multiply(Vector3f.POSITIVE_Y.getDegreesQuaternion(angle * 3 + 180));
+            matrices.translate(0.0f, 0.0f, -0.4f);
+            matrices.multiply(Vector3f.POSITIVE_X.getDegreesQuaternion(90));
+            MinecraftClient.getInstance().getItemRenderer().renderItem(item1, ModelTransformation.Mode.GROUND, lightAtBlock, overlay, matrices, vertexConsumers);
+
+
+            matrices.pop();
+            if (!item2.getItem().isIn(ItemTags.LOGS_THAT_BURN) && !item2.getItem().isIn(ItemTags.PLANKS)) {
+                matrices.push();
+
+                matrices.translate(0.5f, 0.08f, 0.5f);
+                matrices.scale(1f, 1f, 1f);
+                matrices.multiply(Vector3f.POSITIVE_Y.getDegreesQuaternion(angle * 3 + 180));
+                matrices.translate(0.0f, 0.0f, -0.4f);
+                matrices.multiply(Vector3f.POSITIVE_X.getDegreesQuaternion(90));
+                MinecraftClient.getInstance().getItemRenderer().renderItem(item2, ModelTransformation.Mode.GROUND, lightAtBlock, overlay, matrices, vertexConsumers);
+
+                matrices.pop();
+            }
+            if (item2.getItem().isIn(ItemTags.LOGS_THAT_BURN) || item2.getItem().isIn(ItemTags.PLANKS)) {
+                matrices.push();
+                BlockState state = Block.getBlockFromItem(item2.getItem()).getDefaultState();
+                Sprite texture = MinecraftClient.getInstance().getBlockRenderManager().getModel(state).getSprite();
+                VertexConsumer vertexConsumer = vertexConsumers.getBuffer(RenderLayer.getEntityCutoutNoCull(spriteToTexture(texture)));
+
+                matrices.translate(0.5f, -1.3f, 0.5f);
+                matrices.scale(1f, 1f, 1f);
+
+
+                matrices.multiply(Vector3f.POSITIVE_Y.getDegreesQuaternion(angle * 3 + 180));
+                bb_main.render(matrices, vertexConsumer, lightAtBlock, overlay);
+                matrices.pop();
+            }
+        }
+
+    }
+    public static Identifier spriteToTexture(Sprite sprite) {
+        String texture = sprite.getId().getPath();
+        return new Identifier(sprite.getId().getNamespace(), "textures/" + texture + ".png");
+    }
+}

src/main/java/eu/midnightdust/visualoverhaul/block/renderer/JukeboxBlockEntityRenderer.java

@@ -1,6 +1,7 @@
 package eu.midnightdust.visualoverhaul.block.renderer;
 
 import eu.midnightdust.visualoverhaul.VisualOverhaulClient;
+import eu.midnightdust.visualoverhaul.config.VOConfig;
 import net.fabricmc.api.EnvType;
 import net.fabricmc.api.Environment;
 import net.minecraft.block.entity.JukeboxBlockEntity;
@@ -28,7 +29,7 @@ public class JukeboxBlockEntityRenderer extends BlockEntityRenderer<JukeboxBlock
     @Override
     public void render(JukeboxBlockEntity blockEntity, float tickDelta, MatrixStack matrices, VertexConsumerProvider vertexConsumers, int light, int overlay) {
 
-        if (VisualOverhaulClient.VO_CONFIG.jukebox) {
+        if (VOConfig.jukebox) {
             int lightAbove = WorldRenderer.getLightmapCoordinates(blockEntity.getWorld(), blockEntity.getPos().up());
             ItemStack record = blockEntity.getRecord();
             record.setCount(2);
@@ -41,7 +42,7 @@ public class JukeboxBlockEntityRenderer extends BlockEntityRenderer<JukeboxBlock
             MinecraftClient.getInstance().getItemRenderer().renderItem(record, ModelTransformation.Mode.GROUND, lightAbove, overlay, matrices, vertexConsumers);
 
             matrices.pop();
-            if (VisualOverhaulClient.VO_CONFIG.jukebox_fake_block) {
+            if (VOConfig.jukebox_fake_block) {
                 matrices.push();
                 matrices.translate(0f, 1f, 0f);
                 if (record == ItemStack.EMPTY) {

src/main/java/eu/midnightdust/visualoverhaul/config/MidnightConfig.java

@@ -0,0 +1,288 @@
+package eu.midnightdust.visualoverhaul.config;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import net.fabricmc.loader.api.FabricLoader;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.client.gui.screen.ScreenTexts;
+import net.minecraft.client.gui.widget.ButtonWidget;
+import net.minecraft.client.gui.widget.TextFieldWidget;
+import net.minecraft.client.resource.language.I18n;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.text.*;
+import net.minecraft.util.Formatting;
+
+import java.lang.annotation.*;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.*;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.regex.Pattern;
+
+// MidnightConfig v0.1.0 //
+
+/* Based on https://github.com/Minenash/TinyConfig
+   Credits to Minenash - CC0-1.0
+   You can copy this class to get a standalone version of MidnightConfig */
+
+@SuppressWarnings("rawtypes")
+public class MidnightConfig {
+
+    private static final Pattern INTEGER_ONLY = Pattern.compile("(-?[0-9]*)");
+    private static final Pattern DECIMAL_ONLY = Pattern.compile("-?([\\d]+\\.?[\\d]*|[\\d]*\\.?[\\d]+|\\.)");
+
+    private static final List<EntryInfo> entries = new ArrayList<>();
+
+    protected static class EntryInfo {
+        Field field;
+        Object widget;
+        int width;
+        Method dynamicTooltip;
+        Map.Entry<TextFieldWidget,Text> error;
+        Object defaultValue;
+        Object value;
+        String tempValue;
+        boolean inLimits = true;
+    }
+
+    private static Class configClass;
+    private static String translationPrefix;
+    private static Path path;
+
+    private static final Gson gson = new GsonBuilder()
+            .excludeFieldsWithModifiers(Modifier.TRANSIENT)
+            .excludeFieldsWithModifiers(Modifier.PRIVATE)
+            .setPrettyPrinting()
+            .create();
+
+    public static void init(String modid, Class<?> config) {
+        translationPrefix = modid + ".midnightconfig.";
+        path = FabricLoader.getInstance().getConfigDir().resolve(modid + ".json");
+        configClass = config;
+
+        for (Field field : config.getFields()) {
+            Class<?> type = field.getType();
+            EntryInfo info = new EntryInfo();
+
+            Entry e;
+            try { e = field.getAnnotation(Entry.class); }
+            catch (Exception ignored) { continue; }
+
+            info.width = e.width();
+            info.field = field;
+
+            if (type == int.class)         textField(info, Integer::parseInt, INTEGER_ONLY, e.min(), e.max(), true);
+            else if (type == double.class) textField(info, Double::parseDouble, DECIMAL_ONLY, e.min(), e.max(),false);
+            else if (type == String.class) textField(info, String::length, null, Math.min(e.min(),0), Math.max(e.max(),1),true);
+            else if (type == boolean.class) {
+                Function<Object,Text> func = value -> new LiteralText((Boolean) value ? "True" : "False").formatted((Boolean) value ? Formatting.GREEN : Formatting.RED);
+                info.widget = new AbstractMap.SimpleEntry<ButtonWidget.PressAction, Function<Object, Text>>(button -> {
+                    info.value = !(Boolean) info.value;
+                    button.setMessage(func.apply(info.value));
+                }, func);
+            }
+            else if (type.isEnum()) {
+                List<?> values = Arrays.asList(field.getType().getEnumConstants());
+                Function<Object,Text> func = value -> new TranslatableText(translationPrefix + "enum." + type.getSimpleName() + "." + info.value.toString());
+                info.widget = new AbstractMap.SimpleEntry<ButtonWidget.PressAction, Function<Object,Text>>( button -> {
+                    int index = values.indexOf(info.value) + 1;
+                    info.value = values.get(index >= values.size()? 0 : index);
+                    button.setMessage(func.apply(info.value));
+                }, func);
+            }
+            else
+                continue;
+
+            entries.add(info);
+
+            try { info.defaultValue = field.get(null); }
+            catch (IllegalAccessException ignored) {}
+
+            try {
+                info.dynamicTooltip = config.getMethod(e.dynamicTooltip());
+                info.dynamicTooltip.setAccessible(true);
+            } catch (Exception ignored) {}
+
+        }
+
+        try { gson.fromJson(Files.newBufferedReader(path), config); }
+        catch (Exception e) { write(); }
+
+        for (EntryInfo info : entries) {
+            try {
+                info.value = info.field.get(null);
+                info.tempValue = info.value.toString();
+            }
+            catch (IllegalAccessException ignored) {}
+        }
+
+    }
+
+    private static void textField(EntryInfo info, Function<String,Number> f, Pattern pattern, double min, double max, boolean cast) {
+        boolean isNumber = pattern != null;
+        info.widget = (BiFunction<TextFieldWidget, ButtonWidget, Predicate<String>>) (t, b) -> s -> {
+            s = s.trim();
+            if (!(s.isEmpty() || !isNumber || pattern.matcher(s).matches()))
+                return false;
+
+            Number value = 0;
+            boolean inLimits = false;
+            System.out.println(((isNumber ^ s.isEmpty())));
+            System.out.println(!s.equals("-") && !s.equals("."));
+            info.error = null;
+            if (!(isNumber && s.isEmpty()) && !s.equals("-") && !s.equals(".")) {
+                value = f.apply(s);
+                inLimits = value.doubleValue() >= min && value.doubleValue() <= max;
+                info.error = inLimits? null : new AbstractMap.SimpleEntry<>(t, new LiteralText(value.doubleValue() < min ?
+                        "§cMinimum " + (isNumber? "value" : "length") + (cast? " is " + (int)min : " is " + min) :
+                        "§cMaximum " + (isNumber? "value" : "length") + (cast? " is " + (int)max : " is " + max)));
+            }
+
+            info.tempValue = s;
+            t.setEditableColor(inLimits? 0xFFFFFFFF : 0xFFFF7777);
+            info.inLimits = inLimits;
+            b.active = entries.stream().allMatch(e -> e.inLimits);
+
+            if (inLimits)
+                info.value = isNumber? value : s;
+
+            return true;
+        };
+    }
+
+    public static void write() {
+        try {
+            if (!Files.exists(path)) Files.createFile(path);
+            Files.write(path, gson.toJson(configClass.newInstance()).getBytes());
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+    }
+
+    public Screen getScreen(Screen parent) {
+        return new TinyConfigScreen(parent);
+    }
+
+    private static class TinyConfigScreen extends Screen {
+        protected TinyConfigScreen(Screen parent) {
+            super(new TranslatableText(MidnightConfig.translationPrefix + "title"));
+            this.parent = parent;
+        }
+        private final Screen parent;
+
+        // Real Time config update //
+        @Override
+        public void tick() {
+            for (EntryInfo info : entries)
+                try { info.field.set(null, info.value); }
+                catch (IllegalAccessException ignore) {}
+        }
+
+        @Override
+        protected void init() {
+            super.init();
+            this.addButton(new ButtonWidget(this.width / 2 - 154, this.height - 28, 150, 20, ScreenTexts.CANCEL, button -> {
+                try { gson.fromJson(Files.newBufferedReader(path), configClass); }
+                catch (Exception e) { write(); }
+
+                for (EntryInfo info : entries) {
+                    try {
+                        info.value = info.field.get(null);
+                        info.tempValue = info.value.toString();
+                    }
+                    catch (IllegalAccessException ignored) {}
+                }
+                    Objects.requireNonNull(client).openScreen(parent);
+            }));
+
+            ButtonWidget done = this.addButton(new ButtonWidget(this.width / 2 + 4, this.height - 28, 150, 20, ScreenTexts.DONE, (button) -> {
+                for (EntryInfo info : entries)
+                    try { info.field.set(null, info.value); }
+                    catch (IllegalAccessException ignore) {}
+                write();
+                Objects.requireNonNull(client).openScreen(parent);
+            }));
+
+            int y = 45;
+            for (EntryInfo info : entries) {
+                addButton(new ButtonWidget(width - 155, y, 40,20, new LiteralText("Reset").formatted(Formatting.RED), (button -> {
+                    info.value = info.defaultValue;
+                    info.tempValue = info.value.toString();
+                    Objects.requireNonNull(client).openScreen(this);
+                })));
+
+                if (info.widget instanceof Map.Entry) {
+                    Map.Entry<ButtonWidget.PressAction,Function<Object,Text>> widget = (Map.Entry<ButtonWidget.PressAction, Function<Object, Text>>) info.widget;
+                    addButton(new ButtonWidget(width-110,y,info.width,20, widget.getValue().apply(info.value), widget.getKey()));
+                }
+                else {
+                    TextFieldWidget widget = addButton(new TextFieldWidget(textRenderer, width-110, y, info.width, 20, null));
+                    widget.setText(info.tempValue);
+
+                    Predicate<String> processor = ((BiFunction<TextFieldWidget, ButtonWidget, Predicate<String>>) info.widget).apply(widget,done);
+                    widget.setTextPredicate(processor);
+
+                    children.add(widget);
+                }
+                y += 25;
+            }
+
+        }
+        int aniX = this.width / 2;
+        @Override
+        public void render(MatrixStack matrices, int mouseX, int mouseY, float delta) {
+            this.renderBackground(matrices);
+
+            if (aniX < this.width / 2) {
+                aniX = aniX +40;
+            }
+
+            int stringWidth = (int) (title.getString().length() * 2.75f);
+            this.fillGradient(matrices, this.width / 2 - stringWidth, 10, this.width /2 + stringWidth, 29, -1072689136, -804253680);
+            this.fillGradient(matrices, this.width / 2 - aniX, 35, width/2 + aniX, this.height - 40, -1072689136, -804253680);
+
+            super.render(matrices, mouseX, mouseY, delta);
+            drawCenteredText(matrices, textRenderer, title, width/2, 15, 0xFFFFFF);
+
+            int y = 40;
+            for (EntryInfo info : entries) {
+                drawTextWithShadow(matrices, textRenderer, new TranslatableText(translationPrefix + info.field.getName()), 12, y + 10, 0xFFFFFF);
+
+                if (info.error != null && info.error.getKey().isMouseOver(mouseX,mouseY))
+                    renderTooltip(matrices, info.error.getValue(), mouseX, mouseY);
+                else if (mouseY >= y && mouseY < (y + 25)) {
+                    if (info.dynamicTooltip != null) {
+                        try {
+                            renderTooltip(matrices, (List<Text>) info.dynamicTooltip.invoke(null, entries), mouseX, mouseY);
+                            y += 25;
+                            continue;
+                        } catch (Exception e) { e.printStackTrace(); }
+                    }
+                    String key = translationPrefix + info.field.getName() + ".tooltip";
+                    if (I18n.hasTranslation(key)) {
+                        List<Text> list = new ArrayList<>();
+                        for (String str : I18n.translate(key).split("\n"))
+                            list.add(new LiteralText(str));
+                        renderTooltip(matrices, list, mouseX, mouseY);
+                    }
+                }
+                y += 25;
+            }
+        }
+    }
+
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target(ElementType.FIELD)
+    public @interface Entry {
+        String dynamicTooltip() default "";
+        int width() default 100;
+        double min() default Double.MIN_NORMAL;
+        double max() default Double.MAX_VALUE;
+    }
+}

src/main/java/eu/midnightdust/visualoverhaul/config/ModMenuIntegration.java

@@ -2,7 +2,6 @@ package eu.midnightdust.visualoverhaul.config;
 
 import io.github.prospector.modmenu.api.ConfigScreenFactory;
 import io.github.prospector.modmenu.api.ModMenuApi;
-import me.sargunvohra.mcmods.autoconfig1u.AutoConfig;
 import net.fabricmc.api.EnvType;
 import net.fabricmc.api.Environment;
 
@@ -11,6 +10,6 @@ public class ModMenuIntegration implements ModMenuApi {
 
     @Override
     public ConfigScreenFactory<?> getModConfigScreenFactory() {
-        return parent -> AutoConfig.getConfigScreen(VOConfig.class, parent).get();
+        return parent -> new VOConfig().getScreen(parent);
     }
 }

src/main/java/eu/midnightdust/visualoverhaul/config/VOConfig.java

@@ -1,16 +1,14 @@
 package eu.midnightdust.visualoverhaul.config;
 
-import me.sargunvohra.mcmods.autoconfig1u.ConfigData;
-import me.sargunvohra.mcmods.autoconfig1u.annotation.Config;
-import me.sargunvohra.mcmods.autoconfig1u.shadowed.blue.endless.jankson.Comment;
-
-import java.util.ArrayList;
-import java.util.List;
-
-@Config(name = "visualoverhaul")
-public class VOConfig implements ConfigData {
-
-    public boolean brewingstand = true;
-    public boolean jukebox = true;
-    public boolean jukebox_fake_block = true;
+public class VOConfig extends MidnightConfig {
+    @Entry
+    public static boolean brewingstand = true;
+    @Entry
+    public static boolean jukebox = true;
+    @Entry
+    public static boolean jukebox_fake_block = true;
+    @Entry
+    public static boolean furnace = true;
+    @Entry
+    public static boolean coloredItems = true;
 }

src/main/java/eu/midnightdust/visualoverhaul/mixin/MixinAbstractFurnaceBlockEntity.java

@@ -0,0 +1,56 @@
+package eu.midnightdust.visualoverhaul.mixin;
+
+import eu.midnightdust.visualoverhaul.VisualOverhaul;
+import io.netty.buffer.Unpooled;
+import net.fabricmc.fabric.api.server.PlayerStream;
+import net.fabricmc.fabric.impl.networking.ServerSidePacketRegistryImpl;
+import net.minecraft.block.Blocks;
+import net.minecraft.block.entity.*;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.network.PacketByteBuf;
+import net.minecraft.util.collection.DefaultedList;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+import java.util.stream.Stream;
+
+@Mixin(AbstractFurnaceBlockEntity.class)
+public abstract class MixinAbstractFurnaceBlockEntity extends LockableContainerBlockEntity {
+
+    @Shadow protected DefaultedList<ItemStack> inventory;
+    Boolean invUpdate = true;
+    int playerUpdate = -1;
+
+    private MixinAbstractFurnaceBlockEntity(BlockEntityType<?> blockEntityType) {
+        super(blockEntityType);
+    }
+
+    @Inject(at = @At("TAIL"), method = "tick")
+    public void tick(CallbackInfo ci) {
+        if (this.world.getBlockState(this.pos).getBlock().is(Blocks.FURNACE)) {
+            if (!this.world.isClient && (invUpdate || world.getPlayers().size() == playerUpdate)) {
+                Stream<PlayerEntity> watchingPlayers = PlayerStream.watching(world, getPos());
+                PacketByteBuf passedData = new PacketByteBuf(Unpooled.buffer());
+                passedData.writeBlockPos(pos);
+                passedData.writeItemStack(inventory.get(0));
+                passedData.writeItemStack(inventory.get(1));
+                passedData.writeItemStack(inventory.get(2));
+
+                passedData.writeString(String.valueOf(inventory));
+                watchingPlayers.forEach(player -> ServerSidePacketRegistryImpl.INSTANCE.sendToPlayer(player, VisualOverhaul.UPDATE_FURNACE_ITEMS, passedData));
+                invUpdate = false;
+            }
+            playerUpdate = world.getPlayers().size();
+        }
+    }
+
+    @Inject(at = @At("RETURN"), method = "getStack", cancellable = true)
+    public void getStack(int slot, CallbackInfoReturnable cir) {
+        this.invUpdate = true;
+    }
+}

src/main/java/eu/midnightdust/visualoverhaul/mixin/MixinBrewingStandBlockEntity.java

@@ -23,25 +23,17 @@ import java.util.stream.Stream;
 @Mixin(BrewingStandBlockEntity.class)
 public abstract class MixinBrewingStandBlockEntity extends LockableContainerBlockEntity {
 
-
     @Shadow private DefaultedList<ItemStack> inventory;
-    public ItemStack item1;
-    public ItemStack item2;
-    public ItemStack item3;
-    Boolean sendData = true;
+    Boolean invUpdate = true;
+    int playerUpdate = -1;
 
     private MixinBrewingStandBlockEntity(BlockEntityType<?> blockEntityType) {
         super(blockEntityType);
-
     }
 
     @Inject(at = @At("TAIL"), method = "tick")
     public void tick(CallbackInfo ci) {
-        item1 = inventory.get(0);
-        item2 = inventory.get(1);
-        item3 = inventory.get(2);
-
-        if (!this.world.isClient) {
+        if (!this.world.isClient && (invUpdate || world.getPlayers().size() == playerUpdate)) {
             Stream<PlayerEntity> watchingPlayers = PlayerStream.watching(world, getPos());
             PacketByteBuf passedData = new PacketByteBuf(Unpooled.buffer());
             passedData.writeBlockPos(pos);
@@ -53,12 +45,13 @@ public abstract class MixinBrewingStandBlockEntity extends LockableContainerBloc
 
             passedData.writeString(String.valueOf(inventory));
             watchingPlayers.forEach(player -> ServerSidePacketRegistryImpl.INSTANCE.sendToPlayer(player, VisualOverhaul.UPDATE_POTION_BOTTLES, passedData));
-            sendData = false;
+            invUpdate = false;
         }
+        playerUpdate = world.getPlayers().size();
     }
 
     @Inject(at = @At("RETURN"), method = "getStack", cancellable = true)
     public void getStack(int slot, CallbackInfoReturnable cir) {
-        this.sendData = true;
+        this.invUpdate = true;
     }
 }

src/main/java/eu/midnightdust/visualoverhaul/mixin/MixinJukeboxBlockEntity.java

@@ -21,30 +21,30 @@ import java.util.stream.Stream;
 @Mixin(JukeboxBlockEntity.class)
 public abstract class MixinJukeboxBlockEntity extends BlockEntity implements Tickable {
 
-
     @Shadow private ItemStack record;
-    Boolean sendData = true;
+    Boolean invUpdate = true;
+    int playerUpdate = -1;
 
     private MixinJukeboxBlockEntity(BlockEntityType<?> blockEntityType) {
         super(blockEntityType);
-
     }
 
     @Unique
     public void tick() {
-        if (!this.world.isClient) {
+        if (!this.world.isClient && (invUpdate || world.getPlayers().size() == playerUpdate)) {
             Stream<PlayerEntity> watchingPlayers = PlayerStream.watching(world, getPos());
             PacketByteBuf passedData = new PacketByteBuf(Unpooled.buffer());
             passedData.writeBlockPos(pos);
             passedData.writeItemStack(record);
 
             watchingPlayers.forEach(player -> ServerSidePacketRegistryImpl.INSTANCE.sendToPlayer(player, VisualOverhaul.UPDATE_RECORD, passedData));
-            sendData = false;
+            invUpdate = false;
         }
+        playerUpdate = world.getPlayers().size();
     }
 
     @Inject(at = @At("RETURN"), method = "getRecord", cancellable = true)
     public void getRecord(CallbackInfoReturnable cir) {
-        this.sendData = true;
+        this.invUpdate = true;
     }
 }

src/main/java/eu/midnightdust/visualoverhaul/mixin/MixinServerWorld.java

@@ -0,0 +1,63 @@
+package eu.midnightdust.visualoverhaul.mixin;
+
+import eu.midnightdust.visualoverhaul.VisualOverhaul;
+import net.minecraft.block.Blocks;
+import net.minecraft.server.world.ServerWorld;
+import net.minecraft.state.property.Properties;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.ChunkPos;
+import net.minecraft.util.math.Direction;
+import net.minecraft.util.profiler.Profiler;
+import net.minecraft.util.registry.RegistryKey;
+import net.minecraft.world.*;
+import net.minecraft.world.chunk.WorldChunk;
+import net.minecraft.world.dimension.DimensionType;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+import java.util.function.Supplier;
+
+@Mixin(ServerWorld.class)
+public abstract class MixinServerWorld extends World {
+    protected MixinServerWorld(MutableWorldProperties properties, RegistryKey<World> registryRef, DimensionType dimensionType, Supplier<Profiler> profiler, boolean isClient, boolean debugWorld, long seed) {
+        super(properties, registryRef, dimensionType, profiler, isClient, debugWorld, seed);
+    }
+
+    @Shadow protected abstract BlockPos getSurface(BlockPos pos);
+
+    @Inject(at = @At("TAIL"),method = "tickChunk")
+    public void tickChunk(WorldChunk chunk, int randomTickSpeed, CallbackInfo ci) {
+        ChunkPos chunkPos = chunk.getPos();
+        boolean bl = this.isRaining();
+        int x = chunkPos.getStartX();
+        int z = chunkPos.getStartZ();
+        Profiler profiler = this.getProfiler();
+        BlockPos pos;
+
+        if (this.getGameRules().getInt(VisualOverhaul.PUDDLE_SPAWN_RATE) != 0) {
+            profiler.push("puddles");
+            if (bl && random.nextInt(10000 / this.getGameRules().getInt(VisualOverhaul.PUDDLE_SPAWN_RATE)) == 0) {
+                pos = this.getSurface(getRandomPosInChunk(x, 0, z, 15));
+                if (this.hasRain(pos) && getBlockState(pos.down()).isSideSolidFullSquare(this, pos, Direction.UP)) {
+                    setBlockState(pos, VisualOverhaul.Puddle.getDefaultState());
+                }
+            }
+            profiler.pop();
+        }
+
+        if (this.getGameRules().getInt(VisualOverhaul.SNOW_STACK_CHANCE) != 0) {
+            profiler.push("extra_snow");
+            if (bl && random.nextInt(10000 / this.getGameRules().getInt(VisualOverhaul.SNOW_STACK_CHANCE)) == 0) {
+                pos = this.getSurface(getRandomPosInChunk(x, 0, z, 15));
+                if (this.getBlockState(pos).getBlock() == Blocks.SNOW && getBlockState(pos.down()).isSideSolidFullSquare(this, pos, Direction.UP)) {
+                    int layer = getBlockState(pos).get(Properties.LAYERS);
+                    setBlockState(pos, Blocks.SNOW.getDefaultState().with(Properties.LAYERS, layer + 1));
+                }
+            }
+            profiler.pop();
+        }
+    }
+}

src/main/resources/assets/visualoverhaul/blockstates/puddle.json

@@ -0,0 +1,7 @@
+{
+  "variants": {
+    "": {
+      "model": "visualoverhaul:block/puddle"
+    }
+  }
+}

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

@@ -0,0 +1,10 @@
+{
+	"visualoverhaul.midnightconfig.title":"Visual Overhaul Config",
+	"visualoverhaul.midnightconfig.brewingstand":"Enable Brewing Stand Enhancements",
+	"visualoverhaul.midnightconfig.jukebox":"Enable Jukebox Enhancements",
+	"visualoverhaul.midnightconfig.jukebox_fake_block":"Enable fake block on jukebox top",
+	"visualoverhaul.midnightconfig.furnace":"Enable Furnace Enhancements",
+	"visualoverhaul.midnightconfig.coloredItems":"Enable biome-based item colors",
+	"visualoverhaul.midnightconfig.coloredItems.tooltip":"Needs restart!",
+	"block.visualoverhaul.puddle":"Puddle"
+}

src/main/resources/assets/visualoverhaul/models/block/jukebox_top_playing.json

@@ -10,7 +10,7 @@
 	"elements": [
 		{
 			"from": [0, 0, 0],
-			"to": [16, 0.001, 16],
+			"to": [16, 0.01, 16],
 			"faces": {
 				"up": {"uv": [0, 0, 16, 16], "texture": "#3"}
 			}

src/main/resources/assets/visualoverhaul/models/block/jukebox_top_stopped.json

@@ -10,7 +10,7 @@
 	"elements": [
 		{
 			"from": [0, 0, 0],
-			"to": [16, 0.001, 16],
+			"to": [16, 0.01, 16],
 			"faces": {
 				"up": {"uv": [0, 0, 16, 16], "texture": "#3"}
 			}

src/main/resources/assets/visualoverhaul/models/block/puddle.json

@@ -0,0 +1,7 @@
+{
+	"credit": "made by Motschen",
+	"parent": "block/block",
+	"textures": {
+		"particle": "block/water_still"
+	}
+}

src/main/resources/assets/visualoverhaul/models/item/puddle.json

@@ -0,0 +1,22 @@
+{
+	"credit": "made by Motschen",
+	"parent": "block/block",
+	"textures": {
+		"0": "block/water_still",
+		"particle": "block/water_still"
+	},
+	"elements": [
+		{
+			"from": [0, 0, 0],
+			"to": [16, 1, 16],
+			"faces": {
+				"north": {"uv": [0, 0, 16, 1], "texture": "#0", "tintindex": 0},
+				"east": {"uv": [0, 0, 16, 1], "texture": "#0", "tintindex": 0},
+				"south": {"uv": [0, 0, 16, 1], "texture": "#0", "tintindex": 0},
+				"west": {"uv": [0, 0, 16, 1], "texture": "#0", "tintindex": 0},
+				"up": {"uv": [0, 0, 16, 16], "texture": "#0", "tintindex": 0},
+				"down": {"uv": [0, 0, 16, 16], "texture": "#0", "tintindex": 0}
+			}
+		}
+	]
+}

src/main/resources/fabric.mod.json

@@ -20,6 +20,9 @@
 
   "environment": "*",
   "entrypoints": {
+    "main": [
+      "eu.midnightdust.visualoverhaul.VisualOverhaul"
+    ],
     "client": [
       "eu.midnightdust.visualoverhaul.VisualOverhaulClient"
     ],
@@ -33,6 +36,7 @@
   ],
 
   "depends": {
-    "fabric": "*"
+    "fabric": ">=0.28.4",
+    "minecraft": "1.16.x"
   }
 }

src/main/resources/resourcepacks/coloredwaterbucket/assets/minecraft/models/item/water_bucket.json

@@ -0,0 +1,7 @@
+{
+    "parent": "item/generated",
+    "textures": {
+        "layer1": "item/water_bucket_overlay",
+        "layer0": "item/water_bucket"
+    }
+}

src/main/resources/resourcepacks/coloredwaterbucket/pack.mcmeta

@@ -0,0 +1,6 @@
+{
+  "pack": {
+    "pack_format": 6,
+    "description": "Makes the water bucket also change it's color based on biome color"
+  }
+}

src/main/resources/resourcepacks/fancyfurnace/assets/minecraft/blockstates/furnace.json

@@ -0,0 +1,34 @@
+{
+  "variants": {
+    "facing=east,lit=false": {
+      "model": "minecraft:block/furnace",
+      "y": 90
+    },
+    "facing=east,lit=true": {
+      "model": "minecraft:block/furnace_on",
+      "y": 90
+    },
+    "facing=north,lit=false": {
+      "model": "minecraft:block/furnace"
+    },
+    "facing=north,lit=true": {
+      "model": "minecraft:block/furnace_on"
+    },
+    "facing=south,lit=false": {
+      "model": "minecraft:block/furnace",
+      "y": 180
+    },
+    "facing=south,lit=true": {
+      "model": "minecraft:block/furnace_on",
+      "y": 180
+    },
+    "facing=west,lit=false": {
+      "model": "minecraft:block/furnace",
+      "y": 270
+    },
+    "facing=west,lit=true": {
+      "model": "minecraft:block/furnace_on",
+      "y": 270
+    }
+  }
+}

src/main/resources/resourcepacks/fancyfurnace/assets/minecraft/materialmaps/block/furnace.json

@@ -0,0 +1,14 @@
+{
+  "defaultMap": {
+	"spriteMap": [
+	  {
+		"sprite": "minecraft:block/furnace_front_on",
+		"material": "canvas:warm_glow"
+	  },
+	  {
+		"sprite": "minecraft:block/campfire_fire",
+		"material": "canvas:warm_glow"
+	  }
+	]
+  }
+}

src/main/resources/resourcepacks/fancyfurnace/assets/minecraft/models/block/furnace.json

@@ -0,0 +1,148 @@
+{
+	"credit": "made by Motschen",
+	"parent": "block/block",
+	"textures": {
+		"0": "block/furnace_front",
+		"1": "block/furnace_side",
+		"2": "block/furnace_top",
+		"3": "block/smooth_stone",
+		"4": "block/furnace_front",
+		"5": "block/campfire_fire",
+		"particle": "block/furnace_front"
+	},
+	"elements": [
+		{
+			"from": [0, 0, 6],
+			"to": [16, 16, 16],
+			"faces": {
+				"north": {"uv": [0, 0, 16, 16], "texture": "#4"},
+				"east": {"uv": [0, 0, 10, 16], "texture": "#1"},
+				"south": {"uv": [0, 0, 16, 16], "texture": "#1"},
+				"west": {"uv": [6, 0, 16, 16], "texture": "#1"},
+				"up": {"uv": [0, 6, 16, 16], "texture": "#2"},
+				"down": {"uv": [0, 0, 16, 10], "texture": "#3"}
+			}
+		},
+		{
+			"from": [13, 0, 0],
+			"to": [16, 16, 6],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, -2]},
+			"faces": {
+				"north": {"uv": [0, 0, 3, 16], "texture": "#0"},
+				"east": {"uv": [10, 0, 16, 16], "texture": "#1"},
+				"west": {"uv": [0, 0, 6, 16], "texture": "#1"},
+				"up": {"uv": [13, 0, 16, 6], "texture": "#2"},
+				"down": {"uv": [13, 10, 16, 16], "texture": "#3"}
+			}
+		},
+		{
+			"from": [12, 11, 0],
+			"to": [13, 16, 6],
+			"rotation": {"angle": 0, "axis": "y", "origin": [5, 8, -2]},
+			"faces": {
+				"north": {"uv": [3, 0, 4, 5], "texture": "#0"},
+				"west": {"uv": [1, 9, 7, 14], "texture": "#1"},
+				"up": {"uv": [12, 0, 13, 6], "texture": "#2"},
+				"down": {"uv": [12, 10, 13, 16], "texture": "#3"}
+			}
+		},
+		{
+			"from": [3, 11, 0],
+			"to": [4, 16, 6],
+			"rotation": {"angle": 0, "axis": "y", "origin": [-4, 8, -2]},
+			"faces": {
+				"north": {"uv": [3, 0, 4, 5], "texture": "#0"},
+				"east": {"uv": [1, 9, 7, 14], "texture": "#1"},
+				"west": {"uv": [1, 8, 7, 13], "texture": "#1"},
+				"up": {"uv": [12, 0, 13, 6], "texture": "#2"},
+				"down": {"uv": [3, 10, 4, 16], "texture": "#3"}
+			}
+		},
+		{
+			"from": [4, 12, 0],
+			"to": [12, 16, 6],
+			"rotation": {"angle": 0, "axis": "y", "origin": [3, 8, -2]},
+			"faces": {
+				"north": {"uv": [4, 0, 12, 4], "texture": "#0"},
+				"up": {"uv": [4, 0, 12, 6], "texture": "#2"},
+				"down": {"uv": [4, 10, 12, 16], "texture": "#3"}
+			}
+		},
+		{
+			"from": [0, 0, 0],
+			"to": [3, 16, 6],
+			"rotation": {"angle": 0, "axis": "y", "origin": [-5, 8, -2]},
+			"faces": {
+				"north": {"uv": [13, 0, 16, 16], "texture": "#0"},
+				"east": {"uv": [10, 0, 16, 16], "texture": "#1"},
+				"west": {"uv": [0, 0, 6, 16], "texture": "#1"},
+				"up": {"uv": [0, 0, 3, 6], "texture": "#2"},
+				"down": {"uv": [0, 10, 3, 16], "texture": "#3"}
+			}
+		},
+		{
+			"from": [12, 3, 0],
+			"to": [13, 9, 6],
+			"rotation": {"angle": 0, "axis": "y", "origin": [5, 8, -2]},
+			"faces": {
+				"north": {"uv": [3, 7, 4, 13], "texture": "#0"},
+				"west": {"uv": [1, 8, 7, 14], "texture": "#1"},
+				"up": {"uv": [3, 0, 4, 6], "texture": "#2"},
+				"down": {"uv": [3, 10, 4, 16], "texture": "#3"}
+			}
+		},
+		{
+			"from": [3, 3, 0],
+			"to": [4, 9, 6],
+			"rotation": {"angle": 0, "axis": "y", "origin": [-4, 8, -2]},
+			"faces": {
+				"north": {"uv": [12, 7, 13, 13], "texture": "#0"},
+				"east": {"uv": [9, 8, 15, 14], "texture": "#1"},
+				"up": {"uv": [12, 0, 13, 6], "texture": "#2"},
+				"down": {"uv": [12, 10, 13, 16], "texture": "#3"}
+			}
+		},
+		{
+			"from": [11, 4, 0],
+			"to": [12, 9, 6],
+			"rotation": {"angle": 0, "axis": "y", "origin": [4, 8, -2]},
+			"faces": {
+				"north": {"uv": [4, 7, 5, 12], "texture": "#0"},
+				"west": {"uv": [1, 9, 7, 14], "texture": "#1"},
+				"up": {"uv": [4, 0, 5, 6], "texture": "#2"},
+				"down": {"uv": [4, 10, 5, 16], "texture": "#3"}
+			}
+		},
+		{
+			"from": [4, 4, 0],
+			"to": [5, 9, 6],
+			"rotation": {"angle": 0, "axis": "y", "origin": [-3, 8, -2]},
+			"faces": {
+				"north": {"uv": [11, 7, 12, 12], "texture": "#0"},
+				"east": {"uv": [10, 9, 16, 14], "texture": "#1"},
+				"up": {"uv": [11, 0, 12, 6], "texture": "#2"},
+				"down": {"uv": [11, 10, 12, 16], "texture": "#3"}
+			}
+		},
+		{
+			"from": [5, 5, 0],
+			"to": [11, 9, 6],
+			"rotation": {"angle": 0, "axis": "y", "origin": [3, 8, -2]},
+			"faces": {
+				"north": {"uv": [5, 7, 11, 11], "texture": "#0"},
+				"up": {"uv": [5, 0, 11, 6], "texture": "#2"},
+				"down": {"uv": [5, 10, 11, 16], "texture": "#3"}
+			}
+		},
+		{
+			"from": [3, 0, 0],
+			"to": [13, 1, 6],
+			"rotation": {"angle": 0, "axis": "y", "origin": [5, 5, -2]},
+			"faces": {
+				"north": {"uv": [3, 15, 13, 16], "texture": "#0"},
+				"up": {"uv": [3, 0, 13, 6], "texture": "#2"},
+				"down": {"uv": [3, 10, 13, 16], "texture": "#3"}
+			}
+		}
+	]
+}

src/main/resources/resourcepacks/fancyfurnace/assets/minecraft/models/block/furnace_on.json

@@ -0,0 +1,156 @@
+{
+	"credit": "made by Motschen",
+	"parent": "block/block",
+	"textures": {
+		"0": "block/furnace_front",
+		"1": "block/furnace_side",
+		"2": "block/furnace_top",
+		"3": "block/smooth_stone",
+		"4": "block/furnace_front_on",
+		"5": "block/campfire_fire",
+		"particle": "block/furnace_front"
+	},
+	"elements": [
+		{
+			"from": [0, 0, 6],
+			"to": [16, 16, 16],
+			"faces": {
+				"north": {"uv": [0, 0, 16, 16], "texture": "#4"},
+				"east": {"uv": [0, 0, 10, 16], "texture": "#1"},
+				"south": {"uv": [0, 0, 16, 16], "texture": "#1"},
+				"west": {"uv": [6, 0, 16, 16], "texture": "#1"},
+				"up": {"uv": [0, 6, 16, 16], "texture": "#2"},
+				"down": {"uv": [0, 0, 16, 10], "texture": "#3"}
+			}
+		},
+		{
+			"from": [13, 0, 0],
+			"to": [16, 16, 6],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, -2]},
+			"faces": {
+				"north": {"uv": [0, 0, 3, 16], "texture": "#0"},
+				"east": {"uv": [10, 0, 16, 16], "texture": "#1"},
+				"west": {"uv": [0, 0, 6, 16], "texture": "#1"},
+				"up": {"uv": [13, 0, 16, 6], "texture": "#2"},
+				"down": {"uv": [13, 10, 16, 16], "texture": "#3"}
+			}
+		},
+		{
+			"from": [12, 11, 0],
+			"to": [13, 16, 6],
+			"rotation": {"angle": 0, "axis": "y", "origin": [5, 8, -2]},
+			"faces": {
+				"north": {"uv": [3, 0, 4, 5], "texture": "#0"},
+				"west": {"uv": [1, 9, 7, 14], "texture": "#1"},
+				"up": {"uv": [12, 0, 13, 6], "texture": "#2"},
+				"down": {"uv": [12, 10, 13, 16], "texture": "#3"}
+			}
+		},
+		{
+			"from": [3, 11, 0],
+			"to": [4, 16, 6],
+			"rotation": {"angle": 0, "axis": "y", "origin": [-4, 8, -2]},
+			"faces": {
+				"north": {"uv": [3, 0, 4, 5], "texture": "#0"},
+				"east": {"uv": [1, 9, 7, 14], "texture": "#1"},
+				"west": {"uv": [1, 8, 7, 13], "texture": "#1"},
+				"up": {"uv": [12, 0, 13, 6], "texture": "#2"},
+				"down": {"uv": [3, 10, 4, 16], "texture": "#3"}
+			}
+		},
+		{
+			"from": [4, 12, 0],
+			"to": [12, 16, 6],
+			"rotation": {"angle": 0, "axis": "y", "origin": [3, 8, -2]},
+			"faces": {
+				"north": {"uv": [4, 0, 12, 4], "texture": "#0"},
+				"up": {"uv": [4, 0, 12, 6], "texture": "#2"},
+				"down": {"uv": [4, 10, 12, 16], "texture": "#3"}
+			}
+		},
+		{
+			"from": [0, 0, 0],
+			"to": [3, 16, 6],
+			"rotation": {"angle": 0, "axis": "y", "origin": [-5, 8, -2]},
+			"faces": {
+				"north": {"uv": [13, 0, 16, 16], "texture": "#0"},
+				"east": {"uv": [10, 0, 16, 16], "texture": "#1"},
+				"west": {"uv": [0, 0, 6, 16], "texture": "#1"},
+				"up": {"uv": [0, 0, 3, 6], "texture": "#2"},
+				"down": {"uv": [0, 10, 3, 16], "texture": "#3"}
+			}
+		},
+		{
+			"from": [12, 3, 0],
+			"to": [13, 9, 6],
+			"rotation": {"angle": 0, "axis": "y", "origin": [5, 8, -2]},
+			"faces": {
+				"north": {"uv": [3, 7, 4, 13], "texture": "#0"},
+				"west": {"uv": [1, 8, 7, 14], "texture": "#1"},
+				"up": {"uv": [3, 0, 4, 6], "texture": "#2"},
+				"down": {"uv": [3, 10, 4, 16], "texture": "#3"}
+			}
+		},
+		{
+			"from": [3, 3, 0],
+			"to": [4, 9, 6],
+			"rotation": {"angle": 0, "axis": "y", "origin": [-4, 8, -2]},
+			"faces": {
+				"north": {"uv": [12, 7, 13, 13], "texture": "#0"},
+				"east": {"uv": [9, 8, 15, 14], "texture": "#1"},
+				"up": {"uv": [12, 0, 13, 6], "texture": "#2"},
+				"down": {"uv": [12, 10, 13, 16], "texture": "#3"}
+			}
+		},
+		{
+			"from": [11, 4, 0],
+			"to": [12, 9, 6],
+			"rotation": {"angle": 0, "axis": "y", "origin": [4, 8, -2]},
+			"faces": {
+				"north": {"uv": [4, 7, 5, 12], "texture": "#0"},
+				"west": {"uv": [1, 9, 7, 14], "texture": "#1"},
+				"up": {"uv": [4, 0, 5, 6], "texture": "#2"},
+				"down": {"uv": [4, 10, 5, 16], "texture": "#3"}
+			}
+		},
+		{
+			"from": [4, 4, 0],
+			"to": [5, 9, 6],
+			"rotation": {"angle": 0, "axis": "y", "origin": [-3, 8, -2]},
+			"faces": {
+				"north": {"uv": [11, 7, 12, 12], "texture": "#0"},
+				"east": {"uv": [10, 9, 16, 14], "texture": "#1"},
+				"up": {"uv": [11, 0, 12, 6], "texture": "#2"},
+				"down": {"uv": [11, 10, 12, 16], "texture": "#3"}
+			}
+		},
+		{
+			"from": [5, 5, 0],
+			"to": [11, 9, 6],
+			"rotation": {"angle": 0, "axis": "y", "origin": [3, 8, -2]},
+			"faces": {
+				"north": {"uv": [5, 7, 11, 11], "texture": "#0"},
+				"up": {"uv": [5, 0, 11, 6], "texture": "#2"},
+				"down": {"uv": [5, 10, 11, 16], "texture": "#3"}
+			}
+		},
+		{
+			"from": [3, 0, 0],
+			"to": [13, 1, 6],
+			"rotation": {"angle": 0, "axis": "y", "origin": [5, 5, -2]},
+			"faces": {
+				"north": {"uv": [3, 15, 13, 16], "texture": "#0"},
+				"up": {"uv": [3, 0, 13, 6], "texture": "#2"},
+				"down": {"uv": [3, 10, 13, 16], "texture": "#3"}
+			}
+		},
+		{
+			"from": [4, 1, 2],
+			"to": [12, 3, 2],
+			"rotation": {"angle": 0, "axis": "y", "origin": [14, 9, 10]},
+			"faces": {
+				"north": {"uv": [4, 0, 12, 2], "texture": "#5"}
+			}
+		}
+	]
+}

src/main/resources/resourcepacks/fancyfurnace/pack.mcmeta

@@ -0,0 +1,6 @@
+{
+  "pack": {
+    "pack_format": 6,
+    "description": "§2Changes the model of the furnace to be 3D"
+  }
+}

src/main/resources/visualoverhaul.mixins.json

@@ -4,7 +4,9 @@
   "compatibilityLevel": "JAVA_8",
   "mixins": [
     "MixinBrewingStandBlockEntity",
-    "MixinJukeboxBlockEntity"
+    "MixinJukeboxBlockEntity",
+    "MixinAbstractFurnaceBlockEntity",
+    "MixinServerWorld"
   ],
   "injectors": {
     "defaultRequire": 1