add Essentia Hatch

6 files changed, 411 insertions, 59 deletions

diff --git a/src/main/java/GoodGenerator/Blocks/RegularBlock/TEBlock.java b/src/main/java/GoodGenerator/Blocks/RegularBlock/TEBlock.java
new file mode 100644
index 0000000000..ec23abde91
--- /dev/null
+++ b/src/main/java/GoodGenerator/Blocks/RegularBlock/TEBlock.java
@@ -0,0 +1,141 @@
+package GoodGenerator.Blocks.RegularBlock;
+
+import GoodGenerator.Blocks.TEs.EssentiaHatch;
+import GoodGenerator.Main.GoodGenerator;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import gregtech.api.GregTech_API;
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockContainer;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EnumCreatureType;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+
+import java.util.List;
+
+public class TEBlock extends BlockContainer {
+
+    @SideOnly(Side.CLIENT)
+    protected IIcon[] texture;
+    String[] textureNames;
+    protected String name;
+    int index;
+
+    public TEBlock(String name, String[] texture, CreativeTabs Tab){
+        super(Material.iron);
+        this.setHardness(9.0F);
+        this.setResistance(5.0F);
+        this.name = name;
+        this.textureNames = texture;
+        this.setHarvestLevel("wrench",2);
+        this.setCreativeTab(GoodGenerator.GG);
+        GregTech_API.registerMachineBlock(this, -1);
+    }
+
+    public TEBlock(String name, String[] texture, int index){
+        super(Material.iron);
+        this.setHardness(9.0F);
+        this.setResistance(5.0F);
+        this.name = name;
+        this.textureNames = texture;
+        this.setHarvestLevel("wrench",2);
+        this.index = index;
+        this.setCreativeTab(GoodGenerator.GG);
+        GregTech_API.registerMachineBlock(this, -1);
+    }
+
+    public TEBlock(String name, String[] texture, Material material){
+        super(material);
+        this.setHardness(9.0F);
+        this.setResistance(5.0F);
+        this.name = name;
+        this.textureNames = texture;
+        this.setHarvestLevel("wrench",2);
+        this.setCreativeTab(GoodGenerator.GG);
+        GregTech_API.registerMachineBlock(this, -1);
+    }
+
+    @Override
+    public int damageDropped(int meta) {
+        return meta;
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public IIcon getIcon(int side, int meta) {
+        return meta < this.texture.length ? this.texture[meta] : this.texture[0];
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void registerBlockIcons(IIconRegister par1IconRegister) {
+        this.texture = new IIcon[this.textureNames.length];
+        for (int i = 0; i < this.textureNames.length; i++) {
+            this.texture[i] = par1IconRegister.registerIcon(this.textureNames[i]);
+        }
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    @SuppressWarnings("unchecked")
+    public void getSubBlocks(Item item, CreativeTabs tab, List list) {
+        for (int i = 0; i < this.textureNames.length; i++) {
+            list.add(new ItemStack(item, 1, i));
+        }
+    }
+
+    @Override
+    public void onBlockAdded(World aWorld, int aX, int aY, int aZ) {
+        if (GregTech_API.isMachineBlock(this, aWorld.getBlockMetadata(aX, aY, aZ))) {
+            GregTech_API.causeMachineUpdate(aWorld, aX, aY, aZ);
+        }
+    }
+
+    @Override
+    public void breakBlock(World aWorld, int aX, int aY, int aZ, Block aBlock, int aMetaData) {
+        if (GregTech_API.isMachineBlock(this, aWorld.getBlockMetadata(aX, aY, aZ))) {
+            GregTech_API.causeMachineUpdate(aWorld, aX, aY, aZ);
+        }
+        aWorld.removeTileEntity(aX, aY, aZ);
+    }
+
+    @Override
+    public String getUnlocalizedName() {
+        return this.name;
+    }
+
+    @Override
+    public boolean canBeReplacedByLeaves(IBlockAccess world, int x, int y, int z) {
+        return false;
+    }
+
+    @Override
+    public boolean canEntityDestroy(IBlockAccess world, int x, int y, int z, Entity entity) {
+        return false;
+    }
+
+    @Override
+    public boolean canCreatureSpawn(EnumCreatureType type, IBlockAccess world, int x, int y, int z) {
+        return false;
+    }
+
+    @Override
+    public TileEntity createTileEntity(World world, int meta) {
+        if (index == 1)
+            return new EssentiaHatch();
+        return null;
+    }
+
+    @Override
+    public TileEntity createNewTileEntity(World p_149915_1_, int p_149915_2_) {
+        return null;
+    }
+}
diff --git a/src/main/java/GoodGenerator/Blocks/TEs/EssentiaHatch.java b/src/main/java/GoodGenerator/Blocks/TEs/EssentiaHatch.java
new file mode 100644
index 0000000000..2a86d374e8
--- /dev/null
+++ b/src/main/java/GoodGenerator/Blocks/TEs/EssentiaHatch.java
@@ -0,0 +1,213 @@
+package GoodGenerator.Blocks.TEs;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.network.NetworkManager;
+import net.minecraft.network.Packet;
+import net.minecraft.network.play.server.S35PacketUpdateTileEntity;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.util.ForgeDirection;
+import thaumcraft.api.ThaumcraftApiHelper;
+import thaumcraft.api.aspects.Aspect;
+import thaumcraft.api.aspects.AspectList;
+import thaumcraft.api.aspects.IAspectContainer;
+import thaumcraft.api.aspects.IEssentiaTransport;
+
+import java.util.ArrayList;
+
+public class EssentiaHatch extends TileEntity implements IAspectContainer, IEssentiaTransport {
+
+    public int facing;
+    public boolean isOn;
+
+    private AspectList current = new AspectList();
+
+    @Override
+    public void readFromNBT(NBTTagCompound tagCompound) {
+        super.readFromNBT(tagCompound);
+
+        this.facing = tagCompound.getInteger("facing");
+        this.isOn = tagCompound.getBoolean("isOn");
+
+        current = new AspectList();
+        NBTTagList tlist = tagCompound.getTagList("Aspects", 10);
+        for (int j = 0; j < tlist.tagCount(); ++j) {
+            NBTTagCompound rs = tlist.getCompoundTagAt(j);
+            if (rs.hasKey("key")) {
+                current.add(Aspect.getAspect(rs.getString("key")), rs.getInteger("amount"));
+            }
+        }
+    }
+
+    @Override
+    public void writeToNBT(NBTTagCompound tagCompound) {
+        super.writeToNBT(tagCompound);
+
+        tagCompound.setInteger("facing", this.facing);
+        tagCompound.setBoolean("isOn", this.isOn);
+
+        NBTTagList tlist = new NBTTagList();
+        Aspect[] aspectA = current.getAspects();
+        for (Aspect aspect : aspectA) {
+            if (aspect != null) {
+                NBTTagCompound f = new NBTTagCompound();
+                f.setString("key", aspect.getTag());
+                f.setInteger("amount", current.getAmount(aspect));
+                tlist.appendTag(f);
+            }
+        }
+        tagCompound.setTag("Aspects", tlist);
+    }
+
+    public final Packet getDescriptionPacket() {
+        NBTTagCompound nbt = new NBTTagCompound();
+        writeToNBT(nbt);
+        return new S35PacketUpdateTileEntity(this.xCoord, this.yCoord, this.zCoord, 0, nbt);
+    }
+
+    public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity pkt) {
+        NBTTagCompound nbt = pkt.func_148857_g();
+        readFromNBT(nbt);
+    }
+
+    public void markDirty() {
+        super.markDirty();
+        if (this.worldObj.isRemote) {
+            return;
+        }
+        this.worldObj.markBlockForUpdate(this.xCoord, this.yCoord, this.zCoord);
+    }
+
+    @Override
+    public void updateEntity() {
+        fillfrompipe();
+    }
+
+    public void fillfrompipe() {
+        TileEntity[] te = new TileEntity[ForgeDirection.VALID_DIRECTIONS.length];
+        for (int i = 0; i < ForgeDirection.VALID_DIRECTIONS.length; i++) {
+            te[i] = ThaumcraftApiHelper.getConnectableTile(this.worldObj, this.xCoord, this.yCoord, this.zCoord, ForgeDirection.VALID_DIRECTIONS[i]);
+            if (te[i] != null) {
+                IEssentiaTransport pipe = (IEssentiaTransport) te[i];
+                if (!pipe.canOutputTo(ForgeDirection.VALID_DIRECTIONS[i])) {
+                    return;
+                }
+                if ((pipe.getEssentiaType(ForgeDirection.VALID_DIRECTIONS[i]) != null) && (pipe.getSuctionAmount(ForgeDirection.VALID_DIRECTIONS[i]) < getSuctionAmount(ForgeDirection.VALID_DIRECTIONS[i]))) {
+                    addToContainer(pipe.getEssentiaType(ForgeDirection.VALID_DIRECTIONS[i]), pipe.takeEssentia(pipe.getEssentiaType(ForgeDirection.VALID_DIRECTIONS[i]), 1, ForgeDirection.VALID_DIRECTIONS[i]));
+                }
+            }
+        }
+    }
+
+    @Override
+    public AspectList getAspects() {
+        return current;
+    }
+
+    @Override
+    public void setAspects(AspectList aspectList) {
+        this.current.add(aspectList);
+    }
+
+    @Override
+    public boolean doesContainerAccept(Aspect aspect) {
+        return true;
+    }
+
+    @Override
+    public int addToContainer(Aspect aspect, int i) {
+        current.add(aspect, i);
+        return 0;
+    }
+
+    @Override
+    public boolean takeFromContainer(Aspect aspect, int i) {
+        return false;
+    }
+
+    @Override
+    public boolean takeFromContainer(AspectList aspectList) {
+        return false;
+    }
+
+    @Override
+    public boolean doesContainerContainAmount(Aspect aspect, int i) {
+        return current.aspects.containsKey(aspect) && i <= current.getAmount(aspect);
+    }
+
+    @Override
+    public boolean doesContainerContain(AspectList aspectList) {
+        ArrayList<Boolean> ret = new ArrayList<Boolean>();
+        for (Aspect a : aspectList.aspects.keySet())
+            ret.add(current.aspects.containsKey(a));
+        return !ret.contains(false);
+    }
+
+    @Override
+    public int containerContains(Aspect aspect) {
+        return current.aspects.containsKey(aspect) ? current.getAmount(aspect) : 0;
+    }
+
+    @Override
+    public boolean isConnectable(ForgeDirection forgeDirection) {
+        return true;
+    }
+
+    @Override
+    public boolean canInputFrom(ForgeDirection forgeDirection) {
+        return true;
+    }
+
+    @Override
+    public boolean canOutputTo(ForgeDirection forgeDirection) {
+        return false;
+    }
+
+    @Override
+    public void setSuction(Aspect aspect, int i) { }
+
+    @Override
+    public Aspect getSuctionType(ForgeDirection forgeDirection) {
+        return null;
+    }
+
+    @Override
+    public int getSuctionAmount(ForgeDirection forgeDirection) {
+        return 256;
+    }
+
+    @Override
+    public int takeEssentia(Aspect aspect, int i, ForgeDirection forgeDirection) {
+        return 0;
+    }
+
+    @Override
+    public int addEssentia(Aspect aspect, int i, ForgeDirection forgeDirection) {
+        current.add(aspect, i);
+        return 0;
+    }
+
+    @Override
+    public Aspect getEssentiaType(ForgeDirection forgeDirection) {
+        return current.getAspects()[0];
+    }
+
+    @Override
+    public int getEssentiaAmount(ForgeDirection forgeDirection) {
+        int ret = 0;
+        for (final Aspect A : current.aspects.keySet()) {
+            ret += current.getAmount(A);
+        }
+        return ret;
+    }
+
+    @Override
+    public int getMinimumSuction() {
+        return Integer.MAX_VALUE;
+    }
+
+    @Override
+    public boolean renderExtendedTube() {
+        return true;
+    }
+}
diff --git a/src/main/java/GoodGenerator/Blocks/TEs/LargeEssentiaGenerator.java b/src/main/java/GoodGenerator/Blocks/TEs/LargeEssentiaGenerator.java
index 818d31c715..6af2e59e14 100644
--- a/src/main/java/GoodGenerator/Blocks/TEs/LargeEssentiaGenerator.java
+++ b/src/main/java/GoodGenerator/Blocks/TEs/LargeEssentiaGenerator.java
@@ -16,30 +16,25 @@ import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
 import gregtech.api.metatileentity.implementations.*;
 import gregtech.api.objects.GT_RenderedTexture;
 import gregtech.api.render.TextureFactory;
-import gregtech.api.util.GT_Log;
+import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.tileentity.TileEntity;
-import net.minecraftforge.common.util.ForgeDirection;
 import thaumcraft.api.aspects.Aspect;
 import thaumcraft.api.aspects.AspectList;
-import thaumcraft.api.aspects.AspectSourceHelper;
-import thaumcraft.api.aspects.IAspectContainer;
 import thaumcraft.common.config.ConfigBlocks;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Set;
 
 import static com.github.technus.tectech.mechanics.structure.StructureUtility.*;
 
 public class LargeEssentiaGenerator extends GT_MetaTileEntity_MultiblockBase_EM implements TecTechEnabledMulti, IConstructable {
 
     private IStructureDefinition<LargeEssentiaGenerator> multiDefinition = null;
-    protected List<Aspect> mAvailableAspects = new ArrayList<>(Aspect.aspects.size());
-    protected final int MAX_RANGE = 16;
     protected final int ENERGY_PER_ESSENTIA = 512;
     protected int mStableValue = 0;
+    protected ArrayList<EssentiaHatch> mEssentiaHatch = new ArrayList<>();
 
     public LargeEssentiaGenerator(String name){
         super(name);
@@ -87,6 +82,36 @@ public class LargeEssentiaGenerator extends GT_MetaTileEntity_MultiblockBase_EM
         aNBT.setInteger("mStableValue", this.mStableValue);
     }
 
+    public void getEssentiaHatch() {
+        IGregTechTileEntity aTileEntity = getBaseMetaTileEntity();
+        if (aTileEntity == null) return;
+        mEssentiaHatch.clear();
+        TileEntity hatch = aTileEntity.getTileEntityOffset(4,-2, 0);
+        addEssentiaHatch(hatch);
+        hatch = aTileEntity.getTileEntityOffset(-4,-2, 0);
+        addEssentiaHatch(hatch);
+        hatch = aTileEntity.getTileEntityOffset(0,-2, 4);
+        addEssentiaHatch(hatch);
+        hatch = aTileEntity.getTileEntityOffset(0,-2, -4);
+        addEssentiaHatch(hatch);
+    }
+
+    public void addEssentiaHatch(TileEntity aHatch) {
+        if (aHatch instanceof EssentiaHatch) {
+            mEssentiaHatch.add((EssentiaHatch) aHatch);
+        }
+    }
+
+    @Override
+    public boolean onWrenchRightClick(byte aSide, byte aWrenchingSide, EntityPlayer aPlayer, float aX, float aY, float aZ) {
+        if (aWrenchingSide == 0 || aWrenchingSide == 1) return false;
+        if (getBaseMetaTileEntity().isValidFacing(aWrenchingSide)) {
+            getBaseMetaTileEntity().setFrontFacing(aWrenchingSide);
+            return true;
+        }
+        return false;
+    }
+
     @Override
     public IStructureDefinition<LargeEssentiaGenerator> getStructure_EM() {
         if(multiDefinition == null) {
@@ -144,6 +169,9 @@ public class LargeEssentiaGenerator extends GT_MetaTileEntity_MultiblockBase_EM
                                     ),
                                     ofBlock(
                                             Loaders.magicCasing, 0
+                                    ),
+                                    ofBlock(
+                                            Loaders.essentiaHatch, 0
                                     )
                             )
                     )
@@ -174,65 +202,34 @@ public class LargeEssentiaGenerator extends GT_MetaTileEntity_MultiblockBase_EM
         return false;
     }
 
-    List<Aspect> getAvailableAspects() {
-        return mAvailableAspects;
-    }
-
-    public void scanAvailableAspects() {
-        IGregTechTileEntity tBaseMetaTileEntity = this.getBaseMetaTileEntity();
-        if (tBaseMetaTileEntity.isInvalidTileEntity()) return;
-        int tRange = MAX_RANGE;
-        int tY = tBaseMetaTileEntity.getYCoord();
-        int tMaxY = tBaseMetaTileEntity.getWorld().getHeight()-1;
-        int rYMin = (tY - tRange >= 0) ? -tRange : -(tY);
-        int rYMax = (((tY + tRange) <= tMaxY)? tRange : tMaxY - tY);
-        mAvailableAspects.clear();
-        for (int rX = -tRange; rX <= tRange; rX++) {
-            for (int rZ = -tRange; rZ <= tRange; rZ++) {
-                for (int rY = rYMin; rY < rYMax; rY++) {
-                    TileEntity tTile = tBaseMetaTileEntity.getTileEntityOffset(rX, rY, rZ);
-                    if (tTile instanceof IAspectContainer) {
-                        AspectList tAspectList = ((IAspectContainer) tTile).getAspects();
-                        if (tAspectList == null || tAspectList.aspects.isEmpty()) continue;
-                        Set<Aspect> tAspects = tAspectList.aspects.keySet();
-                        mAvailableAspects.addAll(tAspects);
-                    }
-                }
-            }
-        }
-    }
-
     @Override
     public boolean checkRecipe_EM(ItemStack aStack) {
         this.mEfficiency = 10000;
         this.mMaxProgresstime = 1;
-        scanAvailableAspects();
-        this.mEUt = (int)absorbFromEssentiaContainers();
+        getEssentiaHatch();
+        this.mEUt = (int)getEssentiaToEU();
         return true;
     }
 
+    public long getEssentiaToEU(){
+        long EUt = 0;
+        for (EssentiaHatch hatch: this.mEssentiaHatch){
+            AspectList aspects = hatch.getAspects();
+            for (Aspect aspect: aspects.aspects.keySet()) {
+                while (EUt < 8192 && aspects.getAmount(aspect) > 0) {
+                    EUt += ENERGY_PER_ESSENTIA;
+                    aspects.reduce(aspect, 1);
+                }
+            }
+        }
+        return EUt;
+    }
+
     @Override
     public int getMaxEfficiency(ItemStack aStack) {
         return 10000;
     }
 
-    private long absorbFromEssentiaContainers() {
-        long tEU = 0;
-
-        long tEUtoGen = 8192;
-        List<Aspect> mAvailableEssentiaAspects = getAvailableAspects();
-        for (int i = mAvailableEssentiaAspects.size() - 1; i >= 0 && tEUtoGen > 0; i--) {
-            Aspect aspect = mAvailableEssentiaAspects.get(i);
-            long tAspectEU = ENERGY_PER_ESSENTIA;
-            if (tAspectEU <= tEUtoGen
-                    && AspectSourceHelper.drainEssentia((TileEntity) this.getBaseMetaTileEntity(), aspect, ForgeDirection.UNKNOWN, MAX_RANGE)) {
-                tEUtoGen -= tAspectEU;
-                tEU += tAspectEU;
-            }
-        }
-        return tEU;
-    }
-
     @Override
     public String[] getStructureDescription(ItemStack itemStack) {
         return new String[0];
diff --git a/src/main/java/GoodGenerator/Loader/Loaders.java b/src/main/java/GoodGenerator/Loader/Loaders.java
index 5f3a2c1fdc..a17bedec03 100644
--- a/src/main/java/GoodGenerator/Loader/Loaders.java
+++ b/src/main/java/GoodGenerator/Loader/Loaders.java
@@ -2,10 +2,8 @@ package GoodGenerator.Loader;
 
 import GoodGenerator.Blocks.RegularBlock.Casing;
 import GoodGenerator.Blocks.RegularBlock.Frame;
-import GoodGenerator.Blocks.TEs.FuelRefineFactory;
-import GoodGenerator.Blocks.TEs.LargeEssentiaGenerator;
-import GoodGenerator.Blocks.TEs.MultiNqGenerator;
-import GoodGenerator.Blocks.TEs.UniversalChemicalFuelEngine;
+import GoodGenerator.Blocks.RegularBlock.TEBlock;
+import GoodGenerator.Blocks.TEs.*;
 import GoodGenerator.Items.MyItemBlocks;
 import GoodGenerator.Items.MyItems;
 import GoodGenerator.Main.GoodGenerator;
@@ -14,7 +12,6 @@ import cpw.mods.fml.common.registry.GameRegistry;
 import gregtech.api.enums.Textures;
 import gregtech.api.interfaces.ITexture;
 import gregtech.api.render.TextureFactory;
-import gregtech.api.util.GT_Log;
 import net.minecraft.block.Block;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
@@ -52,6 +49,7 @@ public class Loaders {
     public static final Block titaniumPlatedCylinder = new Casing("titaniumPlatedCylinder", new String[]{GoodGenerator.MOD_ID+":titaniumPlatedCylinder"});
     public static final Block magicCasing = new Casing("magicCasing", new String[]{GoodGenerator.MOD_ID+":MagicCasing"});
     public static final Block essentiaCell = new Casing("essentiaCell", new String[]{GoodGenerator.MOD_ID+":essentiaCell/1",GoodGenerator.MOD_ID+":essentiaCell/2",GoodGenerator.MOD_ID+":essentiaCell/3"});
+    public static final Block essentiaHatch = new TEBlock("essentiaHatch", new String[]{GoodGenerator.MOD_ID+":essentiaHatch"}, 1);
 
     public static final Block[] essentiaCells = new Block[]{essentiaCell};
 
@@ -70,6 +68,7 @@ public class Loaders {
         GameRegistry.registerBlock(FRF_Coil_3, MyItemBlocks.class, "FRF_Coil_3");
         GameRegistry.registerBlock(rawCylinder, MyItemBlocks.class, "rawCylinder");
         GameRegistry.registerBlock(titaniumPlatedCylinder, MyItemBlocks.class, "titaniumPlatedCylinder");
+        GameRegistry.registerBlock(essentiaHatch, MyItemBlocks.class, "essentiaHatch");
         GameRegistry.registerItem(radiationProtectionPlate, "radiationProtectionPlate", GoodGenerator.MOD_ID);
         GameRegistry.registerItem(wrappedUraniumIngot, "wrappedUraniumIngot", GoodGenerator.MOD_ID);
         GameRegistry.registerItem(highDensityUraniumNugget, "highDensityUraniumNugget", GoodGenerator.MOD_ID);
@@ -85,6 +84,7 @@ public class Loaders {
         GameRegistry.registerItem(aluminumNitride, "aluminumNitride", GoodGenerator.MOD_ID);
         GameRegistry.registerItem(specialCeramics, "specialCeramics", GoodGenerator.MOD_ID);
         GameRegistry.registerItem(specialCeramicsPlate, "specialCeramicsPlate", GoodGenerator.MOD_ID);
+        GameRegistry.registerTileEntity(EssentiaHatch.class, "EssentiaHatch");
         Loaders.MAR = new MultiNqGenerator(12732, "NaG", "Large Naquadah Reactor").getStackForm(1L);
         Loaders.FRF = new FuelRefineFactory(16999, "FRF", "Naquadah Fuel Refinery").getStackForm(1L);
         Loaders.UCFE = new UniversalChemicalFuelEngine(IDOffset, "UniversalChemicalFuelEngine", "Universal Chemical Fuel Engine").getStackForm(1L);
diff --git a/src/main/resources/assets/goodgenerator/lang/en_US.lang b/src/main/resources/assets/goodgenerator/lang/en_US.lang
index 1c96653306..c82acfeb96 100644
--- a/src/main/resources/assets/goodgenerator/lang/en_US.lang
+++ b/src/main/resources/assets/goodgenerator/lang/en_US.lang
@@ -12,6 +12,7 @@ magicCasing.0.name=Magic Casing
 essentiaCell.0.name=Novice Essentia Diffusion Cell
 essentiaCell.1.name=Adept Essentia Diffusion Cell
 essentiaCell.2.name=Master Essentia Diffusion Cell
+essentiaHatch.0.name=Essentia Input Hatch
 
 item.radiationProtectionPlate.name=Radiation Proof Plate
 item.wrappedUraniumIngot.name=Wrapped Uranium Ingot
diff --git a/src/main/resources/assets/goodgenerator/textures/blocks/essentiaHatch.png b/src/main/resources/assets/goodgenerator/textures/blocks/essentiaHatch.png
new file mode 100644
index 0000000000..9c4bc26458
--- /dev/null
+++ b/src/main/resources/assets/goodgenerator/textures/blocks/essentiaHatch.png