Oh god so many blocks...

Block reg refactor, part 1

src/main/java/de/ellpeck/actuallyadditions/data/BlockRecipeGenerator.java

@@ -28,7 +28,7 @@ public class BlockRecipeGenerator extends RecipeProvider {
         //Farmer
         Recipe.shaped(ActuallyBlocks.FARMER.get())
             .pattern("ISI", "SCS", "ISI")
-            .key('I', ActuallyBlocks.CRYSTAL_ENORI.get())
+            .key('I', ActuallyBlocks.ENORI_CRYSTAL.getItem())
             .key('C', ActuallyBlocks.IRON_CASING.get())
             .key('S', Tags.Items.SEEDS)
             .build(consumer);
@@ -161,6 +161,25 @@ public class BlockRecipeGenerator extends RecipeProvider {
             .key('R', ActuallyBlocks.LASER_RELAY_ADVANCED.get())
             .key('X', ActuallyItems.RESTONIA_CRYSTAL.get())
             .build(consumer);
+
+        // Whitelist Item Laser Relay
+        Recipe.shapeless(ActuallyBlocks.LASER_RELAY_ITEM_WHITELIST.get())
+            .ingredients(ActuallyBlocks.LASER_RELAY_ITEM.get(), ActuallyItems.COIL_ADVANCED.get(), ActuallyItems.BLACK_QUARTZ.get())
+            .build(consumer);
+
+        // Item Interface
+        Recipe.shaped(ActuallyBlocks.ITEM_VIEWER.get())
+            .pattern("OBO", "RCR", "OBO")
+            .key('B', Tags.Items.DUSTS_REDSTONE)
+            .key('O', ActuallyItems.COIL.get())
+            .key('R', ActuallyItems.RESTONIA_CRYSTAL.get())
+            .key('C', Tags.Items.CHESTS_WOODEN)
+            .build(consumer);
+
+        // Hopping Item Interface
+        Recipe.shapeless(ActuallyBlocks.ITEM_VIEWER_HOPPING.get()).ingredients(ActuallyBlocks.ITEM_VIEWER.get()).build(consumer);
+
+
     }
 
     @Override

src/main/java/de/ellpeck/actuallyadditions/mod/ActuallyAdditions.java

@@ -18,7 +18,6 @@ import de.ellpeck.actuallyadditions.mod.data.WorldData;
 import de.ellpeck.actuallyadditions.mod.entity.InitEntities;
 import de.ellpeck.actuallyadditions.mod.event.CommonEvents;
 import de.ellpeck.actuallyadditions.mod.fluids.InitFluids;
-import de.ellpeck.actuallyadditions.mod.gen.AAWorldGen;
 import de.ellpeck.actuallyadditions.mod.inventory.ActuallyContainers;
 import de.ellpeck.actuallyadditions.mod.items.ActuallyItems;
 import de.ellpeck.actuallyadditions.mod.items.ItemCoffee;

src/main/java/de/ellpeck/actuallyadditions/mod/blocks/AABlockItem.java

@@ -0,0 +1,10 @@
+package de.ellpeck.actuallyadditions.mod.blocks;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.BlockItem;
+
+public class AABlockItem extends BlockItem {
+    public AABlockItem(Block blockIn, Properties builder) {
+        super(blockIn, builder);
+    }
+}

src/main/java/de/ellpeck/actuallyadditions/mod/blocks/ActuallyBlock.java

@@ -0,0 +1,64 @@
+package de.ellpeck.actuallyadditions.mod.blocks;
+
+import de.ellpeck.actuallyadditions.mod.ActuallyAdditions;
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.SlabBlock;
+import net.minecraft.block.StairsBlock;
+import net.minecraft.item.Item;
+
+import java.util.function.Supplier;
+
+/**
+ * Using a custom class here to declare common rules between all of our blocks.
+ * This also provides a simple instance of check for our blocks.
+ *
+ * @implNote Every block should extend this class in some form or use the {@link IActuallyBlock}
+ */
+public class ActuallyBlock extends Block implements IActuallyBlock {
+    public ActuallyBlock(Properties properties) {
+        super(properties);
+    }
+
+    @Override
+    public AABlockItem createBlockItem() {
+        return new AABlockItem(this, this.getItemProperties());
+    }
+
+    @Override
+    public Item.Properties getItemProperties() {
+        return new Item.Properties().group(ActuallyAdditions.GROUP);
+    }
+
+    public static class Stairs extends StairsBlock implements IActuallyBlock {
+        public Stairs(Supplier<BlockState> state, Properties properties) {
+            super(state, properties);
+        }
+
+        @Override
+        public AABlockItem createBlockItem() {
+            return new AABlockItem(this, this.getItemProperties());
+        }
+
+        @Override
+        public Item.Properties getItemProperties() {
+            return new Item.Properties().group(ActuallyAdditions.GROUP);
+        }
+    }
+
+    public static class Slabs extends SlabBlock implements IActuallyBlock {
+        public Slabs(Properties properties) {
+            super(properties);
+        }
+
+        @Override
+        public AABlockItem createBlockItem() {
+            return new AABlockItem(this, this.getItemProperties());
+        }
+
+        @Override
+        public Item.Properties getItemProperties() {
+            return new Item.Properties().group(ActuallyAdditions.GROUP);
+        }
+    }
+}

src/main/java/de/ellpeck/actuallyadditions/mod/blocks/ActuallyBlocks.java

@@ -13,9 +13,12 @@ package de.ellpeck.actuallyadditions.mod.blocks;
 import de.ellpeck.actuallyadditions.mod.ActuallyAdditions;
 import de.ellpeck.actuallyadditions.mod.blocks.base.BlockPlant;
 import de.ellpeck.actuallyadditions.mod.items.ActuallyItems;
-import de.ellpeck.actuallyadditions.mod.items.metalists.TheCrystals;
+import de.ellpeck.actuallyadditions.mod.items.metalists.Crystals;
+import de.ellpeck.actuallyadditions.mod.tile.*;
+import de.ellpeck.actuallyadditions.registration.AABlockReg;
 import net.minecraft.block.*;
 import net.minecraft.block.material.Material;
+import net.minecraft.item.Item;
 import net.minecraftforge.common.ToolType;
 import net.minecraftforge.fml.RegistryObject;
 import net.minecraftforge.registries.DeferredRegister;
@@ -24,34 +27,136 @@ import net.minecraftforge.registries.ForgeRegistries;
 public final class ActuallyBlocks {
     public static final DeferredRegister<Block> BLOCKS = DeferredRegister.create(ForgeRegistries.BLOCKS, ActuallyAdditions.MODID);
 
+    private static final Item.Properties defaultBlockItemProperties = new Item.Properties().group(ActuallyAdditions.GROUP).maxStackSize(64);
+
     public static final AbstractBlock.Properties miscBlockProperties = AbstractBlock.Properties.create(Material.ROCK).harvestLevel(1).harvestTool(ToolType.PICKAXE).hardnessAndResistance(1.5f, 10f);
-    @Deprecated
+
-    public static final RegistryObject<Block> blockMisc = BLOCKS.register("misc", () -> new Block(miscBlockProperties)); // TODO this isnt a real block?
+    // Casings
-    public static final RegistryObject<Block> WOOD_CASING = BLOCKS.register("wood_casing", () -> new Block(miscBlockProperties));
+    public static final AABlockReg<ActuallyBlock, AABlockItem, ?> WOOD_CASING = new AABlockReg<>("wood_casing", () -> new ActuallyBlock(miscBlockProperties), ActuallyBlock::createBlockItem);
-    public static final RegistryObject<Block> IRON_CASING = BLOCKS.register("iron_casing", () -> new Block(miscBlockProperties));
+    public static final AABlockReg<ActuallyBlock, AABlockItem, ?> IRON_CASING = new AABlockReg<>("iron_casing", () -> new ActuallyBlock(miscBlockProperties), ActuallyBlock::createBlockItem);
-    public static final RegistryObject<Block> ENDER_CASING = BLOCKS.register("ender_casing", () -> new Block(miscBlockProperties));
+    public static final AABlockReg<ActuallyBlock, AABlockItem, ?> ENDER_CASING = new AABlockReg<>("ender_casing", () -> new ActuallyBlock(miscBlockProperties), ActuallyBlock::createBlockItem);
-    public static final RegistryObject<Block> LAVA_CASING = BLOCKS.register("lava_casing", () -> new Block(miscBlockProperties));
+    public static final AABlockReg<ActuallyBlock, AABlockItem, ?> LAVA_FACTORY_CASING = new AABlockReg<>("lava_factory_casing", () -> new ActuallyBlock(miscBlockProperties), ActuallyBlock::createBlockItem);
-    public static final RegistryObject<Block> WILD_PLANT = BLOCKS.register("wild", BlockWildPlant::new);
+
-    public static final RegistryObject<Block> FEEDER = BLOCKS.register("feeder", BlockFeeder::new);
+    // Machines
-    public static final RegistryObject<Block> GRINDER = BLOCKS.register("grinder", () -> new BlockGrinder(false));
+    public static final AABlockReg<BlockFeeder, AABlockItem, TileEntityFeeder> FEEDER = new AABlockReg<>("feeder", BlockFeeder::new, (b) -> new AABlockItem(b, defaultBlockItemProperties), TileEntityFeeder::new);
-    public static final RegistryObject<Block> GRINDER_DOUBLE = BLOCKS.register("grinder_double", () -> new BlockGrinder(true));
+    public static final AABlockReg<BlockCrusher, AABlockItem, TileEntityCrusher> CRUSHER = new AABlockReg<>("crusher", () -> new BlockCrusher(false),
-    
+        (b) -> new AABlockItem(b, defaultBlockItemProperties), TileEntityCrusher::new);
-    public static final RegistryObject<Block> CRYSTAL_CLUSTER_REDSTONE = BLOCKS.register("crystal_cluster_redstone", () -> new BlockCrystalCluster(TheCrystals.REDSTONE));
+    public static final AABlockReg<BlockCrusher, AABlockItem, TileEntityCrusher> CRUSHER_DOUBLE = new AABlockReg<>("crusher_double", () -> new BlockCrusher(false),
-    public static final RegistryObject<Block> CRYSTAL_CLUSTER_LAPIS = BLOCKS.register("crystal_cluster_lapis", () -> new BlockCrystalCluster(TheCrystals.LAPIS));
+        (b) -> new AABlockItem(b, defaultBlockItemProperties), TileEntityCrusherDouble::new);
-    public static final RegistryObject<Block> CRYSTAL_CLUSTER_DIAMOND = BLOCKS.register("crystal_cluster_diamond", () -> new BlockCrystalCluster(TheCrystals.DIAMOND));
+
-    public static final RegistryObject<Block> CRYSTAL_CLUSTER_COAL = BLOCKS.register("crystal_cluster_coal", () -> new BlockCrystalCluster(TheCrystals.COAL));
+    public static final AABlockReg<BlockEnergizer, AABlockItem, TileEntityEnergizer> ENERGIZER = new AABlockReg<>("energizer", () -> new BlockEnergizer(true),
-    public static final RegistryObject<Block> CRYSTAL_CLUSTER_EMERALD = BLOCKS.register("crystal_cluster_emerald", () -> new BlockCrystalCluster(TheCrystals.EMERALD));
+        (b) -> new AABlockItem(b, defaultBlockItemProperties), TileEntityEnergizer::new);
-    public static final RegistryObject<Block> CRYSTAL_CLUSTER_IRON = BLOCKS.register("crystal_cluster_iron", () -> new BlockCrystalCluster(TheCrystals.IRON));
+    public static final AABlockReg<BlockEnergizer, AABlockItem, TileEntityEnergizer> ENERVATOR = new AABlockReg<>("enervator", () -> new BlockEnergizer(false),
-    public static final RegistryObject<Block> BATTERY_BOX = BLOCKS.register("battery_box", BlockBatteryBox::new);
+        (b) -> new AABlockItem(b, defaultBlockItemProperties), TileEntityEnergizer::new);
-    public static final RegistryObject<Block> ITEM_VIEWER_HOPPING = BLOCKS.register("item_viewer_hopping", BlockItemViewerHopping::new);
+
-    public static final RegistryObject<Block> FARMER = BLOCKS.register("farmer", BlockFarmer::new);
+    public static final AABlockReg<BlockLavaFactoryController, AABlockItem, TileEntityLavaFactoryController> LAVA_FACTORY_CONTROLLER
-    public static final RegistryObject<Block> BIOREACTOR = BLOCKS.register("bio_reactor", BlockBioReactor::new);
+        = new AABlockReg<>("lava_factory_controller", BlockLavaFactoryController::new, (b) -> new AABlockItem(b, defaultBlockItemProperties), TileEntityLavaFactoryController::new);
-    public static final RegistryObject<Block> EMPOWERER = BLOCKS.register("empowerer", BlockEmpowerer::new);
+
+    public static final AABlockReg<BlockLampPowerer, AABlockItem, ?> LAMP_POWERER = new AABlockReg<>("lamp_powerer", BlockLampPowerer::new, (b) -> new AABlockItem(b, defaultBlockItemProperties));
+
+    public static final AABlockReg<BlockCanolaPress, AABlockItem, TileEntityCanolaPress> CANOLA_PRESS = new AABlockReg<>("canola_press", BlockCanolaPress::new,
+        (b) -> new AABlockItem(b, defaultBlockItemProperties), TileEntityCanolaPress::new);
+
+    public static final AABlockReg<BlockLeafGenerator, AABlockItem, TileEntityLeafGenerator> LEAF_GENERATOR = new AABlockReg<>("leaf_generator", BlockLeafGenerator::new,
+        (b) -> new AABlockItem(b, defaultBlockItemProperties) , TileEntityLeafGenerator::new);
+
+    public static final AABlockReg<BlockXPSolidifier, AABlockItem, TileEntityXPSolidifier> XP_SOLIDIFIER = new AABlockReg<>("xp_solidifier", BlockXPSolidifier::new,
+        (b) -> new AABlockItem(b, defaultBlockItemProperties), TileEntityXPSolidifier::new);
+
+    public static final AABlockReg<BlockBreaker, AABlockItem, TileEntityBreaker> BREAKER = new AABlockReg<>("breaker", () -> new BlockBreaker(false),
+        (b) -> new AABlockItem(b, defaultBlockItemProperties), TileEntityBreaker::new);
+    public static final AABlockReg<BlockBreaker, AABlockItem, TileEntityPlacer> PLACER = new AABlockReg<>("placer", () -> new BlockBreaker(true),
+        (b) -> new AABlockItem(b, defaultBlockItemProperties), TileEntityPlacer::new);
+    public static final AABlockReg<BlockDropper, AABlockItem, TileEntityDropper> DROPPER = new AABlockReg<>("dropper", BlockDropper::new,
+        (b) -> new AABlockItem(b, defaultBlockItemProperties), TileEntityDropper::new);
+    public static final AABlockReg<BlockFluidCollector, AABlockItem, TileEntityFluidCollector> FLUID_PLACER = new AABlockReg<>("fluid_placer", () -> new BlockFluidCollector(true),
+        (b) -> new AABlockItem(b, defaultBlockItemProperties), TileEntityFluidCollector::new);
+    public static final AABlockReg<BlockFluidCollector, AABlockItem, TileEntityFluidPlacer> FLUID_COLLECTOR = new AABlockReg<>("fluid_collector", () -> new BlockFluidCollector(false),
+        (b) -> new AABlockItem(b, defaultBlockItemProperties), TileEntityFluidPlacer::new);
+
+    public static final AABlockReg<BlockFarmer, AABlockItem, TileEntityFarmer> FARMER = new AABlockReg<>("farmer", BlockFarmer::new,
+        (b) -> new AABlockItem(b, defaultBlockItemProperties), TileEntityFarmer::new);
+
+    public static final AABlockReg<BlockBioReactor, AABlockItem, TileEntityBioReactor> BIOREACTOR = new AABlockReg<>("bio_reactor", BlockBioReactor::new,
+        (b) -> new AABlockItem(b, defaultBlockItemProperties), TileEntityBioReactor::new);
+
+    // Crystal Blocks
+    public static final AABlockReg<BlockCrystal, AABlockItem,?> ENORI_CRYSTAL = new AABlockReg<>("enori_crystal_block", () -> new BlockCrystal(false), BlockCrystal::createBlockItem);
+    public static final AABlockReg<BlockCrystal, AABlockItem,?> RESTONIA_CRYSTAL = new AABlockReg<>("restonia_crystal_block", () -> new BlockCrystal(false), BlockCrystal::createBlockItem);
+    public static final AABlockReg<BlockCrystal, AABlockItem,?> PALIS_CRYSTAL = new AABlockReg<>("palis_crystal_block", () -> new BlockCrystal(false), BlockCrystal::createBlockItem);
+    public static final AABlockReg<BlockCrystal, AABlockItem,?> DIAMATINE_CRYSTAL = new AABlockReg<>("diamatine_crystal_block", () -> new BlockCrystal(false), BlockCrystal::createBlockItem);
+    public static final AABlockReg<BlockCrystal, AABlockItem,?> VOID_CRYSTAL = new AABlockReg<>("void_crystal_block", () -> new BlockCrystal(false), BlockCrystal::createBlockItem);
+    public static final AABlockReg<BlockCrystal, AABlockItem,?> EMERADIC_CRYSTAL = new AABlockReg<>("emeradic_crystal_block", () -> new BlockCrystal(false), BlockCrystal::createBlockItem);
+    // Empowered Crystal Blocks
+    public static final AABlockReg<BlockCrystal, AABlockItem,?> EMPOWERED_ENORI_CRYSTAL = new AABlockReg<>("empowered_enori_crystal_block", () -> new BlockCrystal(true), BlockCrystal::createBlockItem);
+    public static final AABlockReg<BlockCrystal, AABlockItem,?> EMPOWERED_RESTONIA_CRYSTAL = new AABlockReg<>("empowered_restonia_crystal_block", () -> new BlockCrystal(true), BlockCrystal::createBlockItem);
+    public static final AABlockReg<BlockCrystal, AABlockItem,?> EMPOWERED_PALIS_CRYSTAL = new AABlockReg<>("empowered_palis_crystal_block", () -> new BlockCrystal(true), BlockCrystal::createBlockItem);
+    public static final AABlockReg<BlockCrystal, AABlockItem,?> EMPOWERED_DIAMATINE_CRYSTAL = new AABlockReg<>("empowered_diamatine_crystal_block", () -> new BlockCrystal(true), BlockCrystal::createBlockItem);
+    public static final AABlockReg<BlockCrystal, AABlockItem,?> EMPOWERED_VOID_CRYSTAL = new AABlockReg<>("empowered_void_crystal_block", () -> new BlockCrystal(true), BlockCrystal::createBlockItem);
+    public static final AABlockReg<BlockCrystal, AABlockItem,?> EMPOWERED_EMERADIC_CRYSTAL = new AABlockReg<>("empowered_emeradic_crystal_block", () -> new BlockCrystal(true), BlockCrystal::createBlockItem);
+    // Crystal Clusters
+    public static final AABlockReg<CrystalClusterBlock, AABlockItem, ?> ENORI_CRYSTAL_CLUSTER = new AABlockReg<>("enori_crystal_cluster", () -> new CrystalClusterBlock(Crystals.IRON), (b) -> new AABlockItem(b, defaultBlockItemProperties));
+    public static final AABlockReg<CrystalClusterBlock, AABlockItem, ?> RESTONIA_CRYSTAL_CLUSTER = new AABlockReg<>("restonia_crystal_cluster", () -> new CrystalClusterBlock(Crystals.REDSTONE), (b) -> new AABlockItem(b, defaultBlockItemProperties));
+    public static final AABlockReg<CrystalClusterBlock, AABlockItem, ?> PALIS_CRYSTAL_CLUSTER = new AABlockReg<>("palis_crystal_cluster", () -> new CrystalClusterBlock(Crystals.LAPIS), (b) -> new AABlockItem(b, defaultBlockItemProperties));
+    public static final AABlockReg<CrystalClusterBlock, AABlockItem, ?> DIAMATINE_CRYSTAL_CLUSTER = new AABlockReg<>("diamatine_crystal_cluster", () -> new CrystalClusterBlock(Crystals.DIAMOND), (b) -> new AABlockItem(b, defaultBlockItemProperties));
+    public static final AABlockReg<CrystalClusterBlock, AABlockItem, ?> VOID_CRYSTAL_CLUSTER = new AABlockReg<>("void_crystal_cluster", () -> new CrystalClusterBlock(Crystals.COAL), (b) -> new AABlockItem(b, defaultBlockItemProperties));
+    public static final AABlockReg<CrystalClusterBlock, AABlockItem, ?> EMERADIC_CRYSTAL_CLUSTER = new AABlockReg<>("emeradic_crystal_cluster", () -> new CrystalClusterBlock(Crystals.EMERALD), (b) -> new AABlockItem(b, defaultBlockItemProperties));
+
+    // LAMPS! SO MANY LAMPS
+    public static final AABlockReg<BlockColoredLamp, AABlockItem, ?> LAMP_WHITE = new AABlockReg<>("lamp_white", BlockColoredLamp::new, (b) -> new AABlockItem(b, defaultBlockItemProperties));
+    public static final AABlockReg<BlockColoredLamp, AABlockItem, ?> LAMP_ORANGE = new AABlockReg<>("lamp_orange", BlockColoredLamp::new, (b) -> new AABlockItem(b, defaultBlockItemProperties));
+    public static final AABlockReg<BlockColoredLamp, AABlockItem, ?> LAMP_MAGENTA = new AABlockReg<>("lamp_magenta", BlockColoredLamp::new, (b) -> new AABlockItem(b, defaultBlockItemProperties));
+    public static final AABlockReg<BlockColoredLamp, AABlockItem, ?> LAMP_LIGHT_BLUE = new AABlockReg<>("lamp_light_blue", BlockColoredLamp::new, (b) -> new AABlockItem(b, defaultBlockItemProperties));
+    public static final AABlockReg<BlockColoredLamp, AABlockItem, ?> LAMP_YELLOW = new AABlockReg<>("lamp_yellow", BlockColoredLamp::new, (b) -> new AABlockItem(b, defaultBlockItemProperties));
+    public static final AABlockReg<BlockColoredLamp, AABlockItem, ?> LAMP_LIME = new AABlockReg<>("lamp_lime", BlockColoredLamp::new, (b) -> new AABlockItem(b, defaultBlockItemProperties));
+    public static final AABlockReg<BlockColoredLamp, AABlockItem, ?> LAMP_PINK = new AABlockReg<>("lamp_pink", BlockColoredLamp::new, (b) -> new AABlockItem(b, defaultBlockItemProperties));
+    public static final AABlockReg<BlockColoredLamp, AABlockItem, ?> LAMP_GRAY = new AABlockReg<>("lamp_gray", BlockColoredLamp::new, (b) -> new AABlockItem(b, defaultBlockItemProperties));
+    public static final AABlockReg<BlockColoredLamp, AABlockItem, ?> LAMP_LIGHT_GRAY = new AABlockReg<>("lamp_light_gray", BlockColoredLamp::new, (b) -> new AABlockItem(b, defaultBlockItemProperties));
+    public static final AABlockReg<BlockColoredLamp, AABlockItem, ?> LAMP_CYAN = new AABlockReg<>("lamp_cyan", BlockColoredLamp::new, (b) -> new AABlockItem(b, defaultBlockItemProperties));
+    public static final AABlockReg<BlockColoredLamp, AABlockItem, ?> LAMP_PURPLE = new AABlockReg<>("lamp_purple", BlockColoredLamp::new, (b) -> new AABlockItem(b, defaultBlockItemProperties));
+    public static final AABlockReg<BlockColoredLamp, AABlockItem, ?> LAMP_BLUE = new AABlockReg<>("lamp_blue", BlockColoredLamp::new, (b) -> new AABlockItem(b, defaultBlockItemProperties));
+    public static final AABlockReg<BlockColoredLamp, AABlockItem, ?> LAMP_BROWN = new AABlockReg<>("lamp_brown", BlockColoredLamp::new, (b) -> new AABlockItem(b, defaultBlockItemProperties));
+    public static final AABlockReg<BlockColoredLamp, AABlockItem, ?> LAMP_GREEN = new AABlockReg<>("lamp_green", BlockColoredLamp::new, (b) -> new AABlockItem(b, defaultBlockItemProperties));
+    public static final AABlockReg<BlockColoredLamp, AABlockItem, ?> LAMP_RED = new AABlockReg<>("lamp_red", BlockColoredLamp::new, (b) -> new AABlockItem(b, defaultBlockItemProperties));
+    public static final AABlockReg<BlockColoredLamp, AABlockItem, ?> LAMP_BLACK = new AABlockReg<>("lamp_black", BlockColoredLamp::new, (b) -> new AABlockItem(b, defaultBlockItemProperties));
+
+    // Empowerer / Display Stands
+    public static final AABlockReg<BlockEmpowerer, AABlockItem, TileEntityEmpowerer> EMPOWERER = new AABlockReg<>("empowerer", BlockEmpowerer::new,
+        (b) -> new AABlockItem(b, defaultBlockItemProperties), TileEntityEmpowerer::new);
+    public static final AABlockReg<BlockDisplayStand, AABlockItem, TileEntityDisplayStand> DISPLAY_STAND = new AABlockReg<>("display_stand", BlockDisplayStand::new,
+        (b) -> new AABlockItem(b, defaultBlockItemProperties), TileEntityDisplayStand::new);
+
+    // Interface Blocks
+    public static final AABlockReg<BlockPlayerInterface, AABlockItem, TileEntityPlayerInterface> PLAYER_INTERFACE = new AABlockReg<>("player_interface", BlockPlayerInterface::new,
+        (b) -> new AABlockItem(b, defaultBlockItemProperties), TileEntityPlayerInterface::new);
+    public static final AABlockReg<BlockItemInterface, AABlockItem, TileEntityItemInterface> ITEM_VIEWER = new AABlockReg<>("item_viewer", BlockItemInterface::new,
+        (b) -> new AABlockItem(b, defaultBlockItemProperties), TileEntityItemInterface::new);
+    public static final AABlockReg<BlockItemInterfaceHopping, AABlockItem, TileEntityItemInterfaceHopping> ITEM_VIEWER_HOPPING = new AABlockReg<>("item_viewer_hopping", BlockItemInterfaceHopping::new,
+        (b) -> new AABlockItem(b, defaultBlockItemProperties), TileEntityItemInterfaceHopping::new);
+
+    // Phantom stuff
+    public static final AABlockReg<BlockPhantom, AABlockItem, TileEntityPhantomFace> PHANTOMFACE = new AABlockReg<>("phantomface", () -> new BlockPhantom(BlockPhantom.Type.FACE),
+        (b) -> new AABlockItem(b, defaultBlockItemProperties), TileEntityPhantomFace::new);
+    public static final AABlockReg<BlockPhantom, AABlockItem, TileEntityPhantomPlacer> PHANTOM_PLACER = new AABlockReg<>("phantom_placer", () -> new BlockPhantom(BlockPhantom.Type.PLACER),
+        (b) -> new AABlockItem(b, defaultBlockItemProperties), TileEntityPhantomPlacer::new);
+    public static final AABlockReg<BlockPhantom, AABlockItem, TileEntityPhantomLiquiface> PHANTOM_LIQUIFACE = new AABlockReg<>("phantom_liquiface", () -> new BlockPhantom(BlockPhantom.Type.LIQUIFACE),
+        (b) -> new AABlockItem(b, defaultBlockItemProperties), TileEntityPhantomLiquiface::new);
+    public static final AABlockReg<BlockPhantom, AABlockItem, TileEntityPhantomEnergyface> PHANTOM_ENERGYFACE = new AABlockReg<>("phantom_energyface", () -> new BlockPhantom(BlockPhantom.Type.ENERGYFACE),
+        (b) -> new AABlockItem(b, defaultBlockItemProperties), TileEntityPhantomEnergyface::new);
+    public static final AABlockReg<BlockPhantom, AABlockItem, TileEntityPhantomRedstoneface> PHANTOM_REDSTONEFACE = new AABlockReg<>("phantom_redstoneface", () -> new BlockPhantom(BlockPhantom.Type.REDSTONEFACE),
+        (b) -> new AABlockItem(b, defaultBlockItemProperties), TileEntityPhantomRedstoneface::new);
+    public static final AABlockReg<BlockPhantom, AABlockItem, TileEntityPhantomBreaker> PHANTOM_BREAKER = new AABlockReg<>("phantom_breaker", () -> new BlockPhantom(BlockPhantom.Type.BREAKER),
+        (b) -> new AABlockItem(b, defaultBlockItemProperties), TileEntityPhantomBreaker::new);
+
+    // Misc Tiles
+    public static final AABlockReg<BlockBatteryBox, AABlockItem, TileEntityBatteryBox> BATTERY_BOX = new AABlockReg<>("battery_box", BlockBatteryBox::new,
+        (b) -> new AABlockItem(b, defaultBlockItemProperties), TileEntityBatteryBox::new);
+
+
+
+    //public static final RegistryObject<Block> WILD_PLANT = BLOCKS.register("wild", BlockWildPlant::new); //TODO: what is this?
     public static final RegistryObject<Block> TINY_TORCH = BLOCKS.register("tiny_torch", BlockTinyTorch::new);
     public static final RegistryObject<Block> SHOCK_SUPPRESSOR = BLOCKS.register("shock_suppressor", BlockShockSuppressor::new);
-    public static final RegistryObject<Block> DISPLAY_STAND = BLOCKS.register("display_stand", BlockDisplayStand::new);
-    public static final RegistryObject<Block> PLAYER_INTERFACE = BLOCKS.register("player_interface", BlockPlayerInterface::new);
-    public static final RegistryObject<Block> ITEM_VIEWER = BLOCKS.register("item_viewer", BlockItemViewer::new);
     public static final RegistryObject<Block> FIREWORK_BOX = BLOCKS.register("firework_box", BlockFireworkBox::new);
     public static final RegistryObject<Block> MINER = BLOCKS.register("miner", BlockVerticalDigger::new);
     public static final RegistryObject<Block> ATOMIC_RECONSTRUCTOR = BLOCKS.register("atomic_reconstructor", BlockAtomicReconstructor::new);
@@ -63,8 +168,7 @@ public final class ActuallyBlocks {
     public static final RegistryObject<Block> LASER_RELAY_ITEM_WHITELIST = BLOCKS.register("laser_relay_item_whitelist", () -> new BlockLaserRelay(BlockLaserRelay.Type.ITEM_WHITELIST));
     public static final RegistryObject<Block> RANGED_COLLECTOR = BLOCKS.register("ranged_collector", BlockRangedCollector::new);
     public static final RegistryObject<Block> DIRECTIONAL_BREAKER = BLOCKS.register("directional_breaker", BlockDirectionalBreaker::new);
-    public static final RegistryObject<Block> LEAF_GENERATOR = BLOCKS.register("leaf_generator", BlockLeafGenerator::new);
+
-    public static final RegistryObject<Block> XP_SOLIDIFIER = BLOCKS.register("xp_solidifier", BlockXPSolidifier::new);
     public static final RegistryObject<Block> ETHETIC_GREEN_BLOCK = BLOCKS.register("ethetic_green_block", BlockGeneric::new);
     public static final RegistryObject<Block> ETHETIC_WHITE_BLOCK = BLOCKS.register("ethetic_white_block", BlockGeneric::new);
     public static final RegistryObject<Block> ETHETIC_GREEN_STAIRS = BLOCKS.register("ethetic_green_stairs", () -> new StairsBlock(() -> ETHETIC_GREEN_BLOCK.get().getDefaultState(), AbstractBlock.Properties.from(ETHETIC_GREEN_BLOCK.get())));
@@ -74,51 +178,8 @@ public final class ActuallyBlocks {
     public static final RegistryObject<Block> ETHETIC_GREEN_WALL = BLOCKS.register("ethetic_green_wall", () -> new WallBlock(AbstractBlock.Properties.from(ETHETIC_GREEN_BLOCK.get())));
     public static final RegistryObject<Block> ETHETIC_WHITE_WALL = BLOCKS.register("ethetic_white_wall", () -> new WallBlock(AbstractBlock.Properties.from(ETHETIC_WHITE_BLOCK.get())));
 
-    public static final RegistryObject<Block> CRYSTAL_ENORI = BLOCKS.register("crystal_enori_block", () -> new BlockCrystal(false));
-    public static final RegistryObject<Block> CRYSTAL_RESTONIA = BLOCKS.register("crystal_restonia_block", () -> new BlockCrystal(false));
-    public static final RegistryObject<Block> CRYSTAL_PALIS = BLOCKS.register("crystal_palis_block", () -> new BlockCrystal(false));
-    public static final RegistryObject<Block> CRYSTAL_DIAMATINE = BLOCKS.register("crystal_diamatine_block", () -> new BlockCrystal(false));
-    public static final RegistryObject<Block> CRYSTAL_VOID = BLOCKS.register("crystal_void_block", () -> new BlockCrystal(false));
-    public static final RegistryObject<Block> CRYSTAL_EMERADIC = BLOCKS.register("crystal_emeradic_block", () -> new BlockCrystal(false));
 
-    public static final RegistryObject<Block> CRYSTAL_EMPOWERED_ENORI = BLOCKS.register("crystal_enori_empowered_block", () -> new BlockCrystal(true));
-    public static final RegistryObject<Block> CRYSTAL_EMPOWERED_RESTONIA = BLOCKS.register("crystal_restonia_empowered_block", () -> new BlockCrystal(true));
-    public static final RegistryObject<Block> CRYSTAL_EMPOWERED_PALIS = BLOCKS.register("crystal_palis_empowered_block", () -> new BlockCrystal(true));
-    public static final RegistryObject<Block> CRYSTAL_EMPOWERED_DIAMATINE = BLOCKS.register("crystal_diamatine_empowered_block", () -> new BlockCrystal(true));
-    public static final RegistryObject<Block> CRYSTAL_EMPOWERED_VOID = BLOCKS.register("crystal_void_empowered_block", () -> new BlockCrystal(true));
-    public static final RegistryObject<Block> CRYSTAL_EMPOWERED_EMERADIC = BLOCKS.register("crystal_emeradic_empowered_block", () -> new BlockCrystal(true));
-
-    public static final RegistryObject<Block> LAMP_WHITE = BLOCKS.register("lamp_white_block", BlockColoredLamp::new);
-    public static final RegistryObject<Block> LAMP_ORANGE = BLOCKS.register("lamp_orange_block", BlockColoredLamp::new);
-    public static final RegistryObject<Block> LAMP_MAGENTA = BLOCKS.register("lamp_magenta_block", BlockColoredLamp::new);
-    public static final RegistryObject<Block> LAMP_LIGHT_BLUE = BLOCKS.register("lamp_light_blue_block", BlockColoredLamp::new);
-    public static final RegistryObject<Block> LAMP_YELLOW = BLOCKS.register("lamp_yellow_block", BlockColoredLamp::new);
-    public static final RegistryObject<Block> LAMP_LIME = BLOCKS.register("lamp_lime_block", BlockColoredLamp::new);
-    public static final RegistryObject<Block> LAMP_PINK = BLOCKS.register("lamp_pink_block", BlockColoredLamp::new);
-    public static final RegistryObject<Block> LAMP_GRAY = BLOCKS.register("lamp_gray_block", BlockColoredLamp::new);
-    public static final RegistryObject<Block> LAMP_LIGHT_GRAY = BLOCKS.register("lamp_light_gray_block", BlockColoredLamp::new);
-    public static final RegistryObject<Block> LAMP_CYAN = BLOCKS.register("lamp_cyan_block", BlockColoredLamp::new);
-    public static final RegistryObject<Block> LAMP_PURPLE = BLOCKS.register("lamp_purple_block", BlockColoredLamp::new);
-    public static final RegistryObject<Block> LAMP_BLUE = BLOCKS.register("lamp_blue_block", BlockColoredLamp::new);
-    public static final RegistryObject<Block> LAMP_BROWN = BLOCKS.register("lamp_brown_block", BlockColoredLamp::new);
-    public static final RegistryObject<Block> LAMP_GREEN = BLOCKS.register("lamp_green_block", BlockColoredLamp::new);
-    public static final RegistryObject<Block> LAMP_RED = BLOCKS.register("lamp_red_block", BlockColoredLamp::new);
-    public static final RegistryObject<Block> LAMP_BLACK = BLOCKS.register("lamp_black_block", BlockColoredLamp::new);
-
-    //    public static final RegistryObject<Block> blockColoredLamp = BLOCKS.register("colored_lamp", () -> new BlockColoredLamp());
-    //    public static final RegistryObject<Block> blockColoredLampOn = BLOCKS.register("colored_lamp_on", () -> new BlockColoredLamp());
-    public static final RegistryObject<Block> LAMP_POWERER = BLOCKS.register("lamp_powerer", BlockLampPowerer::new);
     //    public static final RegistryObject<Block> blockTreasureChest = BLOCKS.register("treasure_chest", BlockTreasureChest::new);
-    public static final RegistryObject<Block> ENERGIZER = BLOCKS.register("energizer", () -> new BlockEnergizer(true));
-    public static final RegistryObject<Block> ENERVATOR = BLOCKS.register("enervator", () -> new BlockEnergizer(false));
-    public static final RegistryObject<Block> LAVA_FACTORY_CONTROLLER = BLOCKS.register("lava_factory_controller", BlockLavaFactoryController::new);
-    public static final RegistryObject<Block> CANOLA_PRESS = BLOCKS.register("canola_press", BlockCanolaPress::new);
-    public static final RegistryObject<Block> PHANTOMFACE = BLOCKS.register("phantomface", () -> new BlockPhantom(BlockPhantom.Type.FACE));
-    public static final RegistryObject<Block> PHANTOM_PLACER = BLOCKS.register("phantom_placer", () -> new BlockPhantom(BlockPhantom.Type.PLACER));
-    public static final RegistryObject<Block> PHANTOM_LIQUIFACE = BLOCKS.register("phantom_liquiface", () -> new BlockPhantom(BlockPhantom.Type.LIQUIFACE));
-    public static final RegistryObject<Block> PHANTOM_ENERGYFACE = BLOCKS.register("phantom_energyface", () -> new BlockPhantom(BlockPhantom.Type.ENERGYFACE));
-    public static final RegistryObject<Block> PHANTOM_REDSTONEFACE = BLOCKS.register("phantom_redstoneface", () -> new BlockPhantom(BlockPhantom.Type.REDSTONEFACE));
-    public static final RegistryObject<Block> PHANTOM_BREAKER = BLOCKS.register("phantom_breaker", () -> new BlockPhantom(BlockPhantom.Type.BREAKER));
     public static final RegistryObject<Block> COAL_GENERATOR = BLOCKS.register("coal_generator", BlockCoalGenerator::new);
     public static final RegistryObject<Block> OIL_GENERATOR = BLOCKS.register("oil_generator", BlockOilGenerator::new);
     public static final RegistryObject<Block> FERMENTING_BARREL = BLOCKS.register("fermenting_barrel", BlockFermentingBarrel::new);
@@ -127,16 +188,9 @@ public final class ActuallyBlocks {
     public static final RegistryObject<Block> FLAX = BLOCKS.register("flax", () -> new BlockPlant(ActuallyItems.FLAX_SEED.get()));// TODO: [port][replace] ensure values match these new BlockPlant(2, 4));
     public static final RegistryObject<Block> COFFEE = BLOCKS.register("coffee", () -> new BlockPlant(ActuallyItems.COFFEE_SEED.get()));// TODO: [port][replace] ensure values match these new BlockPlant(2, 2));
     public static final RegistryObject<Block> FURNACE_DOUBLE = BLOCKS.register("furnace_double", BlockFurnaceDouble::new);
-    public static final RegistryObject<Block> INPUTTER = BLOCKS.register("inputter", () -> new BlockInputter(false));
-    public static final RegistryObject<Block> INPUTTER_ADVANCED = BLOCKS.register("inputter_advanced", () -> new BlockInputter(true));
     //    public static final RegistryObject<Block> blockFurnaceSolar = BLOCKS.register("furnace_solar", BlockFurnaceSolar::new);
     public static final RegistryObject<Block> HEAT_COLLECTOR = BLOCKS.register("heat_collector", BlockHeatCollector::new);
     public static final RegistryObject<Block> GREENHOUSE_GLASS = BLOCKS.register("greenhouse_glass", BlockGreenhouseGlass::new);
-    public static final RegistryObject<Block> BREAKER = BLOCKS.register("breaker", () -> new BlockBreaker(false));
-    public static final RegistryObject<Block> PLACER = BLOCKS.register("placer", () -> new BlockBreaker(true));
-    public static final RegistryObject<Block> DROPPER = BLOCKS.register("dropper", BlockDropper::new);
-    public static final RegistryObject<Block> FLUID_PLACER = BLOCKS.register("fluid_placer", () -> new BlockFluidCollector(true));
-    public static final RegistryObject<Block> FLUID_COLLECTOR = BLOCKS.register("fluid_collector", () -> new BlockFluidCollector(false));
     public static final RegistryObject<Block> COFFEE_MACHINE = BLOCKS.register("coffee_machine", BlockCoffeeMachine::new);
     public static final RegistryObject<Block> PHANTOM_BOOSTER = BLOCKS.register("phantom_booster", BlockPhantomBooster::new);
     public static final RegistryObject<Block> BLACK_QUARTZ_BLOCK = BLOCKS.register("black_quartz_block", BlockGeneric::new);

src/main/java/de/ellpeck/actuallyadditions/mod/blocks/BlockCrusher.java

@@ -14,8 +14,8 @@ import static net.minecraft.state.properties.BlockStateProperties.HORIZONTAL_FAC
 import static net.minecraft.state.properties.BlockStateProperties.LIT;
 
 import de.ellpeck.actuallyadditions.mod.blocks.base.BlockContainerBase;
-import de.ellpeck.actuallyadditions.mod.tile.TileEntityGrinder;
+import de.ellpeck.actuallyadditions.mod.tile.TileEntityCrusher;
-import de.ellpeck.actuallyadditions.mod.tile.TileEntityGrinderDouble;
+import de.ellpeck.actuallyadditions.mod.tile.TileEntityCrusherDouble;
 import net.minecraft.block.Block;
 import net.minecraft.block.BlockState;
 import net.minecraft.entity.player.PlayerEntity;
@@ -37,10 +37,10 @@ import net.minecraft.world.server.ServerWorld;
 
 import java.util.Random;
 
-public class BlockGrinder extends BlockContainerBase {
+public class BlockCrusher extends BlockContainerBase {
     private final boolean isDouble;
 
-    public BlockGrinder(boolean isDouble) {
+    public BlockCrusher(boolean isDouble) {
         super(ActuallyBlocks.defaultPickProps(0).tickRandomly());
         this.isDouble = isDouble;
         this.setDefaultState(this.stateContainer.getBaseState().with(HORIZONTAL_FACING, Direction.NORTH).with(LIT, false));
@@ -49,8 +49,8 @@ public class BlockGrinder extends BlockContainerBase {
     @Override
     public TileEntity createNewTileEntity(IBlockReader worldIn) {
         return this.isDouble
-            ? new TileEntityGrinderDouble()
+            ? new TileEntityCrusherDouble()
-            : new TileEntityGrinder();
+            : new TileEntityCrusher();
     }
 
     @Override
@@ -68,10 +68,10 @@ public class BlockGrinder extends BlockContainerBase {
     @Override
     public ActionResultType onBlockActivated(BlockState state, World world, BlockPos pos, PlayerEntity player, Hand handIn, BlockRayTraceResult hit) {
         if (this.isDouble) {
-            return this.openGui(world, player, pos, TileEntityGrinderDouble.class);
+            return this.openGui(world, player, pos, TileEntityCrusherDouble.class);
         }
 
-        return this.openGui(world, player, pos, TileEntityGrinder.class);
+        return this.openGui(world, player, pos, TileEntityCrusher.class);
     }
 
     @Override

src/main/java/de/ellpeck/actuallyadditions/mod/blocks/BlockCrystal.java

@@ -10,9 +10,9 @@
 
 package de.ellpeck.actuallyadditions.mod.blocks;
 
-import de.ellpeck.actuallyadditions.mod.blocks.base.BlockBase;
+import net.minecraft.item.ItemStack;
 
-public class BlockCrystal extends BlockBase {
+public class BlockCrystal extends ActuallyBlock {
     private final boolean isEmpowered;
 
     public BlockCrystal(boolean isEmpowered) {
@@ -20,6 +20,16 @@ public class BlockCrystal extends BlockBase {
         this.isEmpowered = isEmpowered;
     }
 
+    @Override
+    public AABlockItem createBlockItem() {
+        return new AABlockItem(this, getItemProperties()) {
+            @Override
+            public boolean hasEffect(ItemStack stack) {
+                return isEmpowered;
+            }
+        };
+    }
+
     //    public static class TheItemBlock extends ItemBlockBase {
     //
     //        public TheItemBlock(Block block) {

src/main/java/de/ellpeck/actuallyadditions/mod/blocks/BlockCrystalCluster.java

@@ -1,38 +0,0 @@
-/*
- * This file ("BlockCrystalCluster.java") is part of the Actually Additions mod for Minecraft.
- * It is created and owned by Ellpeck and distributed
- * under the Actually Additions License to be found at
- * http://ellpeck.de/actaddlicense
- * View the source code at https://github.com/Ellpeck/ActuallyAdditions
- *
- * © 2015-2017 Ellpeck
- */
-
-package de.ellpeck.actuallyadditions.mod.blocks;
-
-import de.ellpeck.actuallyadditions.mod.blocks.base.FullyDirectionalBlock;
-import de.ellpeck.actuallyadditions.mod.items.metalists.TheCrystals;
-import net.minecraft.block.BlockState;
-import net.minecraft.block.SoundType;
-import net.minecraft.block.material.Material;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.util.math.shapes.ISelectionContext;
-import net.minecraft.util.math.shapes.VoxelShape;
-import net.minecraft.world.IBlockReader;
-
-public class BlockCrystalCluster extends FullyDirectionalBlock {
-
-    private final TheCrystals crystal;
-
-    public BlockCrystalCluster(TheCrystals crystal) {
-        super(Properties.create(Material.GLASS).hardnessAndResistance(0.25F, 1.0F).sound(SoundType.GLASS).setLightLevel(state -> 7));
-        this.crystal = crystal;
-
-        //        this.setLightOpacity(1);
-    }
-
-    @Override
-    public VoxelShape getShape(BlockState state, IBlockReader worldIn, BlockPos pos, ISelectionContext context) {
-        return Shapes.CRYSTAL_CLUSTER_SHAPE;
-    }
-}

src/main/java/de/ellpeck/actuallyadditions/mod/blocks/BlockItemInterface.java

@@ -11,7 +11,7 @@
 package de.ellpeck.actuallyadditions.mod.blocks;
 
 import de.ellpeck.actuallyadditions.mod.blocks.base.BlockContainerBase;
-import de.ellpeck.actuallyadditions.mod.tile.TileEntityItemViewer;
+import de.ellpeck.actuallyadditions.mod.tile.TileEntityItemInterface;
 import net.minecraft.block.BlockState;
 import net.minecraft.tileentity.TileEntity;
 import net.minecraft.util.math.BlockPos;
@@ -19,14 +19,14 @@ import net.minecraft.util.math.shapes.ISelectionContext;
 import net.minecraft.util.math.shapes.VoxelShape;
 import net.minecraft.world.IBlockReader;
 
-public class BlockItemViewer extends BlockContainerBase {
+public class BlockItemInterface extends BlockContainerBase {
-    public BlockItemViewer() {
+    public BlockItemInterface() {
         super(ActuallyBlocks.defaultPickProps(0));
     }
 
     @Override
     public TileEntity createNewTileEntity(IBlockReader worldIn) {
-        return new TileEntityItemViewer();
+        return new TileEntityItemInterface();
     }
 
     @Override

src/main/java/de/ellpeck/actuallyadditions/mod/blocks/BlockItemInterfaceHopping.java

@@ -10,7 +10,7 @@
 
 package de.ellpeck.actuallyadditions.mod.blocks;
 
-import de.ellpeck.actuallyadditions.mod.tile.TileEntityItemViewerHopping;
+import de.ellpeck.actuallyadditions.mod.tile.TileEntityItemInterfaceHopping;
 import net.minecraft.block.BlockState;
 import net.minecraft.tileentity.TileEntity;
 import net.minecraft.util.math.BlockPos;
@@ -18,8 +18,8 @@ import net.minecraft.util.math.shapes.ISelectionContext;
 import net.minecraft.util.math.shapes.VoxelShape;
 import net.minecraft.world.IBlockReader;
 
-public class BlockItemViewerHopping extends BlockItemViewer {
+public class BlockItemInterfaceHopping extends BlockItemInterface {
-    public BlockItemViewerHopping() {
+    public BlockItemInterfaceHopping() {
         super();
     }
 
@@ -30,6 +30,6 @@ public class BlockItemViewerHopping extends BlockItemViewer {
 
     @Override
     public TileEntity createNewTileEntity(IBlockReader worldIn) {
-        return new TileEntityItemViewerHopping();
+        return new TileEntityItemInterfaceHopping();
     }
 }

src/main/java/de/ellpeck/actuallyadditions/mod/blocks/CrystalClusterBlock.java

@@ -0,0 +1,69 @@
+/*
+ * This file ("BlockCrystalCluster.java") is part of the Actually Additions mod for Minecraft.
+ * It is created and owned by Ellpeck and distributed
+ * under the Actually Additions License to be found at
+ * http://ellpeck.de/actaddlicense
+ * View the source code at https://github.com/Ellpeck/ActuallyAdditions
+ *
+ * © 2015-2017 Ellpeck
+ */
+
+package de.ellpeck.actuallyadditions.mod.blocks;
+
+import de.ellpeck.actuallyadditions.mod.blocks.base.FullyDirectionalBlock;
+import de.ellpeck.actuallyadditions.mod.items.metalists.Crystals;
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.SoundType;
+import net.minecraft.block.material.Material;
+import net.minecraft.state.DirectionProperty;
+import net.minecraft.state.StateContainer;
+import net.minecraft.state.properties.BlockStateProperties;
+import net.minecraft.util.Direction;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.shapes.IBooleanFunction;
+import net.minecraft.util.math.shapes.ISelectionContext;
+import net.minecraft.util.math.shapes.VoxelShape;
+import net.minecraft.util.math.shapes.VoxelShapes;
+import net.minecraft.world.IBlockReader;
+
+import java.util.stream.Stream;
+
+public class CrystalClusterBlock extends FullyDirectionalBlock {
+    public static final DirectionProperty FACING = BlockStateProperties.FACING;
+
+    public static final VoxelShape CRYSTAL_SHAPE = Stream.of(
+        Block.makeCuboidShape(5, 4, 5, 10, 19, 10), Block.makeCuboidShape(4, 0, 4, 11, 5, 11),
+        Block.makeCuboidShape(3, 0, 3, 5, 4, 5), Block.makeCuboidShape(10, 0, 3, 12, 2, 5),
+        Block.makeCuboidShape(12, 0, 4, 13, 1, 5), Block.makeCuboidShape(11, 0, 5, 12, 1, 6),
+        Block.makeCuboidShape(10, 0, 10, 12, 3, 12), Block.makeCuboidShape(3, 0, 10, 5, 1, 12),
+        Block.makeCuboidShape(9, 0, 3, 10, 3, 4), Block.makeCuboidShape(8, 0, 2, 11, 1, 4),
+        Block.makeCuboidShape(4, 0, 2, 5, 2, 3), Block.makeCuboidShape(5, 0, 3, 7, 1, 4),
+        Block.makeCuboidShape(2, 0, 4, 4, 1, 6), Block.makeCuboidShape(3, 0, 5, 4, 3, 6.5),
+        Block.makeCuboidShape(3, 0, 9, 4, 2, 10), Block.makeCuboidShape(2, 0, 8, 4, 1, 10),
+        Block.makeCuboidShape(5, 0, 11, 7, 2, 13), Block.makeCuboidShape(7, 0, 11, 11, 1, 13),
+        Block.makeCuboidShape(10, 0, 9, 13, 1, 11), Block.makeCuboidShape(11, 0, 7, 12, 3, 9)
+    ).reduce((v1, v2) -> {return VoxelShapes.combineAndSimplify(v1, v2, IBooleanFunction.OR);}).get();
+
+    public CrystalClusterBlock(Crystals crystal) {
+        super(Properties.create(Material.GLASS)
+            .setLightLevel((e) -> 7)
+            .sound(SoundType.GLASS)
+            .hardnessAndResistance(0.25f, 1.0f));
+    }
+
+    @Override
+    public BlockState getBaseConstructorState() {
+        return this.stateContainer.getBaseState().with(FACING, Direction.UP);
+    }
+
+    @Override
+    public boolean isTransparent(BlockState state) {
+        return true;
+    }
+
+    @Override
+    public VoxelShape getShape(BlockState state, IBlockReader worldIn, BlockPos pos, ISelectionContext context) {
+        return CRYSTAL_SHAPE;
+    }
+}

src/main/java/de/ellpeck/actuallyadditions/mod/blocks/IActuallyBlock.java

@@ -0,0 +1,20 @@
+package de.ellpeck.actuallyadditions.mod.blocks;
+
+import net.minecraft.item.Item;
+
+public interface IActuallyBlock {
+    /**
+     * Defaults to the default class for mc. Don't run this other than on setup
+     *
+     * @return this blocks item pair
+     */
+    AABlockItem createBlockItem();
+
+    /**
+     * Defines the Block Item properties for all non-custom block items.
+     *
+     * @return block item properties for default block item.
+     * @see for implementation {@link #createBlockItem()}
+     */
+    Item.Properties getItemProperties();
+}

src/main/java/de/ellpeck/actuallyadditions/mod/blocks/base/BlockFluidFlowing.java

@@ -12,10 +12,7 @@ package de.ellpeck.actuallyadditions.mod.blocks.base;
 
 import net.minecraft.block.material.Material;
 import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.IBlockAccess;
 import net.minecraft.world.World;
-import net.minecraftforge.fluids.BlockFluidClassic;
-import net.minecraftforge.fluids.Fluid;
 
 public class BlockFluidFlowing extends BlockFluidClassic implements ItemBlockBase.ICustomRarity {
 

src/main/java/de/ellpeck/actuallyadditions/mod/blocks/base/FullyDirectionalBlock.java

@@ -25,6 +25,10 @@ public abstract class FullyDirectionalBlock extends BlockBase {
 
     }
 
+    public BlockState getBaseConstructorState() {
+        return this.stateContainer.getBaseState().with(FACING, Direction.NORTH);
+    }
+
     @Override
     protected void fillStateContainer(StateContainer.Builder<Block, BlockState> builder) {
         builder.add(FACING);

src/main/java/de/ellpeck/actuallyadditions/mod/booklet/InitBooklet.java

@@ -199,7 +199,7 @@ public final class InitBooklet {
         //No RF Using Blocks
         new BookletChapter("breaker", ActuallyAdditionsAPI.entryFunctionalNonRF, new ItemStack(ActuallyBlocks.BREAKER.get()), new PageCrafting(1, BlockCrafting.recipeBreaker).setWildcard(), new PageCrafting(2, BlockCrafting.recipePlacer).setWildcard(), new PageCrafting(3, BlockCrafting.recipeLiquidPlacer).setWildcard(), new PageCrafting(4, BlockCrafting.recipeLiquidCollector).setWildcard());
         new BookletChapter("dropper", ActuallyAdditionsAPI.entryFunctionalNonRF, new ItemStack(ActuallyBlocks.DROPPER.get()), new PageTextOnly(1), new PageCrafting(2, BlockCrafting.recipeDropper).setNoText());
-        new BookletChapter("phantomfaces", ActuallyAdditionsAPI.entryFunctionalNonRF, new ItemStack(ActuallyBlocks.PHANTOM_LIQUIFACE.get()), new PageTextOnly(1).addTextReplacement("<range>", TileEntityPhantomface.RANGE), new PageTextOnly(2), new PageCrafting(3, BlockCrafting.recipePhantomface), new PageCrafting(4, BlockCrafting.recipeLiquiface), new PageCrafting(5, BlockCrafting.recipeEnergyface), new PageCrafting(6, ItemCrafting.recipePhantomConnector).setNoText(), new PageCrafting(7, BlockCrafting.recipePhantomBooster)).setImportant();
+        new BookletChapter("phantomfaces", ActuallyAdditionsAPI.entryFunctionalNonRF, new ItemStack(ActuallyBlocks.PHANTOM_LIQUIFACE.get()), new PageTextOnly(1).addTextReplacement("<range>", TileEntityPhantomFace.RANGE), new PageTextOnly(2), new PageCrafting(3, BlockCrafting.recipePhantomface), new PageCrafting(4, BlockCrafting.recipeLiquiface), new PageCrafting(5, BlockCrafting.recipeEnergyface), new PageCrafting(6, ItemCrafting.recipePhantomConnector).setNoText(), new PageCrafting(7, BlockCrafting.recipePhantomBooster)).setImportant();
         new BookletChapter("phantomRedstoneface", ActuallyAdditionsAPI.entryFunctionalNonRF, new ItemStack(ActuallyBlocks.PHANTOM_REDSTONEFACE.get()), new PageTextOnly(1), new PageCrafting(2, BlockCrafting.recipePhantomRedstoneface).setNoText());
         new BookletChapter("phantomBreaker", ActuallyAdditionsAPI.entryFunctionalNonRF, new ItemStack(ActuallyBlocks.PHANTOM_BREAKER.get()), new PageTextOnly(1).addTextReplacement("<range>", TileEntityPhantomPlacer.RANGE), new PageCrafting(2, BlockCrafting.recipePhantomPlacer).setNoText(), new PageCrafting(3, BlockCrafting.recipePhantomBreaker).setNoText());
         new BookletChapter("esd", ActuallyAdditionsAPI.entryFunctionalNonRF, new ItemStack(ActuallyBlocks.INPUTTER_ADVANCED.get()), new PageTextOnly(1), new PageCrafting(2, BlockCrafting.recipeESD).setNoText(), new PageCrafting(3, BlockCrafting.recipeAdvancedESD).setNoText()).setSpecial();
@@ -219,7 +219,7 @@ public final class InitBooklet {
         new BookletChapterCoffee("coffeeMachine", ActuallyAdditionsAPI.entryFunctionalRF, new ItemStack(ActuallyBlocks.COFFEE_MACHINE.get()), new PageTextOnly(1).addItemsToPage(new ItemStack(ActuallyItems.COFFEE_BEANS.get())).addTextReplacement("<rf>", TileEntityCoffeeMachine.ENERGY_USED).addTextReplacement("<coffee>", TileEntityCoffeeMachine.CACHE_USE).addTextReplacement("<water>", TileEntityCoffeeMachine.WATER_USE), new PageTextOnly(2).addItemsToPage(new ItemStack(ActuallyItems.COFFEE.get())), new PagePicture(3, "page_coffee_machine", 115), new PageCrafting(4, BlockCrafting.recipeCoffeeMachine).setWildcard().setNoText(), new PageCrafting(5, ItemCrafting.recipeCup).setNoText()).setImportant();
 
         List<IBookletPage> list = new ArrayList<>();
-        list.add(new PageTextOnly(1).addTextReplacement("<rf>", TileEntityGrinder.ENERGY_USE));
+        list.add(new PageTextOnly(1).addTextReplacement("<rf>", TileEntityCrusher.ENERGY_USE));
         list.add(new PageCrafting(2, BlockCrafting.recipeCrusher).setWildcard().setNoText());
         list.add(new PageCrafting(3, BlockCrafting.recipeDoubleCrusher).setWildcard().setNoText());
         if (CrusherCrafting.recipeIronHorseArmor != null) {

src/main/java/de/ellpeck/actuallyadditions/mod/booklet/gui/GuiEntry.java

@@ -20,6 +20,7 @@ import de.ellpeck.actuallyadditions.mod.booklet.misc.BookletUtils;
 import net.minecraft.client.gui.screen.Screen;
 import net.minecraft.item.ItemStack;
 import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
 
 import java.io.IOException;
 import java.util.List;

src/main/java/de/ellpeck/actuallyadditions/mod/inventory/ContainerGrinder.java

@@ -13,7 +13,7 @@ package de.ellpeck.actuallyadditions.mod.inventory;
 import de.ellpeck.actuallyadditions.mod.inventory.slot.SlotItemHandlerUnconditioned;
 import de.ellpeck.actuallyadditions.mod.inventory.slot.SlotOutput;
 import de.ellpeck.actuallyadditions.mod.recipe.CrusherRecipeRegistry;
-import de.ellpeck.actuallyadditions.mod.tile.TileEntityGrinder;
+import de.ellpeck.actuallyadditions.mod.tile.TileEntityCrusher;
 import de.ellpeck.actuallyadditions.mod.util.StackUtil;
 import net.minecraft.entity.player.PlayerEntity;
 import net.minecraft.entity.player.PlayerInventory;
@@ -25,31 +25,31 @@ import net.minecraft.network.PacketBuffer;
 import java.util.Objects;
 
 public class ContainerGrinder extends Container {
-    public final TileEntityGrinder tileGrinder;
+    public final TileEntityCrusher tileGrinder;
     public final boolean isDouble;
 
     public static ContainerGrinder fromNetwork(int windowId, PlayerInventory inv, PacketBuffer data) {
-        return new ContainerGrinder(windowId, inv, (TileEntityGrinder) Objects.requireNonNull(inv.player.world.getTileEntity(data.readBlockPos())));
+        return new ContainerGrinder(windowId, inv, (TileEntityCrusher) Objects.requireNonNull(inv.player.world.getTileEntity(data.readBlockPos())));
     }
 
-    public ContainerGrinder(int windowId, PlayerInventory inventory, TileEntityGrinder tile) {
+    public ContainerGrinder(int windowId, PlayerInventory inventory, TileEntityCrusher tile) {
         super(ActuallyContainers.GRINDER_CONTAINER.get(), windowId);
         this.tileGrinder = tile;
         this.isDouble = tile.isDouble;
 
-        this.addSlot(new SlotItemHandlerUnconditioned(this.tileGrinder.inv, TileEntityGrinder.SLOT_INPUT_1, this.isDouble
+        this.addSlot(new SlotItemHandlerUnconditioned(this.tileGrinder.inv, TileEntityCrusher.SLOT_INPUT_1, this.isDouble
             ? 51
             : 80, 21));
-        this.addSlot(new SlotOutput(this.tileGrinder.inv, TileEntityGrinder.SLOT_OUTPUT_1_1, this.isDouble
+        this.addSlot(new SlotOutput(this.tileGrinder.inv, TileEntityCrusher.SLOT_OUTPUT_1_1, this.isDouble
             ? 37
             : 66, 69));
-        this.addSlot(new SlotOutput(this.tileGrinder.inv, TileEntityGrinder.SLOT_OUTPUT_1_2, this.isDouble
+        this.addSlot(new SlotOutput(this.tileGrinder.inv, TileEntityCrusher.SLOT_OUTPUT_1_2, this.isDouble
             ? 64
             : 92, 69));
         if (this.isDouble) {
-            this.addSlot(new SlotItemHandlerUnconditioned(this.tileGrinder.inv, TileEntityGrinder.SLOT_INPUT_2, 109, 21));
+            this.addSlot(new SlotItemHandlerUnconditioned(this.tileGrinder.inv, TileEntityCrusher.SLOT_INPUT_2, 109, 21));
-            this.addSlot(new SlotOutput(this.tileGrinder.inv, TileEntityGrinder.SLOT_OUTPUT_2_1, 96, 69));
+            this.addSlot(new SlotOutput(this.tileGrinder.inv, TileEntityCrusher.SLOT_OUTPUT_2_1, 96, 69));
-            this.addSlot(new SlotOutput(this.tileGrinder.inv, TileEntityGrinder.SLOT_OUTPUT_2_2, 121, 69));
+            this.addSlot(new SlotOutput(this.tileGrinder.inv, TileEntityCrusher.SLOT_OUTPUT_2_2, 121, 69));
         }
 
         for (int i = 0; i < 3; i++) {
@@ -78,7 +78,7 @@ public class ContainerGrinder extends Container {
             ItemStack currentStack = newStack.copy();
 
             //Slots in Inventory to shift from
-            if (slot == TileEntityGrinder.SLOT_OUTPUT_1_1 || slot == TileEntityGrinder.SLOT_OUTPUT_1_2 || this.isDouble && (slot == TileEntityGrinder.SLOT_OUTPUT_2_1 || slot == TileEntityGrinder.SLOT_OUTPUT_2_2)) {
+            if (slot == TileEntityCrusher.SLOT_OUTPUT_1_1 || slot == TileEntityCrusher.SLOT_OUTPUT_1_2 || this.isDouble && (slot == TileEntityCrusher.SLOT_OUTPUT_2_1 || slot == TileEntityCrusher.SLOT_OUTPUT_2_2)) {
                 if (!this.mergeItemStack(newStack, inventoryStart, hotbarEnd + 1, true)) {
                     return StackUtil.getEmpty();
                 }
@@ -88,9 +88,9 @@ public class ContainerGrinder extends Container {
             else if (slot >= inventoryStart) {
                 //Shift from Inventory
                 if (CrusherRecipeRegistry.getRecipeFromInput(newStack) != null) {
-                    if (!this.mergeItemStack(newStack, TileEntityGrinder.SLOT_INPUT_1, TileEntityGrinder.SLOT_INPUT_1 + 1, false)) {
+                    if (!this.mergeItemStack(newStack, TileEntityCrusher.SLOT_INPUT_1, TileEntityCrusher.SLOT_INPUT_1 + 1, false)) {
                         if (this.isDouble) {
-                            if (!this.mergeItemStack(newStack, TileEntityGrinder.SLOT_INPUT_2, TileEntityGrinder.SLOT_INPUT_2 + 1, false)) {
+                            if (!this.mergeItemStack(newStack, TileEntityCrusher.SLOT_INPUT_2, TileEntityCrusher.SLOT_INPUT_2 + 1, false)) {
                                 return StackUtil.getEmpty();
                             }
                         } else {

src/main/java/de/ellpeck/actuallyadditions/mod/inventory/gui/GuiGrinder.java

@@ -15,7 +15,7 @@ import com.mojang.blaze3d.systems.RenderSystem;
 import de.ellpeck.actuallyadditions.mod.ActuallyAdditions;
 import de.ellpeck.actuallyadditions.mod.inventory.ContainerGrinder;
 import de.ellpeck.actuallyadditions.mod.network.PacketHandlerHelper;
-import de.ellpeck.actuallyadditions.mod.tile.TileEntityGrinder;
+import de.ellpeck.actuallyadditions.mod.tile.TileEntityCrusher;
 import de.ellpeck.actuallyadditions.mod.util.AssetUtil;
 import de.ellpeck.actuallyadditions.mod.util.StringUtil;
 import net.minecraft.client.gui.widget.button.Button;
@@ -35,7 +35,7 @@ public class GuiGrinder extends GuiWtfMojang<ContainerGrinder> {
 
     private static final ResourceLocation RES_LOC = AssetUtil.getGuiLocation("gui_grinder");
     private static final ResourceLocation RES_LOC_DOUBLE = AssetUtil.getGuiLocation("gui_grinder_double");
-    private final TileEntityGrinder tileGrinder;
+    private final TileEntityCrusher tileGrinder;
     private final boolean isDouble;
     private EnergyDisplay energy;
 

src/main/java/de/ellpeck/actuallyadditions/mod/items/metalists/Crystals.java

@@ -12,9 +12,7 @@ package de.ellpeck.actuallyadditions.mod.items.metalists;
 
 import net.minecraft.util.IStringSerializable;
 
-@Deprecated
+public enum Crystals implements IStringSerializable {
-public enum TheCrystals implements IStringSerializable {
-
     REDSTONE("red", 0xFF2F21, 158F / 255F, 43F / 255F, 39F / 255F),
     LAPIS("blue", 0x5171FF, 37F / 255F, 49F / 255F, 147F / 255F),
     DIAMOND("light_blue", 0x35F1FF, 99F / 255F, 135F / 255F, 210F / 255F),
@@ -26,7 +24,7 @@ public enum TheCrystals implements IStringSerializable {
     public final float[] conversionColorParticles;
     public final int clusterColor;
 
-    TheCrystals(String name, int clusterColor, float... conversionColorParticles) {
+    Crystals(String name, int clusterColor, float... conversionColorParticles) {
         this.name = name;
         this.conversionColorParticles = conversionColorParticles;
         this.clusterColor = clusterColor;

src/main/java/de/ellpeck/actuallyadditions/mod/tile/ActuallyTiles.java

@@ -11,58 +11,58 @@ public class ActuallyTiles {
     public static final DeferredRegister<TileEntityType<?>> TILES = DeferredRegister.create(ForgeRegistries.TILE_ENTITIES, ActuallyAdditions.MODID);
 
     //    public static final RegistryObject<,<?>> COMPOST_TILE = TILES.register("compost", () -> TileEntityType.Builder.create(TileEntityCompost::new, InitBlocks.blockCompost.get()).build(null));
-    public static final RegistryObject<TileEntityType<TileEntityFeeder>> FEEDER_TILE = TILES.register("feeder", () -> TileEntityType.Builder.create(TileEntityFeeder::new, ActuallyBlocks.FEEDER.get()).build(null));
+    //public static final RegistryObject<TileEntityType<TileEntityFeeder>> FEEDER_TILE = TILES.register("feeder", () -> TileEntityType.Builder.create(TileEntityFeeder::new, ActuallyBlocks.FEEDER.get()).build(null));
     //    public static final RegistryObject<build<?>> GIANTCHEST_TILE = TILES.register("", () -> TileEntityType.Builder.create(TileEntityGiantChest::new, ).build(null));
     //    public static final RegistryObject<build<?>> GIANTCHESTMEDIUM_TILE = TILES.register("", () -> TileEntityType.Builder.create(TileEntityGiantChestMedium::new, ).build(null));
     //    public static final RegistryObject<build<?>> GIANTCHESTLARGE_TILE = TILES.register("", () -> TileEntityType.Builder.create(TileEntityGiantChestLarge::new, ).build(null));
-    public static final RegistryObject<TileEntityType<TileEntityGrinder>> GRINDER_TILE = TILES.register("grinder", () -> TileEntityType.Builder.create(TileEntityGrinder::new, ActuallyBlocks.GRINDER.get()).build(null));
+    //public static final RegistryObject<TileEntityType<TileEntityCrusher>> GRINDER_TILE = TILES.register("grinder", () -> TileEntityType.Builder.create(TileEntityCrusher::new, ActuallyBlocks.GRINDER.get()).build(null));
-    public static final RegistryObject<TileEntityType<TileEntityFurnaceDouble>> FURNACE_DOUBLE_TILE = TILES.register("furnaceDouble", () -> TileEntityType.Builder.create(TileEntityFurnaceDouble::new, ActuallyBlocks.FURNACE_DOUBLE.get()).build(null));
+    //public static final RegistryObject<TileEntityType<TileEntityFurnaceDouble>> FURNACE_DOUBLE_TILE = TILES.register("furnaceDouble", () -> TileEntityType.Builder.create(TileEntityFurnaceDouble::new, ActuallyBlocks.FURNACE_DOUBLE.get()).build(null));
-    public static final RegistryObject<TileEntityType<TileEntityInputter>> INPUTTER_TILE = TILES.register("inputter", () -> TileEntityType.Builder.create(TileEntityInputter::new, ActuallyBlocks.INPUTTER.get()).build(null));
+    //public static final RegistryObject<TileEntityType<TileEntityInputter>> INPUTTER_TILE = TILES.register("inputter", () -> TileEntityType.Builder.create(TileEntityInputter::new, ActuallyBlocks.INPUTTER.get()).build(null));
     //    public static final RegistryObject<TileEntityType<TileEntityFurnaceSolar>> SOLAR_TILE = TILES.register("solarPanel", () -> TileEntityType.Builder.create(TileEntityFurnaceSolar::new, ActuallyBlocks.blockFurnaceSolar.get()).build(null));
     public static final RegistryObject<TileEntityType<TileEntityHeatCollector>> HEATCOLLECTOR_TILE = TILES.register("heatCollector", () -> TileEntityType.Builder.create(TileEntityHeatCollector::new, ActuallyBlocks.HEAT_COLLECTOR.get()).build(null));
-    public static final RegistryObject<TileEntityType<TileEntityBreaker>> BREAKER_TILE = TILES.register("breaker", () -> TileEntityType.Builder.create(TileEntityBreaker::new, ActuallyBlocks.BREAKER.get()).build(null));
+    //public static final RegistryObject<TileEntityType<TileEntityBreaker>> BREAKER_TILE = TILES.register("breaker", () -> TileEntityType.Builder.create(TileEntityBreaker::new, ActuallyBlocks.BREAKER.get()).build(null));
-    public static final RegistryObject<TileEntityType<TileEntityDropper>> DROPPER_TILE = TILES.register("dropper", () -> TileEntityType.Builder.create(TileEntityDropper::new, ActuallyBlocks.DROPPER.get()).build(null));
+    //public static final RegistryObject<TileEntityType<TileEntityDropper>> DROPPER_TILE = TILES.register("dropper", () -> TileEntityType.Builder.create(TileEntityDropper::new, ActuallyBlocks.DROPPER.get()).build(null));
-    public static final RegistryObject<TileEntityType<TileEntityInputterAdvanced>> INPUTTERADVANCED_TILE = TILES.register("inputterAdvanced", () -> TileEntityType.Builder.create(TileEntityInputterAdvanced::new, ActuallyBlocks.INPUTTER_ADVANCED.get()).build(null));
+    //public static final RegistryObject<TileEntityType<TileEntityInputterAdvanced>> INPUTTERADVANCED_TILE = TILES.register("inputterAdvanced", () -> TileEntityType.Builder.create(TileEntityInputterAdvanced::new, ActuallyBlocks.INPUTTER_ADVANCED.get()).build(null));
-    public static final RegistryObject<TileEntityType<TileEntityPlacer>> PLACER_TILE = TILES.register("placer", () -> TileEntityType.Builder.create(TileEntityPlacer::new, ActuallyBlocks.PLACER.get()).build(null));
+    //public static final RegistryObject<TileEntityType<TileEntityPlacer>> PLACER_TILE = TILES.register("placer", () -> TileEntityType.Builder.create(TileEntityPlacer::new, ActuallyBlocks.PLACER.get()).build(null));
-    public static final RegistryObject<TileEntityType<TileEntityGrinderDouble>> GRINDER_DOUBLE_TILE = TILES.register("grinderDouble", () -> TileEntityType.Builder.create(TileEntityGrinderDouble::new, ActuallyBlocks.GRINDER_DOUBLE.get()).build(null));
+    //public static final RegistryObject<TileEntityType<TileEntityCrusherDouble>> GRINDER_DOUBLE_TILE = TILES.register("grinderDouble", () -> TileEntityType.Builder.create(TileEntityCrusherDouble::new, ActuallyBlocks.GRINDER_DOUBLE.get()).build(null));
-    public static final RegistryObject<TileEntityType<TileEntityCanolaPress>> CANOLAPRESS_TILE = TILES.register("canolaPress", () -> TileEntityType.Builder.create(TileEntityCanolaPress::new, ActuallyBlocks.CANOLA_PRESS.get()).build(null));
+    //public static final RegistryObject<TileEntityType<TileEntityCanolaPress>> CANOLAPRESS_TILE = TILES.register("canolaPress", () -> TileEntityType.Builder.create(TileEntityCanolaPress::new, ActuallyBlocks.CANOLA_PRESS.get()).build(null));
     public static final RegistryObject<TileEntityType<TileEntityFermentingBarrel>> FERMENTINGBARREL_TILE = TILES.register("fermentingBarrel", () -> TileEntityType.Builder.create(TileEntityFermentingBarrel::new, ActuallyBlocks.FERMENTING_BARREL.get()).build(null));
     public static final RegistryObject<TileEntityType<TileEntityOilGenerator>> OILGENERATOR_TILE = TILES.register("oilGenerator", () -> TileEntityType.Builder.create(TileEntityOilGenerator::new, ActuallyBlocks.OIL_GENERATOR.get()).build(null));
     public static final RegistryObject<TileEntityType<TileEntityCoalGenerator>> COALGENERATOR_TILE = TILES.register("coalGenerator", () -> TileEntityType.Builder.create(TileEntityCoalGenerator::new, ActuallyBlocks.COAL_GENERATOR.get()).build(null));
-    public static final RegistryObject<TileEntityType<TileEntityPhantomItemface>> PHANTOMITEMFACE_TILE = TILES.register("phantomface", () -> TileEntityType.Builder.create(TileEntityPhantomItemface::new, ActuallyBlocks.PHANTOMFACE.get()).build(null));
+    //public static final RegistryObject<TileEntityType<TileEntityPhantomItemface>> PHANTOMITEMFACE_TILE = TILES.register("phantomface", () -> TileEntityType.Builder.create(TileEntityPhantomItemface::new, ActuallyBlocks.PHANTOMFACE.get()).build(null));
-    public static final RegistryObject<TileEntityType<TileEntityPhantomLiquiface>> PHANTOMLIQUIFACE_TILE = TILES.register("liquiface", () -> TileEntityType.Builder.create(TileEntityPhantomLiquiface::new, ActuallyBlocks.PHANTOM_LIQUIFACE.get()).build(null));
+    //public static final RegistryObject<TileEntityType<TileEntityPhantomLiquiface>> PHANTOMLIQUIFACE_TILE = TILES.register("liquiface", () -> TileEntityType.Builder.create(TileEntityPhantomLiquiface::new, ActuallyBlocks.PHANTOM_LIQUIFACE.get()).build(null));
-    public static final RegistryObject<TileEntityType<TileEntityPhantomEnergyface>> PHANTOMENERGYFACE_TILE = TILES.register("energyface", () -> TileEntityType.Builder.create(TileEntityPhantomEnergyface::new, ActuallyBlocks.PHANTOM_ENERGYFACE.get()).build(null));
+    //public static final RegistryObject<TileEntityType<TileEntityPhantomEnergyface>> PHANTOMENERGYFACE_TILE = TILES.register("energyface", () -> TileEntityType.Builder.create(TileEntityPhantomEnergyface::new, ActuallyBlocks.PHANTOM_ENERGYFACE.get()).build(null));
-    public static final RegistryObject<TileEntityType<TileEntityPlayerInterface>> PLAYERINTERFACE_TILE = TILES.register("playerInterface", () -> TileEntityType.Builder.create(TileEntityPlayerInterface::new, ActuallyBlocks.PLAYER_INTERFACE.get()).build(null));
+    //public static final RegistryObject<TileEntityType<TileEntityPlayerInterface>> PLAYERINTERFACE_TILE = TILES.register("playerInterface", () -> TileEntityType.Builder.create(TileEntityPlayerInterface::new, ActuallyBlocks.PLAYER_INTERFACE.get()).build(null));
-    public static final RegistryObject<TileEntityType<TileEntityPhantomPlacer>> PHANTOMPLACER_TILE = TILES.register("phantomPlacer", () -> TileEntityType.Builder.create(TileEntityPhantomPlacer::new, ActuallyBlocks.PHANTOM_PLACER.get()).build(null));
+    //public static final RegistryObject<TileEntityType<TileEntityPhantomPlacer>> PHANTOMPLACER_TILE = TILES.register("phantomPlacer", () -> TileEntityType.Builder.create(TileEntityPhantomPlacer::new, ActuallyBlocks.PHANTOM_PLACER.get()).build(null));
-    public static final RegistryObject<TileEntityType<TileEntityPhantomBreaker>> PHANTOMBREAKER_TILE = TILES.register("phantomBreaker", () -> TileEntityType.Builder.create(TileEntityPhantomBreaker::new, ActuallyBlocks.PHANTOM_BREAKER.get()).build(null));
+    //public static final RegistryObject<TileEntityType<TileEntityPhantomBreaker>> PHANTOMBREAKER_TILE = TILES.register("phantomBreaker", () -> TileEntityType.Builder.create(TileEntityPhantomBreaker::new, ActuallyBlocks.PHANTOM_BREAKER.get()).build(null));
-    public static final RegistryObject<TileEntityType<TileEntityFluidCollector>> FLUIDCOLLECTOR_TILE = TILES.register("fluidCollector", () -> TileEntityType.Builder.create(TileEntityFluidCollector::new, ActuallyBlocks.FLUID_COLLECTOR.get()).build(null));
+    //public static final RegistryObject<TileEntityType<TileEntityFluidCollector>> FLUIDCOLLECTOR_TILE = TILES.register("fluidCollector", () -> TileEntityType.Builder.create(TileEntityFluidCollector::new, ActuallyBlocks.FLUID_COLLECTOR.get()).build(null));
-    public static final RegistryObject<TileEntityType<TileEntityFluidPlacer>> FLUIDPLACER_TILE = TILES.register("fluidPlacer", () -> TileEntityType.Builder.create(TileEntityFluidPlacer::new, ActuallyBlocks.FLUID_PLACER.get()).build(null));
+    //public static final RegistryObject<TileEntityType<TileEntityFluidPlacer>> FLUIDPLACER_TILE = TILES.register("fluidPlacer", () -> TileEntityType.Builder.create(TileEntityFluidPlacer::new, ActuallyBlocks.FLUID_PLACER.get()).build(null));
-    public static final RegistryObject<TileEntityType<TileEntityLavaFactoryController>> LAVAFACTORYCONTROLLER_TILE = TILES.register("lavaFactory", () -> TileEntityType.Builder.create(TileEntityLavaFactoryController::new, ActuallyBlocks.LAVA_FACTORY_CONTROLLER.get()).build(null));
+    //public static final RegistryObject<TileEntityType<TileEntityLavaFactoryController>> LAVAFACTORYCONTROLLER_TILE = TILES.register("lavaFactory", () -> TileEntityType.Builder.create(TileEntityLavaFactoryController::new, ActuallyBlocks.LAVA_FACTORY_CONTROLLER.get()).build(null));
     public static final RegistryObject<TileEntityType<TileEntityCoffeeMachine>> COFFEEMACHINE_TILE = TILES.register("coffeeMachine", () -> TileEntityType.Builder.create(TileEntityCoffeeMachine::new, ActuallyBlocks.COFFEE_MACHINE.get()).build(null));
     public static final RegistryObject<TileEntityType<TileEntityPhantomBooster>> PHANTOM_BOOSTER_TILE = TILES.register("phantomBooster", () -> TileEntityType.Builder.create(TileEntityPhantomBooster::new, ActuallyBlocks.PHANTOM_BOOSTER.get()).build(null));
-    public static final RegistryObject<TileEntityType<TileEntityEnergizer>> ENERGIZER_TILE = TILES.register("energizer", () -> TileEntityType.Builder.create(TileEntityEnergizer::new, ActuallyBlocks.ENERGIZER.get()).build(null));
+    //public static final RegistryObject<TileEntityType<TileEntityEnergizer>> ENERGIZER_TILE = TILES.register("energizer", () -> TileEntityType.Builder.create(TileEntityEnergizer::new, ActuallyBlocks.ENERGIZER.get()).build(null));
-    public static final RegistryObject<TileEntityType<TileEntityEnervator>> ENERVATOR_TILE = TILES.register("enervator", () -> TileEntityType.Builder.create(TileEntityEnervator::new, ActuallyBlocks.ENERVATOR.get()).build(null));
+    //public static final RegistryObject<TileEntityType<TileEntityEnervator>> ENERVATOR_TILE = TILES.register("enervator", () -> TileEntityType.Builder.create(TileEntityEnervator::new, ActuallyBlocks.ENERVATOR.get()).build(null));
-    public static final RegistryObject<TileEntityType<TileEntityXPSolidifier>> XPSOLIDIFIER_TILE = TILES.register("xpSolidifier", () -> TileEntityType.Builder.create(TileEntityXPSolidifier::new, ActuallyBlocks.XP_SOLIDIFIER.get()).build(null));
+    //public static final RegistryObject<TileEntityType<TileEntityXPSolidifier>> XPSOLIDIFIER_TILE = TILES.register("xpSolidifier", () -> TileEntityType.Builder.create(TileEntityXPSolidifier::new, ActuallyBlocks.XP_SOLIDIFIER.get()).build(null));
     //    public static final RegistryObject<.<?>> SMILEYCLOUD_TILE = TILES.register("", () -> TileEntityType.Builder.create(TileEntitySmileyCloud::new, InitBlocks.blockSmileyCloud.get()).build(null));
-    public static final RegistryObject<TileEntityType<TileEntityLeafGenerator>> LEAFGENERATOR_TILE = TILES.register("leafGenerator", () -> TileEntityType.Builder.create(TileEntityLeafGenerator::new, ActuallyBlocks.LEAF_GENERATOR.get()).build(null));
+    //public static final RegistryObject<TileEntityType<TileEntityLeafGenerator>> LEAFGENERATOR_TILE = TILES.register("leafGenerator", () -> TileEntityType.Builder.create(TileEntityLeafGenerator::new, ActuallyBlocks.LEAF_GENERATOR.get()).build(null));
     public static final RegistryObject<TileEntityType<TileEntityDirectionalBreaker>> DIRECTIONALBREAKER_TILE = TILES.register("directionalBreaker", () -> TileEntityType.Builder.create(TileEntityDirectionalBreaker::new, ActuallyBlocks.DIRECTIONAL_BREAKER.get()).build(null));
     public static final RegistryObject<TileEntityType<TileEntityRangedCollector>> RANGEDCOLLECTOR_TILE = TILES.register("rangedCollector", () -> TileEntityType.Builder.create(TileEntityRangedCollector::new, ActuallyBlocks.RANGED_COLLECTOR.get()).build(null));
     public static final RegistryObject<TileEntityType<TileEntityAtomicReconstructor>> ATOMICRECONSTRUCTOR_TILE = TILES.register("reconstructor", () -> TileEntityType.Builder.create(TileEntityAtomicReconstructor::new, ActuallyBlocks.ATOMIC_RECONSTRUCTOR.get()).build(null));
     public static final RegistryObject<TileEntityType<TileEntityMiner>> MINER_TILE = TILES.register("miner", () -> TileEntityType.Builder.create(TileEntityMiner::new, ActuallyBlocks.MINER.get()).build(null));
     public static final RegistryObject<TileEntityType<TileEntityFireworkBox>> FIREWORKBOX_TILE = TILES.register("fireworkBox", () -> TileEntityType.Builder.create(TileEntityFireworkBox::new, ActuallyBlocks.FIREWORK_BOX.get()).build(null));
-    public static final RegistryObject<TileEntityType<TileEntityPhantomRedstoneface>> PHANTOMREDSTONEFACE_TILE = TILES.register("redstoneface", () -> TileEntityType.Builder.create(TileEntityPhantomRedstoneface::new, ActuallyBlocks.PHANTOM_REDSTONEFACE.get()).build(null));
+    //public static final RegistryObject<TileEntityType<TileEntityPhantomRedstoneface>> PHANTOMREDSTONEFACE_TILE = TILES.register("redstoneface", () -> TileEntityType.Builder.create(TileEntityPhantomRedstoneface::new, ActuallyBlocks.PHANTOM_REDSTONEFACE.get()).build(null));
     public static final RegistryObject<TileEntityType<TileEntityLaserRelayItem>> LASERRELAYITEM_TILE = TILES.register("laserRelayItem", () -> TileEntityType.Builder.create(TileEntityLaserRelayItem::new, ActuallyBlocks.LASER_RELAY_ITEM.get()).build(null));
     public static final RegistryObject<TileEntityType<TileEntityLaserRelayEnergy>> LASERRELAYENERGY_TILE = TILES.register("laserRelay", () -> TileEntityType.Builder.create(TileEntityLaserRelayEnergy::new, ActuallyBlocks.LASER_RELAY.get()).build(null));
     public static final RegistryObject<TileEntityType<TileEntityLaserRelayEnergyAdvanced>> LASERRELAYENERGYADVANCED_TILE = TILES.register("laserRelayAdvanced", () -> TileEntityType.Builder.create(TileEntityLaserRelayEnergyAdvanced::new, ActuallyBlocks.LASER_RELAY_ADVANCED.get()).build(null));
     public static final RegistryObject<TileEntityType<TileEntityLaserRelayEnergyExtreme>> LASERRELAYENERGYEXTREME_TILE = TILES.register("laserRelayExtreme", () -> TileEntityType.Builder.create(TileEntityLaserRelayEnergyExtreme::new, ActuallyBlocks.LASER_RELAY_EXTREME.get()).build(null));
     public static final RegistryObject<TileEntityType<TileEntityLaserRelayItemWhitelist>> LASERRELAYITEMWHITELIST_TILE = TILES.register("laserRelayItemWhitelist", () -> TileEntityType.Builder.create(TileEntityLaserRelayItemWhitelist::new, ActuallyBlocks.LASER_RELAY_ITEM_WHITELIST.get()).build(null));
-    public static final RegistryObject<TileEntityType<TileEntityItemViewer>> ITEMVIEWER_TILE = TILES.register("itemViewer", () -> TileEntityType.Builder.create(TileEntityItemViewer::new, ActuallyBlocks.ITEM_VIEWER.get()).build(null));
+    //public static final RegistryObject<TileEntityType<TileEntityItemInterface>> ITEMVIEWER_TILE = TILES.register("itemViewer", () -> TileEntityType.Builder.create(TileEntityItemInterface::new, ActuallyBlocks.ITEM_VIEWER.get()).build(null));
-    public static final RegistryObject<TileEntityType<TileEntityDisplayStand>> DISPLAYSTAND_TILE = TILES.register("displayStand", () -> TileEntityType.Builder.create(TileEntityDisplayStand::new, ActuallyBlocks.DISPLAY_STAND.get()).build(null));
+    //public static final RegistryObject<TileEntityType<TileEntityDisplayStand>> DISPLAYSTAND_TILE = TILES.register("displayStand", () -> TileEntityType.Builder.create(TileEntityDisplayStand::new, ActuallyBlocks.DISPLAY_STAND.get()).build(null));
     public static final RegistryObject<TileEntityType<TileEntityShockSuppressor>> SHOCKSUPPRESSOR_TILE = TILES.register("shockSuppressor", () -> TileEntityType.Builder.create(TileEntityShockSuppressor::new, ActuallyBlocks.SHOCK_SUPPRESSOR.get()).build(null));
-    public static final RegistryObject<TileEntityType<TileEntityEmpowerer>> EMPOWERER_TILE = TILES.register("empowerer", () -> TileEntityType.Builder.create(TileEntityEmpowerer::new, ActuallyBlocks.EMPOWERER.get()).build(null));
+    //public static final RegistryObject<TileEntityType<TileEntityEmpowerer>> EMPOWERER_TILE = TILES.register("empowerer", () -> TileEntityType.Builder.create(TileEntityEmpowerer::new, ActuallyBlocks.EMPOWERER.get()).build(null));
     public static final RegistryObject<TileEntityType<TileEntityLaserRelayFluids>> LASERRELAYFLUIDS_TILE = TILES.register("laserRelayFluids", () -> TileEntityType.Builder.create(TileEntityLaserRelayFluids::new, ActuallyBlocks.LASER_RELAY_FLUIDS.get()).build(null));
-    public static final RegistryObject<TileEntityType<TileEntityBioReactor>> BIOREACTOR_TILE = TILES.register("bioReactor", () -> TileEntityType.Builder.create(TileEntityBioReactor::new, ActuallyBlocks.BIOREACTOR.get()).build(null));
+    //public static final RegistryObject<TileEntityType<TileEntityBioReactor>> BIOREACTOR_TILE = TILES.register("bioReactor", () -> TileEntityType.Builder.create(TileEntityBioReactor::new, ActuallyBlocks.BIOREACTOR.get()).build(null));
-    public static final RegistryObject<TileEntityType<TileEntityFarmer>> FARMER_TILE = TILES.register("farmer", () -> TileEntityType.Builder.create(TileEntityFarmer::new, ActuallyBlocks.FARMER.get()).build(null));
+    //public static final RegistryObject<TileEntityType<TileEntityFarmer>> FARMER_TILE = TILES.register("farmer", () -> TileEntityType.Builder.create(TileEntityFarmer::new, ActuallyBlocks.FARMER.get()).build(null));
-    public static final RegistryObject<TileEntityType<TileEntityItemViewerHopping>> ITEMVIEWERHOPPING_TILE = TILES.register("itemViewerHopping", () -> TileEntityType.Builder.create(TileEntityItemViewerHopping::new, ActuallyBlocks.ITEM_VIEWER.get()).build(null));
+    //public static final RegistryObject<TileEntityType<TileEntityItemInterfaceHopping>> ITEMVIEWERHOPPING_TILE = TILES.register("itemViewerHopping", () -> TileEntityType.Builder.create(TileEntityItemInterfaceHopping::new, ActuallyBlocks.ITEM_VIEWER.get()).build(null));
-    public static final RegistryObject<TileEntityType<TileEntityBatteryBox>> BATTERYBOX_TILE = TILES.register("batteryBox", () -> TileEntityType.Builder.create(TileEntityBatteryBox::new, ActuallyBlocks.BATTERY_BOX.get()).build(null));
+    //public static final RegistryObject<TileEntityType<TileEntityBatteryBox>> BATTERYBOX_TILE = TILES.register("batteryBox", () -> TileEntityType.Builder.create(TileEntityBatteryBox::new, ActuallyBlocks.BATTERY_BOX.get()).build(null));
 }

src/main/java/de/ellpeck/actuallyadditions/mod/tile/TileEntityCrusher.java

@@ -37,7 +37,7 @@ import net.minecraftforge.energy.IEnergyStorage;
 
 import javax.annotation.Nullable;
 
-public class TileEntityGrinder extends TileEntityInventoryBase implements IButtonReactor, INamedContainerProvider {
+public class TileEntityCrusher extends TileEntityInventoryBase implements IButtonReactor, INamedContainerProvider {
 
     public static final int SLOT_INPUT_1 = 0;
     public static final int SLOT_OUTPUT_1_1 = 1;
@@ -58,11 +58,11 @@ public class TileEntityGrinder extends TileEntityInventoryBase implements IButto
     private boolean lastAutoSplit;
     private boolean lastCrushed;
 
-    public TileEntityGrinder(TileEntityType<?> type, int slots) {
+    public TileEntityCrusher(TileEntityType<?> type, int slots) {
         super(type, slots);
     }
 
-    public TileEntityGrinder() {
+    public TileEntityCrusher() {
         super(ActuallyTiles.GRINDER_TILE.get(), 3);
         this.isDouble = false;
     }

src/main/java/de/ellpeck/actuallyadditions/mod/tile/TileEntityCrusherDouble.java

@@ -10,9 +10,9 @@
 
 package de.ellpeck.actuallyadditions.mod.tile;
 
-public class TileEntityGrinderDouble extends TileEntityGrinder {
+public class TileEntityCrusherDouble extends TileEntityCrusher {
 
-    public TileEntityGrinderDouble() {
+    public TileEntityCrusherDouble() {
         super(ActuallyTiles.GRINDER_DOUBLE_TILE.get(), 6);
         this.isDouble = true;
     }

src/main/java/de/ellpeck/actuallyadditions/mod/tile/TileEntityInputter.java

@@ -97,7 +97,7 @@ public class TileEntityInputter extends TileEntityInventoryBase implements IButt
                 ? null
                 : this.leftFilter);
 
-            if (this.placeToPull instanceof TileEntityItemViewer) {
+            if (this.placeToPull instanceof TileEntityItemInterface) {
                 break;
             }
         }
@@ -109,7 +109,7 @@ public class TileEntityInputter extends TileEntityInventoryBase implements IButt
             for (Direction side : this.placeToPut.keySet()) {
                 WorldUtil.doItemInteraction(this.wrapper, this.placeToPut.get(side), Integer.MAX_VALUE, 0, 1, this.slotToPutStart, this.slotToPutEnd, null);
 
-                if (this.placeToPut instanceof TileEntityItemViewer) {
+                if (this.placeToPut instanceof TileEntityItemInterface) {
                     break;
                 }
             }

src/main/java/de/ellpeck/actuallyadditions/mod/tile/TileEntityItemInterface.java

@@ -32,7 +32,7 @@ import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 import java.util.*;
 
-public class TileEntityItemViewer extends TileEntityBase {
+public class TileEntityItemInterface extends TileEntityBase {
 
     public final List<GenericItemHandlerInfo> genericInfos = new ArrayList<>();
     public final Map<Integer, IItemHandlerInfo> itemHandlerInfos = new HashMap<>();
@@ -43,18 +43,18 @@ public class TileEntityItemViewer extends TileEntityBase {
     private int lastNetworkChangeAmount = -1;
     private int slotCount;
 
-    public TileEntityItemViewer(TileEntityType<?> type) {
+    public TileEntityItemInterface(TileEntityType<?> type) {
         super(type);
 
         IItemHandler normalHandler = new IItemHandler() {
             @Override
             public int getSlots() {
-                return TileEntityItemViewer.this.getSlotCount();
+                return TileEntityItemInterface.this.getSlotCount();
             }
 
             @Override
             public ItemStack getStackInSlot(int slot) {
-                IItemHandlerInfo handler = TileEntityItemViewer.this.getSwitchedIndexHandler(slot);
+                IItemHandlerInfo handler = TileEntityItemInterface.this.getSwitchedIndexHandler(slot);
                 if (handler != null && handler.isLoaded()) {
                     return handler.handler.getStackInSlot(handler.switchedIndex);
                 }
@@ -63,12 +63,12 @@ public class TileEntityItemViewer extends TileEntityBase {
 
             @Override
             public ItemStack insertItem(int slot, ItemStack stack, boolean simulate) {
-                IItemHandlerInfo info = TileEntityItemViewer.this.getSwitchedIndexHandler(slot);
+                IItemHandlerInfo info = TileEntityItemInterface.this.getSwitchedIndexHandler(slot);
-                if (info != null && info.isLoaded() && TileEntityItemViewer.this.isWhitelisted(info, stack, false)) {
+                if (info != null && info.isLoaded() && TileEntityItemInterface.this.isWhitelisted(info, stack, false)) {
                     ItemStack remain = info.handler.insertItem(info.switchedIndex, stack, simulate);
                     if (!ItemStack.areItemStacksEqual(remain, stack) && !simulate) {
-                        TileEntityItemViewer.this.markDirty();
+                        TileEntityItemInterface.this.markDirty();
-                        TileEntityItemViewer.this.doItemParticle(stack, info.relayInQuestion.getPos(), TileEntityItemViewer.this.connectedRelay.getPos());
+                        TileEntityItemInterface.this.doItemParticle(stack, info.relayInQuestion.getPos(), TileEntityItemInterface.this.connectedRelay.getPos());
                     }
                     return remain;
                 }
@@ -79,12 +79,12 @@ public class TileEntityItemViewer extends TileEntityBase {
             public ItemStack extractItem(int slot, int amount, boolean simulate) {
                 ItemStack stackIn = this.getStackInSlot(slot);
                 if (StackUtil.isValid(stackIn)) {
-                    IItemHandlerInfo info = TileEntityItemViewer.this.getSwitchedIndexHandler(slot);
+                    IItemHandlerInfo info = TileEntityItemInterface.this.getSwitchedIndexHandler(slot);
-                    if (info != null && info.isLoaded() && TileEntityItemViewer.this.isWhitelisted(info, stackIn, true)) {
+                    if (info != null && info.isLoaded() && TileEntityItemInterface.this.isWhitelisted(info, stackIn, true)) {
                         ItemStack extracted = info.handler.extractItem(info.switchedIndex, amount, simulate);
                         if (StackUtil.isValid(extracted) && !simulate) {
-                            TileEntityItemViewer.this.markDirty();
+                            TileEntityItemInterface.this.markDirty();
-                            TileEntityItemViewer.this.doItemParticle(extracted, TileEntityItemViewer.this.connectedRelay.getPos(), info.relayInQuestion.getPos());
+                            TileEntityItemInterface.this.doItemParticle(extracted, TileEntityItemInterface.this.connectedRelay.getPos(), info.relayInQuestion.getPos());
                         }
                         return extracted;
                     }
@@ -94,7 +94,7 @@ public class TileEntityItemViewer extends TileEntityBase {
 
             @Override
             public int getSlotLimit(int slot) {
-                IItemHandlerInfo info = TileEntityItemViewer.this.getSwitchedIndexHandler(slot);
+                IItemHandlerInfo info = TileEntityItemInterface.this.getSwitchedIndexHandler(slot);
                 if (info != null && info.isLoaded()) {
                     return info.handler.getSlotLimit(info.switchedIndex);
                 } else {
@@ -117,7 +117,7 @@ public class TileEntityItemViewer extends TileEntityBase {
         this.itemHandler = new SlotlessableItemHandlerWrapper(this.lazyHandlers, slotlessHandler);
     }
 
-    public TileEntityItemViewer() {
+    public TileEntityItemInterface() {
         this(ActuallyTiles.ITEMVIEWER_TILE.get());
     }
 

src/main/java/de/ellpeck/actuallyadditions/mod/tile/TileEntityItemInterfaceHopping.java

@@ -28,12 +28,12 @@ import net.minecraftforge.items.IItemHandler;
 
 import java.util.List;
 
-public class TileEntityItemViewerHopping extends TileEntityItemViewer {
+public class TileEntityItemInterfaceHopping extends TileEntityItemInterface {
 
     private SlotlessableItemHandlerWrapper handlerToPullFrom;
     private SlotlessableItemHandlerWrapper handlerToPushTo;
 
-    public TileEntityItemViewerHopping() {
+    public TileEntityItemInterfaceHopping() {
         super(ActuallyTiles.ITEMVIEWERHOPPING_TILE.get());
     }
 
@@ -97,7 +97,7 @@ public class TileEntityItemViewerHopping extends TileEntityItemViewer {
         this.handlerToPushTo = null;
 
         TileEntity from = this.world.getTileEntity(this.pos.offset(Direction.UP));
-        if (from != null && !(from instanceof TileEntityItemViewer)) {
+        if (from != null && !(from instanceof TileEntityItemInterface)) {
             LazyOptional<IItemHandler> normal = from.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, Direction.DOWN);
 
             Object slotless = null;
@@ -118,7 +118,7 @@ public class TileEntityItemViewerHopping extends TileEntityItemViewer {
         BlockPos toPos = this.pos.offset(facing);
         if (this.world.isBlockLoaded(toPos)) {
             TileEntity to = this.world.getTileEntity(toPos);
-            if (to != null && !(to instanceof TileEntityItemViewer)) {
+            if (to != null && !(to instanceof TileEntityItemInterface)) {
                 LazyOptional<IItemHandler> normal = to.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, facing.getOpposite());
 
                 Object slotless = null;

src/main/java/de/ellpeck/actuallyadditions/mod/tile/TileEntityLaserRelayItem.java

@@ -14,7 +14,7 @@ import de.ellpeck.actuallyadditions.api.laser.IConnectionPair;
 import de.ellpeck.actuallyadditions.api.laser.LaserType;
 import de.ellpeck.actuallyadditions.api.laser.Network;
 import de.ellpeck.actuallyadditions.mod.ActuallyAdditions;
-import de.ellpeck.actuallyadditions.mod.tile.TileEntityItemViewer.GenericItemHandlerInfo;
+import de.ellpeck.actuallyadditions.mod.tile.TileEntityItemInterface.GenericItemHandlerInfo;
 import de.ellpeck.actuallyadditions.mod.util.StringUtil;
 import de.ellpeck.actuallyadditions.mod.util.WorldUtil;
 import de.ellpeck.actuallyadditions.mod.util.compat.SlotlessableItemHandlerWrapper;
@@ -72,7 +72,7 @@ public class TileEntityLaserRelayItem extends TileEntityLaserRelay {
             BlockPos pos = this.getPos().offset(side);
             if (this.world.isBlockLoaded(pos)) {
                 TileEntity tile = this.world.getTileEntity(pos);
-                if (tile != null && !(tile instanceof TileEntityItemViewer) && !(tile instanceof TileEntityLaserRelay)) {
+                if (tile != null && !(tile instanceof TileEntityItemInterface) && !(tile instanceof TileEntityLaserRelay)) {
                     LazyOptional<IItemHandler> itemHandler = tile.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, side.getOpposite());
 
                     Object slotlessHandler = null;

src/main/java/de/ellpeck/actuallyadditions/mod/tile/TileEntityLavaFactoryController.java

@@ -80,7 +80,7 @@ public class TileEntityLavaFactoryController extends TileEntityBase implements I
         BlockPos thisPos = this.pos;
         BlockPos[] positions = new BlockPos[]{thisPos.add(1, 1, 0), thisPos.add(-1, 1, 0), thisPos.add(0, 1, 1), thisPos.add(0, 1, -1)};
 
-        if (this.world != null && WorldUtil.hasBlocksInPlacesGiven(positions, ActuallyBlocks.LAVA_CASING.get(), this.world)) {
+        if (this.world != null && WorldUtil.hasBlocksInPlacesGiven(positions, ActuallyBlocks.LAVA_FACTORY_CASING.get(), this.world)) {
             BlockPos pos = thisPos.up();
             BlockState state = this.world.getBlockState(pos);
             Block block = state.getBlock();

src/main/java/de/ellpeck/actuallyadditions/mod/tile/TileEntityMiner.java

@@ -94,7 +94,7 @@ public class TileEntityMiner extends TileEntityInventoryBase implements IButtonR
 
             if (!this.isRedstonePowered && this.ticksElapsed % 5 == 0) {
                 if (this.checkY != 0) {
-                    int range = TileEntityPhantomface.upgradeRange(DEFAULT_RANGE, this.world, this.pos);
+                    int range = TileEntityPhantomFace.upgradeRange(DEFAULT_RANGE, this.world, this.pos);
                     if (this.checkY < 0) {
                         this.checkY = this.pos.getY() - 1;
                         this.checkX = -range;

src/main/java/de/ellpeck/actuallyadditions/mod/tile/TileEntityPhantomEnergyface.java

@@ -16,7 +16,7 @@ import net.minecraft.util.Direction;
 import net.minecraftforge.common.capabilities.Capability;
 import net.minecraftforge.energy.CapabilityEnergy;
 
-public class TileEntityPhantomEnergyface extends TileEntityPhantomface implements ISharingEnergyProvider {
+public class TileEntityPhantomEnergyface extends TileEntityPhantomFace implements ISharingEnergyProvider {
 
     public TileEntityPhantomEnergyface() {
         super(ActuallyTiles.PHANTOMENERGYFACE_TILE.get());

src/main/java/de/ellpeck/actuallyadditions/mod/tile/TileEntityPhantomFace.java

@@ -30,7 +30,7 @@ import net.minecraftforge.common.util.LazyOptional;
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
-public abstract class TileEntityPhantomface extends TileEntityInventoryBase implements IPhantomTile {
+public abstract class TileEntityPhantomFace extends TileEntityInventoryBase implements IPhantomTile {
 
     public static final int RANGE = 16;
     public BlockPos boundPosition;
@@ -41,7 +41,7 @@ public abstract class TileEntityPhantomface extends TileEntityInventoryBase impl
     private Block boundBlockBefore;
     private int lastStrength;
 
-    public TileEntityPhantomface(TileEntityType<?> type) {
+    public TileEntityPhantomFace(TileEntityType<?> type) {
         super(type, 0);
     }
 

src/main/java/de/ellpeck/actuallyadditions/mod/tile/TileEntityPhantomItemface.java

@@ -18,7 +18,7 @@ import net.minecraft.util.Direction;
 import net.minecraftforge.common.capabilities.Capability;
 import net.minecraftforge.items.CapabilityItemHandler;
 
-public class TileEntityPhantomItemface extends TileEntityPhantomface {
+public class TileEntityPhantomItemface extends TileEntityPhantomFace {
 
     public TileEntityPhantomItemface() {
         super(ActuallyTiles.PHANTOMITEMFACE_TILE.get());

src/main/java/de/ellpeck/actuallyadditions/mod/tile/TileEntityPhantomLiquiface.java

@@ -16,7 +16,7 @@ import net.minecraft.util.Direction;
 import net.minecraftforge.common.capabilities.Capability;
 import net.minecraftforge.fluids.capability.CapabilityFluidHandler;
 
-public class TileEntityPhantomLiquiface extends TileEntityPhantomface implements ISharingFluidHandler {
+public class TileEntityPhantomLiquiface extends TileEntityPhantomFace implements ISharingFluidHandler {
 
     public TileEntityPhantomLiquiface() {
         super(ActuallyTiles.PHANTOMLIQUIFACE_TILE.get());

src/main/java/de/ellpeck/actuallyadditions/mod/tile/TileEntityPhantomPlacer.java

@@ -95,7 +95,7 @@ public class TileEntityPhantomPlacer extends TileEntityInventoryBase implements
     public void updateEntity() {
         super.updateEntity();
         if (!this.world.isRemote) {
-            this.range = TileEntityPhantomface.upgradeRange(RANGE, this.world, this.pos);
+            this.range = TileEntityPhantomFace.upgradeRange(RANGE, this.world, this.pos);
 
             if (!this.hasBoundPosition()) {
                 this.boundPosition = null;

src/main/java/de/ellpeck/actuallyadditions/mod/tile/TileEntityPhantomRedstoneface.java

@@ -17,7 +17,7 @@ import net.minecraftforge.common.capabilities.Capability;
 
 import java.util.Arrays;
 
-public class TileEntityPhantomRedstoneface extends TileEntityPhantomface {
+public class TileEntityPhantomRedstoneface extends TileEntityPhantomFace {
 
     public final int[] providesStrong = new int[Direction.values().length];
     public final int[] providesWeak = new int[Direction.values().length];

src/main/java/de/ellpeck/actuallyadditions/mod/tile/TileEntityPlayerInterface.java

@@ -73,7 +73,7 @@ public class TileEntityPlayerInterface extends TileEntityBase implements IEnergy
         if (!this.world.isRemote) {
             boolean changed = false;
 
-            this.range = TileEntityPhantomface.upgradeRange(DEFAULT_RANGE, this.world, this.pos);
+            this.range = TileEntityPhantomFace.upgradeRange(DEFAULT_RANGE, this.world, this.pos);
 
             PlayerEntity player = this.getPlayer();
             if (player != null) {