Add hollow covers.

2018-07-06 23:27:11 +02:00
parent 7009eb883e
commit fc498e6400
16 changed files with 524 additions and 111 deletions
--- a/src/main/java/com/raoulvdberge/refinedstorage/RSItems.java
+++ b/src/main/java/com/raoulvdberge/refinedstorage/RSItems.java
@@ -22,4 +22,5 @@ public final class RSItems {
    public static final ItemSecurityCard SECURITY_CARD = new ItemSecurityCard();
    public static final ItemCuttingTool CUTTING_TOOL = new ItemCuttingTool();
    public static final ItemCover COVER = new ItemCover();
+    public static final ItemHollowCover HOLLOW_COVER = new ItemHollowCover();
 }
--- a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/cover/Cover.java
+++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/cover/Cover.java
@@ -0,0 +1,21 @@
+package com.raoulvdberge.refinedstorage.apiimpl.network.node.cover;
+
+import net.minecraft.item.ItemStack;
+
+public class Cover {
+    private ItemStack stack;
+    private boolean hollow;
+
+    public Cover(ItemStack stack, boolean hollow) {
+        this.stack = stack;
+        this.hollow = hollow;
+    }
+
+    public ItemStack getStack() {
+        return stack;
+    }
+
+    public boolean isHollow() {
+        return hollow;
+    }
+}
--- a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/cover/CoverManager.java
+++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/cover/CoverManager.java
@@ -27,8 +27,9 @@ import java.util.Map;
 public class CoverManager {
    private static final String NBT_DIRECTION = "Direction";
    private static final String NBT_ITEM = "Item";
+    private static final String NBT_HOLLOW = "Hollow";

-    private Map<EnumFacing, ItemStack> covers = new HashMap<>();
+    private Map<EnumFacing, Cover> covers = new HashMap<>();
    private NetworkNode node;
    private boolean canPlaceCoversOnFace = true;

@@ -37,20 +38,25 @@ public class CoverManager {
    }

    public boolean canConduct(EnumFacing direction) {
-        if (hasCover(direction)) {
+        Cover cover = getCover(direction);
+        if (cover != null && !cover.isHollow()) {
            return false;
        }

        INetworkNode neighbor = API.instance().getNetworkNodeManager(node.getWorld()).getNode(node.getPos().offset(direction));
-        if (neighbor instanceof ICoverable && ((ICoverable) neighbor).getCoverManager().hasCover(direction.getOpposite())) {
-            return false;
+        if (neighbor instanceof ICoverable) {
+            cover = ((ICoverable) neighbor).getCoverManager().getCover(direction.getOpposite());
+
+            if (cover != null && !cover.isHollow()) {
+                return false;
+            }
        }

        return true;
    }

    @Nullable
-    public ItemStack getCover(EnumFacing facing) {
+    public Cover getCover(EnumFacing facing) {
        return covers.get(facing);
    }

@@ -58,13 +64,13 @@ public class CoverManager {
        return covers.containsKey(facing);
    }

-    public boolean setCover(EnumFacing facing, ItemStack stack) {
-        if (isValidCover(stack) && !hasCover(facing)) {
-            if (facing == node.getDirection() && !canPlaceCoversOnFace) {
+    public boolean setCover(EnumFacing facing, Cover cover) {
+        if (isValidCover(cover.getStack()) && !hasCover(facing)) {
+            if (facing == node.getDirection() && !canPlaceCoversOnFace && !cover.isHollow()) {
                return false;
            }

-            covers.put(facing, stack);
+            covers.put(facing, cover);

            node.markDirty();

@@ -78,12 +84,6 @@ public class CoverManager {
        return false;
    }

-    public CoverManager setCanPlaceCoversOnFace(boolean canPlaceCoversOnFace) {
-        this.canPlaceCoversOnFace = canPlaceCoversOnFace;
-
-        return this;
-    }
-
    public void readFromNbt(NBTTagList list) {
        for (int i = 0; i < list.tagCount(); ++i) {
            NBTTagCompound tag = list.getCompoundTagAt(i);
@@ -91,9 +91,10 @@ public class CoverManager {
            if (tag.hasKey(NBT_DIRECTION) && tag.hasKey(NBT_ITEM)) {
                EnumFacing direction = EnumFacing.getFront(tag.getInteger(NBT_DIRECTION));
                ItemStack item = new ItemStack(tag.getCompoundTag(NBT_ITEM));
+                boolean hollow = tag.hasKey(NBT_HOLLOW) && tag.getBoolean(NBT_HOLLOW);

                if (isValidCover(item)) {
-                    covers.put(direction, item);
+                    covers.put(direction, new Cover(item, hollow));
                }
            }
        }
@@ -102,11 +103,12 @@ public class CoverManager {
    public NBTTagList writeToNbt() {
        NBTTagList list = new NBTTagList();

-        for (Map.Entry<EnumFacing, ItemStack> entry : covers.entrySet()) {
+        for (Map.Entry<EnumFacing, Cover> entry : covers.entrySet()) {
            NBTTagCompound tag = new NBTTagCompound();

            tag.setInteger(NBT_DIRECTION, entry.getKey().ordinal());
-            tag.setTag(NBT_ITEM, entry.getValue().serializeNBT());
+            tag.setTag(NBT_ITEM, entry.getValue().getStack().serializeNBT());
+            tag.setBoolean(NBT_HOLLOW, entry.getValue().isHollow());

            list.appendTag(tag);
        }
@@ -119,10 +121,10 @@ public class CoverManager {

        int i = 0;

-        for (Map.Entry<EnumFacing, ItemStack> entry : covers.entrySet()) {
-            ItemStack cover = new ItemStack(RSItems.COVER);
+        for (Map.Entry<EnumFacing, Cover> entry : covers.entrySet()) {
+            ItemStack cover = new ItemStack(entry.getValue().isHollow() ? RSItems.HOLLOW_COVER : RSItems.COVER);

-            ItemCover.setItem(cover, entry.getValue());
+            ItemCover.setItem(cover, entry.getValue().getStack());

            handler.setStackInSlot(i++, cover);
        }
@@ -181,4 +183,10 @@ public class CoverManager {
            return null;
        }
    }
+
+    public CoverManager setCanPlaceCoversOnFace(boolean canPlaceCoversOnFace) {
+        this.canPlaceCoversOnFace = canPlaceCoversOnFace;
+
+        return this;
+    }
 }
--- a/src/main/java/com/raoulvdberge/refinedstorage/block/BlockCable.java
+++ b/src/main/java/com/raoulvdberge/refinedstorage/block/BlockCable.java
@@ -2,6 +2,7 @@ package com.raoulvdberge.refinedstorage.block;

 import com.raoulvdberge.refinedstorage.api.network.node.INetworkNode;
 import com.raoulvdberge.refinedstorage.apiimpl.network.node.ICoverable;
+import com.raoulvdberge.refinedstorage.apiimpl.network.node.cover.Cover;
 import com.raoulvdberge.refinedstorage.apiimpl.network.node.cover.CoverManager;
 import com.raoulvdberge.refinedstorage.capability.CapabilityNetworkNodeProxy;
 import com.raoulvdberge.refinedstorage.tile.TileBase;
@@ -14,7 +15,6 @@ import net.minecraft.block.state.BlockStateContainer;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.EntityLivingBase;
-import net.minecraft.item.ItemStack;
 import net.minecraft.tileentity.TileEntity;
 import net.minecraft.util.BlockRenderLayer;
 import net.minecraft.util.EnumFacing;
@@ -31,12 +31,12 @@ import java.util.ArrayList;
 import java.util.List;

 public class BlockCable extends BlockNode {
-    public static final PropertyObject<ItemStack> COVER_NORTH = new PropertyObject<>("cover_north", ItemStack.class);
-    public static final PropertyObject<ItemStack> COVER_EAST = new PropertyObject<>("cover_east", ItemStack.class);
-    public static final PropertyObject<ItemStack> COVER_SOUTH = new PropertyObject<>("cover_south", ItemStack.class);
-    public static final PropertyObject<ItemStack> COVER_WEST = new PropertyObject<>("cover_west", ItemStack.class);
-    public static final PropertyObject<ItemStack> COVER_UP = new PropertyObject<>("cover_up", ItemStack.class);
-    public static final PropertyObject<ItemStack> COVER_DOWN = new PropertyObject<>("cover_down", ItemStack.class);
+    public static final PropertyObject<Cover> COVER_NORTH = new PropertyObject<>("cover_north", Cover.class);
+    public static final PropertyObject<Cover> COVER_EAST = new PropertyObject<>("cover_east", Cover.class);
+    public static final PropertyObject<Cover> COVER_SOUTH = new PropertyObject<>("cover_south", Cover.class);
+    public static final PropertyObject<Cover> COVER_WEST = new PropertyObject<>("cover_west", Cover.class);
+    public static final PropertyObject<Cover> COVER_UP = new PropertyObject<>("cover_up", Cover.class);
+    public static final PropertyObject<Cover> COVER_DOWN = new PropertyObject<>("cover_down", Cover.class);

    public static final AxisAlignedBB HOLDER_NORTH_AABB = RenderUtils.getBounds(7, 7, 2, 9, 9, 6);
    public static final AxisAlignedBB HOLDER_EAST_AABB = RenderUtils.getBounds(10, 7, 7, 14, 9, 9);
@@ -136,16 +136,20 @@ public class BlockCable extends BlockNode {

        INetworkNode node = ((TileNode) tile).getNode();

-        if (node instanceof ICoverable && ((ICoverable) node).getCoverManager().hasCover(direction)) {
-            return false;
+        if (node instanceof ICoverable) {
+            Cover cover = ((ICoverable) node).getCoverManager().getCover(direction);
+
+            if (cover != null && !cover.isHollow()) {
+                return false;
+            }
        }

        TileEntity otherTile = world.getTileEntity(pos.offset(direction));

-        if (otherTile instanceof TileNode) {
-            INetworkNode otherNode = ((TileNode) otherTile).getNode();
+        if (otherTile instanceof TileNode && ((TileNode) otherTile).getNode() instanceof ICoverable) {
+            Cover cover = ((ICoverable) ((TileNode) otherTile).getNode()).getCoverManager().getCover(direction.getOpposite());

-            if (otherNode instanceof ICoverable && ((ICoverable) otherNode).getCoverManager().hasCover(direction.getOpposite())) {
+            if (cover != null && !cover.isHollow()) {
                return false;
            }
        }
@@ -229,64 +233,77 @@ public class BlockCable extends BlockNode {
        if (tile instanceof TileNode && ((TileNode) tile).getNode() instanceof ICoverable) {
            CoverManager coverManager = ((ICoverable) ((TileNode) tile).getNode()).getCoverManager();

-            boolean hasUp = coverManager.hasCover(EnumFacing.UP);
-            boolean hasDown = coverManager.hasCover(EnumFacing.DOWN);
+            Cover coverNorth = coverManager.getCover(EnumFacing.NORTH);
+            Cover coverEast = coverManager.getCover(EnumFacing.EAST);
+            Cover coverSouth = coverManager.getCover(EnumFacing.SOUTH);
+            Cover coverWest = coverManager.getCover(EnumFacing.WEST);
+            Cover coverUp = coverManager.getCover(EnumFacing.UP);
+            Cover coverDown = coverManager.getCover(EnumFacing.DOWN);

-            boolean hasEast = coverManager.hasCover(EnumFacing.EAST);
-            boolean hasWest = coverManager.hasCover(EnumFacing.WEST);
-
-            if (coverManager.hasCover(EnumFacing.NORTH)) {
+            if (coverNorth != null) {
                boxes.add(RenderUtils.getBounds(
-                    hasWest ? 2 : 0, hasDown ? 2 : 0, 0,
-                    hasEast ? 14 : 16, hasUp ? 14 : 16, 2
+                    coverWest != null ? 2 : 0, coverDown != null ? 2 : 0, 0,
+                    coverEast != null ? 14 : 16, coverUp != null ? 14 : 16, 2
                ));

-                boxes.add(HOLDER_NORTH_AABB);
+                if (!coverNorth.isHollow()) {
+                    boxes.add(HOLDER_NORTH_AABB);
+                }
            }

-            if (hasEast) {
+            if (coverEast != null) {
                boxes.add(RenderUtils.getBounds(
-                    14, hasDown ? 2 : 0, 0,
-                    16, hasUp ? 14 : 16, 16
+                    14, coverDown != null ? 2 : 0, 0,
+                    16, coverUp != null ? 14 : 16, 16
                ));

-                boxes.add(HOLDER_EAST_AABB);
+                if (!coverEast.isHollow()) {
+                    boxes.add(HOLDER_EAST_AABB);
+                }
            }

-            if (coverManager.hasCover(EnumFacing.SOUTH)) {
+            if (coverSouth != null) {
                boxes.add(RenderUtils.getBounds(
-                    hasEast ? 14 : 16, hasDown ? 2 : 0, 16,
-                    hasWest ? 2 : 0, hasUp ? 14 : 16, 14
+                    coverEast != null ? 14 : 16, coverDown != null ? 2 : 0, 16,
+                    coverWest != null ? 2 : 0, coverUp != null ? 14 : 16, 14
                ));

-                boxes.add(HOLDER_SOUTH_AABB);
+                if (!coverSouth.isHollow()) {
+                    boxes.add(HOLDER_SOUTH_AABB);
+                }
            }

-            if (hasWest) {
+            if (coverWest != null) {
                boxes.add(RenderUtils.getBounds(
-                    0, hasDown ? 2 : 0, 0,
-                    2, hasUp ? 14 : 16, 16
+                    0, coverDown != null ? 2 : 0, 0,
+                    2, coverUp != null ? 14 : 16, 16
                ));

-                boxes.add(HOLDER_WEST_AABB);
+                if (!coverWest.isHollow()) {
+                    boxes.add(HOLDER_WEST_AABB);
+                }
            }

-            if (hasUp) {
+            if (coverUp != null) {
                boxes.add(RenderUtils.getBounds(
                    0, 14, 0,
                    16, 16, 16
                ));

-                boxes.add(HOLDER_UP_AABB);
+                if (!coverUp.isHollow()) {
+                    boxes.add(HOLDER_UP_AABB);
+                }
            }

-            if (hasDown) {
+            if (coverDown != null) {
                boxes.add(RenderUtils.getBounds(
                    0, 0, 0,
                    16, 2, 16
                ));

-                boxes.add(HOLDER_DOWN_AABB);
+                if (!coverDown.isHollow()) {
+                    boxes.add(HOLDER_DOWN_AABB);
+                }
            }
        }

--- a/src/main/java/com/raoulvdberge/refinedstorage/item/ItemCover.java
+++ b/src/main/java/com/raoulvdberge/refinedstorage/item/ItemCover.java
@@ -1,10 +1,10 @@
 package com.raoulvdberge.refinedstorage.item;

 import com.raoulvdberge.refinedstorage.RS;
-import com.raoulvdberge.refinedstorage.RSItems;
 import com.raoulvdberge.refinedstorage.api.network.node.INetworkNode;
 import com.raoulvdberge.refinedstorage.api.network.security.Permission;
 import com.raoulvdberge.refinedstorage.apiimpl.network.node.ICoverable;
+import com.raoulvdberge.refinedstorage.apiimpl.network.node.cover.Cover;
 import com.raoulvdberge.refinedstorage.apiimpl.network.node.cover.CoverManager;
 import com.raoulvdberge.refinedstorage.tile.TileNode;
 import com.raoulvdberge.refinedstorage.util.WorldUtils;
@@ -31,12 +31,16 @@ import java.util.List;
 public class ItemCover extends ItemBase {
    private static final String NBT_ITEM = "Item";

-    public ItemCover() {
-        super("cover");
+    public ItemCover(String name) {
+        super(name);

        setCreativeTab(RS.INSTANCE.coversTab);
    }

+    public ItemCover() {
+        this("cover");
+    }
+
    public static void setItem(ItemStack cover, ItemStack item) {
        if (!cover.hasTagCompound()) {
            cover.setTagCompound(new NBTTagCompound());
@@ -84,7 +88,7 @@ public class ItemCover extends ItemBase {

            for (ItemStack subBlock : subBlocks) {
                if (CoverManager.isValidCover(subBlock)) {
-                    ItemStack stack = new ItemStack(RSItems.COVER);
+                    ItemStack stack = new ItemStack(this);

                    setItem(stack, subBlock);

@@ -120,7 +124,7 @@ public class ItemCover extends ItemBase {
                return EnumActionResult.FAIL;
            }

-            if (((ICoverable) node).getCoverManager().setCover(facing, getItem(stack))) {
+            if (((ICoverable) node).getCoverManager().setCover(facing, createCover(getItem(stack)))) {
                player.getHeldItem(hand).shrink(1);

                WorldUtils.updateBlock(world, pos);
@@ -137,4 +141,8 @@ public class ItemCover extends ItemBase {
    private boolean canPlaceOn(TileEntity tile) {
        return tile instanceof TileNode && ((TileNode) tile).getNode() instanceof ICoverable;
    }
+
+    protected Cover createCover(ItemStack stack) {
+        return new Cover(stack, false);
+    }
 }
--- a/src/main/java/com/raoulvdberge/refinedstorage/item/ItemHollowCover.java
+++ b/src/main/java/com/raoulvdberge/refinedstorage/item/ItemHollowCover.java
@@ -0,0 +1,15 @@
+package com.raoulvdberge.refinedstorage.item;
+
+import com.raoulvdberge.refinedstorage.apiimpl.network.node.cover.Cover;
+import net.minecraft.item.ItemStack;
+
+public class ItemHollowCover extends ItemCover {
+    public ItemHollowCover() {
+        super("hollow_cover");
+    }
+
+    @Override
+    protected Cover createCover(ItemStack stack) {
+        return new Cover(stack, true);
+    }
+}
--- a/src/main/java/com/raoulvdberge/refinedstorage/proxy/ProxyClient.java
+++ b/src/main/java/com/raoulvdberge/refinedstorage/proxy/ProxyClient.java
@@ -18,8 +18,8 @@ import com.raoulvdberge.refinedstorage.network.MessageGridCraftingPreviewRespons
 import com.raoulvdberge.refinedstorage.render.model.ModelDiskDrive;
 import com.raoulvdberge.refinedstorage.render.model.ModelDiskManipulator;
 import com.raoulvdberge.refinedstorage.render.model.baked.BakedModelCableCover;
-import com.raoulvdberge.refinedstorage.render.model.baked.BakedModelCover;
 import com.raoulvdberge.refinedstorage.render.model.baked.BakedModelPattern;
+import com.raoulvdberge.refinedstorage.render.model.loader.CustomModelLoaderCover;
 import com.raoulvdberge.refinedstorage.render.model.loader.CustomModelLoaderDefault;
 import com.raoulvdberge.refinedstorage.render.statemapper.StateMapperCTM;
 import com.raoulvdberge.refinedstorage.render.tesr.TileEntitySpecialRendererStorageMonitor;
@@ -231,6 +231,7 @@ public class ProxyClient extends ProxyCommon {
        ModelLoader.setCustomModelResourceLocation(Item.getItemFromBlock(RSBlocks.QUARTZ_ENRICHED_IRON), 0, new ModelResourceLocation("refinedstorage:quartz_enriched_iron_block", "inventory"));
        ModelLoader.setCustomModelResourceLocation(Item.getItemFromBlock(RSBlocks.STORAGE_MONITOR), 0, new ModelResourceLocation("refinedstorage:storage_monitor", "connected=false,direction=north"));
        ModelLoader.setCustomModelResourceLocation(RSItems.COVER, 0, new ModelResourceLocation("refinedstorage:cover", "inventory"));
+        ModelLoader.setCustomModelResourceLocation(RSItems.HOLLOW_COVER, 0, new ModelResourceLocation("refinedstorage:hollow_cover", "inventory"));

        ModelLoaderRegistry.registerLoader(new CustomModelLoaderDefault(new ResourceLocation(RS.ID, "disk_drive"), ModelDiskDrive::new));
        ModelLoaderRegistry.registerLoader(new CustomModelLoaderDefault(new ResourceLocation(RS.ID, "disk_manipulator"), ModelDiskManipulator::new));
@@ -292,6 +293,8 @@ public class ProxyClient extends ProxyCommon {
            }
        });

+        ModelLoaderRegistry.registerLoader(new CustomModelLoaderCover());
+
        ModelLoader.setCustomStateMapper(RSBlocks.PORTABLE_GRID, new StateMap.Builder().ignore(BlockPortableGrid.TYPE).build());
        ModelLoader.setCustomMeshDefinition(Item.getItemFromBlock(RSBlocks.PORTABLE_GRID), stack -> {
            ItemHandlerBase disk = new ItemHandlerBase(1);
@@ -374,8 +377,6 @@ public class ProxyClient extends ProxyCommon {
                    e.getModelRegistry().putObject(model, new BakedModelPattern(e.getModelRegistry().getObject(model)));
                } else if (model.getResourcePath().equals("cable") || model.getResourcePath().equals("exporter") || model.getResourcePath().equals("importer") || model.getResourcePath().equals("external_storage")) {
                    e.getModelRegistry().putObject(model, new BakedModelCableCover(e.getModelRegistry().getObject(model)));
-                } else if (model.getResourcePath().equals("cover")) {
-                    e.getModelRegistry().putObject(model, new BakedModelCover(e.getModelRegistry().getObject(model), null));
                }
            }
        }
--- a/src/main/java/com/raoulvdberge/refinedstorage/proxy/ProxyCommon.java
+++ b/src/main/java/com/raoulvdberge/refinedstorage/proxy/ProxyCommon.java
@@ -43,6 +43,7 @@ import com.raoulvdberge.refinedstorage.integration.oc.IntegrationOC;
 import com.raoulvdberge.refinedstorage.item.ItemProcessor;
 import com.raoulvdberge.refinedstorage.network.*;
 import com.raoulvdberge.refinedstorage.recipe.RecipeCover;
+import com.raoulvdberge.refinedstorage.recipe.RecipeHollowCover;
 import com.raoulvdberge.refinedstorage.tile.*;
 import com.raoulvdberge.refinedstorage.tile.craftingmonitor.TileCraftingMonitor;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataManager;
@@ -263,6 +264,7 @@ public class ProxyCommon {
        registerItem(RSItems.NETWORK_CARD);
        registerItem(RSItems.SECURITY_CARD);
        registerItem(RSItems.COVER);
+        registerItem(RSItems.HOLLOW_COVER);

        IntegrationInventorySorter.register();
    }
@@ -310,6 +312,7 @@ public class ProxyCommon {
    @SubscribeEvent
    public void registerRecipes(RegistryEvent.Register<IRecipe> e) {
        e.getRegistry().register(new RecipeCover().setRegistryName(new ResourceLocation(RS.ID, "cover")));
+        e.getRegistry().register(new RecipeHollowCover().setRegistryName(new ResourceLocation(RS.ID, "hollow_cover")));
    }

    @SubscribeEvent
--- a/src/main/java/com/raoulvdberge/refinedstorage/recipe/RecipeHollowCover.java
+++ b/src/main/java/com/raoulvdberge/refinedstorage/recipe/RecipeHollowCover.java
@@ -0,0 +1,73 @@
+package com.raoulvdberge.refinedstorage.recipe;
+
+import com.raoulvdberge.refinedstorage.RSItems;
+import com.raoulvdberge.refinedstorage.apiimpl.network.node.cover.CoverManager;
+import com.raoulvdberge.refinedstorage.item.ItemCover;
+import com.raoulvdberge.refinedstorage.item.ItemHollowCover;
+import net.minecraft.inventory.InventoryCrafting;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.crafting.IRecipe;
+import net.minecraft.world.World;
+import net.minecraftforge.registries.IForgeRegistryEntry;
+
+import javax.annotation.Nullable;
+
+public class RecipeHollowCover extends IForgeRegistryEntry.Impl<IRecipe> implements IRecipe {
+    private boolean isValid(ItemStack slot, @Nullable ItemStack previousValidSlot) {
+        ItemStack currentCover = ItemCover.getItem(slot);
+
+        if (slot.getItem() == RSItems.COVER && CoverManager.isValidCover(currentCover)) {
+            if (previousValidSlot == null) {
+                return true;
+            }
+
+            ItemStack previousCover = ItemCover.getItem(previousValidSlot);
+
+            return previousCover.getItem() == currentCover.getItem() && previousCover.getItemDamage() == currentCover.getItemDamage();
+        }
+
+        return false;
+    }
+
+    @Override
+    public boolean matches(InventoryCrafting inv, World worldIn) {
+        ItemStack previousValidSlot = null;
+
+        for (int i = 0; i < 9; ++i) {
+            ItemStack slot = inv.getStackInSlot(i);
+
+            if (i == 4) {
+                if (!slot.isEmpty()) {
+                    return false;
+                }
+            } else {
+                if (isValid(slot, previousValidSlot)) {
+                    previousValidSlot = slot;
+                } else {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+
+    @Override
+    public ItemStack getCraftingResult(InventoryCrafting inv) {
+        ItemStack stack = new ItemStack(RSItems.HOLLOW_COVER, 8);
+
+        ItemHollowCover.setItem(stack, ItemCover.getItem(inv.getStackInSlot(0)));
+
+        return stack;
+    }
+
+    @Override
+    public boolean canFit(int width, int height) {
+        return width == 3 && height == 3;
+    }
+
+    @Override
+    public ItemStack getRecipeOutput() {
+        return ItemStack.EMPTY;
+    }
+}
--- a/src/main/java/com/raoulvdberge/refinedstorage/render/model/ModelCover.java
+++ b/src/main/java/com/raoulvdberge/refinedstorage/render/model/ModelCover.java
@@ -0,0 +1,24 @@
+package com.raoulvdberge.refinedstorage.render.model;
+
+import com.raoulvdberge.refinedstorage.render.model.baked.BakedModelCover;
+import net.minecraft.client.renderer.block.model.IBakedModel;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.client.renderer.vertex.VertexFormat;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.client.model.IModel;
+import net.minecraftforge.common.model.IModelState;
+
+import java.util.function.Function;
+
+public class ModelCover implements IModel {
+    private boolean hollow;
+
+    public ModelCover(boolean hollow) {
+        this.hollow = hollow;
+    }
+
+    @Override
+    public IBakedModel bake(IModelState state, VertexFormat format, Function<ResourceLocation, TextureAtlasSprite> bakedTextureGetter) {
+        return new BakedModelCover(null, hollow);
+    }
+}
--- a/src/main/java/com/raoulvdberge/refinedstorage/render/model/baked/BakedModelCableCover.java
+++ b/src/main/java/com/raoulvdberge/refinedstorage/render/model/baked/BakedModelCableCover.java
@@ -1,6 +1,7 @@
 package com.raoulvdberge.refinedstorage.render.model.baked;

 import com.raoulvdberge.refinedstorage.RS;
+import com.raoulvdberge.refinedstorage.apiimpl.network.node.cover.Cover;
 import com.raoulvdberge.refinedstorage.apiimpl.network.node.cover.CoverManager;
 import com.raoulvdberge.refinedstorage.block.BlockCable;
 import com.raoulvdberge.refinedstorage.render.CubeBuilder;
@@ -8,7 +9,6 @@ import net.minecraft.block.state.IBlockState;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.renderer.block.model.*;
 import net.minecraft.client.renderer.texture.TextureAtlasSprite;
-import net.minecraft.item.ItemStack;
 import net.minecraft.util.BlockRenderLayer;
 import net.minecraft.util.EnumFacing;
 import net.minecraftforge.client.ForgeHooksClient;
@@ -37,29 +37,37 @@ public class BakedModelCableCover implements IBakedModel {
        if (state != null) {
            IExtendedBlockState s = (IExtendedBlockState) state;

-            boolean hasUp = CoverManager.getBlockState(s.getValue(BlockCable.COVER_UP)) != null;
-            boolean hasDown = CoverManager.getBlockState(s.getValue(BlockCable.COVER_DOWN)) != null;
+            boolean hasUp = s.getValue(BlockCable.COVER_UP) != null;
+            boolean hasDown = s.getValue(BlockCable.COVER_DOWN) != null;

-            boolean hasEast = CoverManager.getBlockState(s.getValue(BlockCable.COVER_EAST)) != null;
-            boolean hasWest = CoverManager.getBlockState(s.getValue(BlockCable.COVER_WEST)) != null;
+            boolean hasEast = s.getValue(BlockCable.COVER_EAST) != null;
+            boolean hasWest = s.getValue(BlockCable.COVER_WEST) != null;

-            addCover(quads, s.getValue(BlockCable.COVER_NORTH), EnumFacing.NORTH, side, rand, hasUp, hasDown, hasEast, hasWest);
-            addCover(quads, s.getValue(BlockCable.COVER_SOUTH), EnumFacing.SOUTH, side, rand, hasUp, hasDown, hasEast, hasWest);
-            addCover(quads, s.getValue(BlockCable.COVER_EAST), EnumFacing.EAST, side, rand, hasUp, hasDown, hasEast, hasWest);
-            addCover(quads, s.getValue(BlockCable.COVER_WEST), EnumFacing.WEST, side, rand, hasUp, hasDown, hasEast, hasWest);
-            addCover(quads, s.getValue(BlockCable.COVER_DOWN), EnumFacing.DOWN, side, rand, hasUp, hasDown, hasEast, hasWest);
-            addCover(quads, s.getValue(BlockCable.COVER_UP), EnumFacing.UP, side, rand, hasUp, hasDown, hasEast, hasWest);
+            addCoverOrHollow(quads, s.getValue(BlockCable.COVER_NORTH), EnumFacing.NORTH, side, rand, hasUp, hasDown, hasEast, hasWest);
+            addCoverOrHollow(quads, s.getValue(BlockCable.COVER_SOUTH), EnumFacing.SOUTH, side, rand, hasUp, hasDown, hasEast, hasWest);
+            addCoverOrHollow(quads, s.getValue(BlockCable.COVER_EAST), EnumFacing.EAST, side, rand, hasUp, hasDown, hasEast, hasWest);
+            addCoverOrHollow(quads, s.getValue(BlockCable.COVER_WEST), EnumFacing.WEST, side, rand, hasUp, hasDown, hasEast, hasWest);
+            addCoverOrHollow(quads, s.getValue(BlockCable.COVER_DOWN), EnumFacing.DOWN, side, rand, hasUp, hasDown, hasEast, hasWest);
+            addCoverOrHollow(quads, s.getValue(BlockCable.COVER_UP), EnumFacing.UP, side, rand, hasUp, hasDown, hasEast, hasWest);
        }

        return quads;
    }

-    protected static void addCover(List<BakedQuad> quads, @Nullable ItemStack coverStack, EnumFacing coverSide, EnumFacing side, long rand, boolean hasUp, boolean hasDown, boolean hasEast, boolean hasWest) {
-        if (coverStack == null || coverStack.isEmpty()) {
+    protected static void addCoverOrHollow(List<BakedQuad> quads, @Nullable Cover cover, EnumFacing coverSide, EnumFacing side, long rand, boolean hasUp, boolean hasDown, boolean hasEast, boolean hasWest) {
+        if (cover == null) {
            return;
        }

-        IBlockState coverState = CoverManager.getBlockState(coverStack);
+        if (cover.isHollow()) {
+            addHollowCover(quads, cover, coverSide, side, rand, hasUp, hasDown, hasEast, hasWest);
+        } else {
+            addCover(quads, cover, coverSide, side, rand, hasUp, hasDown, hasEast, hasWest);
+        }
+    }
+
+    private static void addCover(List<BakedQuad> quads, Cover cover, EnumFacing coverSide, EnumFacing side, long rand, boolean hasUp, boolean hasDown, boolean hasEast, boolean hasWest) {
+        IBlockState coverState = CoverManager.getBlockState(cover.getStack());

        if (coverState == null) {
            return;
@@ -69,17 +77,20 @@ public class BakedModelCableCover implements IBakedModel {

        TextureAtlasSprite sprite = getSprite(coverModel, coverState, side, rand);

-        ModelRotation modelRotation = ModelRotation.X0_Y0;
+        ModelRotation rotation = ModelRotation.X0_Y0;

        int xStart = 0;
        int xEnd = 16;
+
        int xTexStart = 0;
        int xTexEnd = 16;
+
        int xTexBackStart = 0;
        int xTexBackEnd = 16;

        int yStart = 0;
        int yEnd = 16;
+
        int yTexStart = 0;
        int yTexEnd = 16;

@@ -96,7 +107,7 @@ public class BakedModelCableCover implements IBakedModel {
                xTexBackEnd = 14;
            }
        } else if (coverSide == EnumFacing.SOUTH) {
-            modelRotation = ModelRotation.X0_Y180;
+            rotation = ModelRotation.X0_Y180;

            if (hasWest) {
                xEnd = 14;
@@ -110,16 +121,16 @@ public class BakedModelCableCover implements IBakedModel {
                xTexBackStart = 2;
            }
        } else if (coverSide == EnumFacing.EAST) {
-            modelRotation = ModelRotation.X0_Y90;
+            rotation = ModelRotation.X0_Y90;
        } else if (coverSide == EnumFacing.WEST) {
-            modelRotation = ModelRotation.X0_Y270;
+            rotation = ModelRotation.X0_Y270;
        } else if (coverSide == EnumFacing.DOWN) {
-            modelRotation = ModelRotation.X90_Y0;
+            rotation = ModelRotation.X90_Y0;
        } else if (coverSide == EnumFacing.UP) {
-            modelRotation = ModelRotation.X270_Y0;
+            rotation = ModelRotation.X270_Y0;
        }

-        if (coverSide.getAxis() == EnumFacing.Axis.X || coverSide.getAxis() == EnumFacing.Axis.Z) {
+        if (coverSide.getAxis() != EnumFacing.Axis.Y) {
            if (hasDown) {
                yStart = 2;
                yTexEnd = 14;
@@ -140,14 +151,168 @@ public class BakedModelCableCover implements IBakedModel {

            .face(EnumFacing.UP, 0, 16, 0, 2, sprite)
            .face(EnumFacing.DOWN, 0, 16, 14, 16, sprite)
-            .face(EnumFacing.EAST, 14, 16, 0, 16, sprite)
-            .face(EnumFacing.WEST, 0, 2, 0, 16, sprite)
+            .face(EnumFacing.EAST, 14, 16, yTexStart, yTexEnd, sprite)
+            .face(EnumFacing.WEST, 0, 2, yTexStart, yTexEnd, sprite)

-            .rotate(modelRotation)
+            .rotate(rotation)

            .bake()
        );

+        addHolder(quads, rotation);
+    }
+
+    private static void addHollowCover(List<BakedQuad> quads, Cover cover, EnumFacing coverSide, EnumFacing side, long rand, boolean hasUp, boolean hasDown, boolean hasEast, boolean hasWest) {
+        IBlockState coverState = CoverManager.getBlockState(cover.getStack());
+
+        if (coverState == null) {
+            return;
+        }
+
+        IBakedModel coverModel = Minecraft.getMinecraft().getBlockRendererDispatcher().getModelForState(coverState);
+
+        TextureAtlasSprite sprite = getSprite(coverModel, coverState, side, rand);
+
+        ModelRotation rotation = ModelRotation.X0_Y0;
+
+        int xLeftStart = 13;
+        int xLeftEnd = 16;
+
+        int xLeftTexStart = 0;
+        int xLeftTexEnd = 3;
+
+        int xLeftTexBackStart = 13;
+        int xLeftTexBackEnd = 16;
+
+        int xRightStart = 0;
+        int xRightEnd = 3;
+
+        int xRightTexStart = 13;
+        int xRightTexEnd = 16;
+
+        int xRightTexBackStart = 0;
+        int xRightTexBackEnd = 3;
+
+        int yStart = 0;
+        int yEnd = 16;
+
+        int yTexStart = 0;
+        int yTexEnd = 16;
+
+        if (coverSide == EnumFacing.NORTH) {
+            if (hasEast) {
+                xLeftEnd = 14;
+                xLeftTexStart = 2;
+                xLeftTexBackEnd = 14;
+            }
+
+            if (hasWest) {
+                xRightStart = 2;
+                xRightTexEnd = 14;
+                xRightTexBackStart = 2;
+            }
+        } else if (coverSide == EnumFacing.SOUTH) {
+            rotation = ModelRotation.X0_Y180;
+
+            if (hasWest) {
+                xLeftEnd = 14;
+                xLeftTexStart = 2;
+                xLeftTexBackEnd = 14;
+            }
+
+            if (hasEast) {
+                xRightStart = 2;
+                xRightTexEnd = 14;
+                xRightTexBackStart = 2;
+            }
+        } else if (coverSide == EnumFacing.EAST) {
+            rotation = ModelRotation.X0_Y90;
+        } else if (coverSide == EnumFacing.WEST) {
+            rotation = ModelRotation.X0_Y270;
+        } else if (coverSide == EnumFacing.DOWN) {
+            rotation = ModelRotation.X90_Y0;
+        } else if (coverSide == EnumFacing.UP) {
+            rotation = ModelRotation.X270_Y0;
+        }
+
+        if (coverSide.getAxis() != EnumFacing.Axis.Y) {
+            if (hasDown) {
+                yStart = 2;
+                yTexEnd = 14;
+            }
+
+            if (hasUp) {
+                yEnd = 14;
+                yTexStart = 2;
+            }
+        }
+
+        quads.addAll(new CubeBuilder()
+            .from(xLeftStart, yStart, 0)
+            .to(xLeftEnd, yEnd, 2)
+
+            .face(EnumFacing.NORTH, xLeftTexStart, xLeftTexEnd, yTexStart, yTexEnd, sprite)
+            .face(EnumFacing.SOUTH, xLeftTexBackStart, xLeftTexBackEnd, yTexStart, yTexEnd, sprite)
+
+            .face(EnumFacing.UP, 13, 16, 0, 2, sprite)
+            .face(EnumFacing.DOWN, 13, 16, 14, 16, sprite)
+            .face(EnumFacing.EAST, 14, 16, yTexStart, yTexEnd, sprite)
+            .face(EnumFacing.WEST, 0, 2, yTexStart, yTexEnd, sprite)
+
+            .rotate(rotation)
+
+            .bake()
+        );
+
+        quads.addAll(new CubeBuilder()
+            .from(xRightStart, yStart, 0)
+            .to(xRightEnd, yEnd, 2)
+
+            .face(EnumFacing.NORTH, xRightTexStart, xRightTexEnd, yTexStart, yTexEnd, sprite)
+            .face(EnumFacing.SOUTH, xRightTexBackStart, xRightTexBackEnd, yTexStart, yTexEnd, sprite)
+
+            .face(EnumFacing.UP, 0, 3, 0, 2, sprite)
+            .face(EnumFacing.DOWN, 0, 3, 14, 16, sprite)
+            .face(EnumFacing.EAST, 14, 16, yTexStart, yTexEnd, sprite)
+            .face(EnumFacing.WEST, 0, 2, yTexStart, yTexEnd, sprite)
+
+            .rotate(rotation)
+
+            .bake()
+        );
+
+        quads.addAll(new CubeBuilder()
+            .from(3, yStart, 0)
+            .to(13, 3, 2)
+
+            .face(EnumFacing.NORTH, 3, 13, 13, yTexEnd, sprite)
+            .face(EnumFacing.SOUTH, 3, 13, 13, yTexEnd, sprite)
+
+            .face(EnumFacing.UP, 3, 13, 0, 2, sprite)
+            .face(EnumFacing.DOWN, 3, 13, 14, 16, sprite)
+
+            .rotate(rotation)
+
+            .bake()
+        );
+
+        quads.addAll(new CubeBuilder()
+            .from(3, 13, 0)
+            .to(13, yEnd, 2)
+
+            .face(EnumFacing.NORTH, 3, 13, yTexStart, 3, sprite)
+            .face(EnumFacing.SOUTH, 3, 13, yTexStart, 3, sprite)
+
+            .face(EnumFacing.UP, 3, 13, 0, 2, sprite)
+            .face(EnumFacing.DOWN, 3, 13, 14, 16, sprite)
+
+            .rotate(rotation)
+
+            .bake()
+        );
+    }
+
+    private static void addHolder(List<BakedQuad> quads, ModelRotation rotation) {
        if (GREY_SPRITE == null) {
            GREY_SPRITE = Minecraft.getMinecraft().getTextureMapBlocks().getAtlasSprite(RS.ID + ":blocks/generic_grey");
        }
@@ -163,7 +328,7 @@ public class BakedModelCableCover implements IBakedModel {
            .face(EnumFacing.UP, 0, 0, 4, 2, GREY_SPRITE)
            .face(EnumFacing.DOWN, 0, 0, 4, 2, GREY_SPRITE)

-            .rotate(modelRotation)
+            .rotate(rotation)

            .setUvLocked(false)

--- a/src/main/java/com/raoulvdberge/refinedstorage/render/model/baked/BakedModelCover.java
+++ b/src/main/java/com/raoulvdberge/refinedstorage/render/model/baked/BakedModelCover.java
@@ -3,17 +3,20 @@ package com.raoulvdberge.refinedstorage.render.model.baked;
 import com.google.common.cache.CacheBuilder;
 import com.google.common.cache.CacheLoader;
 import com.google.common.cache.LoadingCache;
+import com.raoulvdberge.refinedstorage.apiimpl.network.node.cover.Cover;
 import com.raoulvdberge.refinedstorage.item.ItemCover;
+import com.raoulvdberge.refinedstorage.util.RenderUtils;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.client.renderer.block.model.BakedQuad;
 import net.minecraft.client.renderer.block.model.IBakedModel;
 import net.minecraft.client.renderer.block.model.ItemCameraTransforms;
 import net.minecraft.client.renderer.block.model.ItemOverrideList;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
 import net.minecraft.entity.EntityLivingBase;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.EnumFacing;
 import net.minecraft.world.World;
-import net.minecraftforge.client.ForgeHooksClient;
+import net.minecraftforge.common.model.TRSRTransformation;
 import org.apache.commons.lang3.tuple.Pair;

 import javax.annotation.Nullable;
@@ -25,16 +28,16 @@ import java.util.Objects;

 public class BakedModelCover extends BakedModelCableCover {
    private class CacheKey {
-        private IBakedModel base;
        private IBlockState state;
        private ItemStack stack;
        private EnumFacing side;
+        private boolean hollow;

-        CacheKey(IBakedModel base, IBlockState state, ItemStack stack, EnumFacing side) {
-            this.base = base;
+        CacheKey(IBlockState state, ItemStack stack, EnumFacing side, boolean hollow) {
            this.state = state;
            this.stack = stack;
            this.side = side;
+            this.hollow = hollow;
        }

        @Override
@@ -49,7 +52,7 @@ public class BakedModelCover extends BakedModelCableCover {

            BakedModelCover.CacheKey cacheKey = (BakedModelCover.CacheKey) o;

-            return cacheKey.stack.getItem() == stack.getItem() && cacheKey.stack.getItemDamage() == stack.getItemDamage() && cacheKey.side == side && Objects.equals(cacheKey.state, state);
+            return cacheKey.hollow == hollow && cacheKey.stack.getItem() == stack.getItem() && cacheKey.stack.getItemDamage() == stack.getItemDamage() && cacheKey.side == side && Objects.equals(cacheKey.state, state);
        }

        @Override
@@ -58,6 +61,7 @@ public class BakedModelCover extends BakedModelCableCover {
            result = 31 * result + stack.getItemDamage();
            result = 31 * result + (side != null ? side.hashCode() : 0);
            result = 31 * result + (state != null ? state.hashCode() : 0);
+            result = 31 * result + Boolean.hashCode(hollow);
            return result;
        }
    }
@@ -65,9 +69,9 @@ public class BakedModelCover extends BakedModelCableCover {
    private static final LoadingCache<CacheKey, List<BakedQuad>> CACHE = CacheBuilder.newBuilder().build(new CacheLoader<CacheKey, List<BakedQuad>>() {
        @Override
        public List<BakedQuad> load(CacheKey key) {
-            List<BakedQuad> quads = new ArrayList<>(key.base.getQuads(key.state, key.side, 0));
+            List<BakedQuad> quads = new ArrayList<>();

-            addCover(quads, key.stack, EnumFacing.NORTH, key.side, 0, false, false, false, false);
+            addCoverOrHollow(quads, new Cover(key.stack, key.hollow), EnumFacing.NORTH, key.side, 0, false, false, false, false);

            return quads;
        }
@@ -75,13 +79,13 @@ public class BakedModelCover extends BakedModelCableCover {

    @Nullable
    private ItemStack stack;
-    private IBakedModel base;
+    private boolean hollow;

-    public BakedModelCover(IBakedModel base, @Nullable ItemStack stack) {
-        super(base);
+    public BakedModelCover(@Nullable ItemStack stack, boolean hollow) {
+        super(null);

-        this.base = base;
        this.stack = stack;
+        this.hollow = hollow;
    }

    @Override
@@ -90,7 +94,7 @@ public class BakedModelCover extends BakedModelCableCover {
            return Collections.emptyList();
        }

-        CacheKey key = new CacheKey(base, state, ItemCover.getItem(stack), side);
+        CacheKey key = new CacheKey(state, ItemCover.getItem(stack), side, hollow);

        return CACHE.getUnchecked(key);
    }
@@ -98,22 +102,52 @@ public class BakedModelCover extends BakedModelCableCover {
    @Override
    public ItemOverrideList getOverrides() {
        if (stack != null) {
-            return base.getOverrides();
+            return ItemOverrideList.NONE;
        }

        return new ItemOverrideList(Collections.emptyList()) {
            @Override
            public IBakedModel handleItemState(IBakedModel originalModel, ItemStack stack, @Nullable World world, @Nullable EntityLivingBase entity) {
-                return new BakedModelCover(base, stack);
+                return new BakedModelCover(stack, hollow);
            }
        };
    }

    @Override
    public Pair<? extends IBakedModel, Matrix4f> handlePerspective(ItemCameraTransforms.TransformType cameraTransformType) {
-        Pair<? extends IBakedModel, Matrix4f> matrix = base.handlePerspective(cameraTransformType);
-        Pair<? extends IBakedModel, Matrix4f> bakedModel = ForgeHooksClient.handlePerspective(this, cameraTransformType);
+        TRSRTransformation transform = RenderUtils.getDefaultBlockTransforms().get(cameraTransformType);

-        return Pair.of(bakedModel.getKey(), matrix.getRight());
+        return Pair.of(this, transform == null ? RenderUtils.EMPTY_MATRIX_TRANSFORM : transform.getMatrix());
    }
-}
+
+    @Override
+    public boolean isAmbientOcclusion() {
+        return true;
+    }
+
+    @Override
+    public boolean isGui3d() {
+        return true;
+    }
+
+    @Override
+    public boolean isBuiltInRenderer() {
+        return false;
+    }
+
+    @Override
+    public TextureAtlasSprite getParticleTexture() {
+        return null;
+    }
+
+    @Override
+    public boolean isAmbientOcclusion(IBlockState state) {
+        return true;
+    }
+
+    @Override
+    @SuppressWarnings("deprecation")
+    public ItemCameraTransforms getItemCameraTransforms() {
+        return ItemCameraTransforms.DEFAULT;
+    }
+}
--- a/src/main/java/com/raoulvdberge/refinedstorage/render/model/loader/CustomModelLoaderCover.java
+++ b/src/main/java/com/raoulvdberge/refinedstorage/render/model/loader/CustomModelLoaderCover.java
@@ -0,0 +1,25 @@
+package com.raoulvdberge.refinedstorage.render.model.loader;
+
+import com.raoulvdberge.refinedstorage.RS;
+import com.raoulvdberge.refinedstorage.render.model.ModelCover;
+import net.minecraft.client.resources.IResourceManager;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.client.model.ICustomModelLoader;
+import net.minecraftforge.client.model.IModel;
+
+public class CustomModelLoaderCover implements ICustomModelLoader {
+    @Override
+    public boolean accepts(ResourceLocation modelLocation) {
+        return modelLocation.getResourceDomain().equals(RS.ID) && (modelLocation.getResourcePath().equals("cover") || modelLocation.getResourcePath().equals("hollow_cover"));
+    }
+
+    @Override
+    public IModel loadModel(ResourceLocation modelLocation) {
+        return new ModelCover(modelLocation.getResourcePath().equals("hollow_cover"));
+    }
+
+    @Override
+    public void onResourceManagerReload(IResourceManager resourceManager) {
+        // NO OP
+    }
+}
--- a/src/main/resources/assets/refinedstorage/blockstates/cover.json
+++ b/src/main/resources/assets/refinedstorage/blockstates/cover.json
@@ -2,8 +2,7 @@
  "forge_marker": 1,
  "defaults": {
    "textures": {
-      "cable": "refinedstorage:blocks/cable",
-      "line": "refinedstorage:blocks/generic_grey"
+      "cable": "refinedstorage:blocks/cable"
    },
    "model": "refinedstorage:cable_core",
    "uvlock": true
--- a/src/main/resources/assets/refinedstorage/blockstates/hollow_cover.json
+++ b/src/main/resources/assets/refinedstorage/blockstates/hollow_cover.json
@@ -0,0 +1,18 @@
+{
+  "forge_marker": 1,
+  "defaults": {
+    "textures": {
+      "cable": "refinedstorage:blocks/cable"
+    },
+    "model": "refinedstorage:cable_core",
+    "uvlock": true
+  },
+  "variants": {
+    "inventory": [
+      {
+        "model": "refinedstorage:cable_core",
+        "transform": "forge:default-block"
+      }
+    ]
+  }
+}
--- a/src/main/resources/assets/refinedstorage/lang/en_us.lang
+++ b/src/main/resources/assets/refinedstorage/lang/en_us.lang
@@ -292,6 +292,7 @@ item.refinedstorage:security_card.name=Security Card
 item.refinedstorage:security_card.owner=Bound to: %s
 item.refinedstorage:cutting_tool.name=Cutting Tool
 item.refinedstorage:cover.name=Cover
+item.refinedstorage:hollow_cover.name=Hollow Cover

 commands.refinedstorage.createdisk.usage=/createdisk <player> <item> <metadata> <id>
 commands.refinedstorage.createdisk.error.notADisk=The given disk item is not a disk.