rename package

11 files changed, 3061 insertions, 0 deletions

diff --git a/src/main/java/goodgenerator/blocks/tileEntity/EssentiaHatch.java b/src/main/java/goodgenerator/blocks/tileEntity/EssentiaHatch.java
new file mode 100644
index 0000000000..c8a4b1c713
--- /dev/null
+++ b/src/main/java/goodgenerator/blocks/tileEntity/EssentiaHatch.java
@@ -0,0 +1,225 @@
+package goodgenerator.blocks.tileEntity;
+
+import goodgenerator.crossmod.thaumcraft.LargeEssentiaEnergyData;
+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 {
+
+    private Aspect mLocked;
+    private AspectList current = new AspectList();
+    public int mState = 0;
+
+    public void setLockedAspect(Aspect aAspect) {
+        this.mLocked = aAspect;
+    }
+
+    @Override
+    public void readFromNBT(NBTTagCompound tagCompound) {
+        super.readFromNBT(tagCompound);
+
+        this.mLocked = Aspect.getAspect(tagCompound.getString("mLocked"));
+        this.mState = tagCompound.getInteger("mState");
+        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.setString("mLocked", this.mLocked == null ? "" : this.mLocked.getTag());
+        tagCompound.setInteger("mState", mState);
+        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() {
+        if (getEssentiaAmount(null) > 1000)
+            return;
+        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].getOpposite()) != null) && (pipe.getSuctionAmount(ForgeDirection.VALID_DIRECTIONS[i]) < getSuctionAmount(ForgeDirection.VALID_DIRECTIONS[i]))) {
+                    Aspect readyInput = pipe.getEssentiaType(ForgeDirection.VALID_DIRECTIONS[i].getOpposite());
+                    int type = LargeEssentiaEnergyData.getAspectTypeIndex(readyInput);
+                    if (type != -1 && (mState & (1 << type)) == 0) continue;
+                    if (readyInput.equals(mLocked)) {
+                        addToContainer(mLocked, pipe.takeEssentia(mLocked, 1, ForgeDirection.VALID_DIRECTIONS[i]));
+                    }
+                    if (mLocked == null)
+                        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 mLocked == null || mLocked.equals(aspect);
+    }
+
+    @Override
+    public int addToContainer(Aspect aspect, int i) {
+        current.add(aspect, i);
+        this.markDirty();
+        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 this.mLocked;
+    }
+
+    @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/tileEntity/FuelRefineFactory.java b/src/main/java/goodgenerator/blocks/tileEntity/FuelRefineFactory.java
new file mode 100644
index 0000000000..e68c92f8e8
--- /dev/null
+++ b/src/main/java/goodgenerator/blocks/tileEntity/FuelRefineFactory.java
@@ -0,0 +1,368 @@
+package goodgenerator.blocks.tileEntity;
+
+import goodgenerator.loader.Loaders;
+import goodgenerator.util.DescTextLocalization;
+import goodgenerator.util.MyRecipeAdder;
+import com.github.bartimaeusnek.crossmod.tectech.TecTechEnabledMulti;
+import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_EnergyMulti;
+import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_EnergyTunnel;
+import com.github.technus.tectech.thing.metaTileEntity.multi.base.GT_MetaTileEntity_MultiblockBase_EM;
+import com.gtnewhorizon.structurelib.StructureLibAPI;
+import com.gtnewhorizon.structurelib.alignment.constructable.IConstructable;
+import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
+import com.gtnewhorizon.structurelib.structure.IStructureElement;
+import com.gtnewhorizon.structurelib.structure.StructureDefinition;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+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_Multiblock_Tooltip_Builder;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GT_Utility;
+import net.minecraft.block.Block;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.StatCollector;
+import net.minecraft.world.World;
+import net.minecraftforge.fluids.FluidStack;
+import org.lwjgl.input.Keyboard;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static goodgenerator.util.DescTextLocalization.BLUE_PRINT_INFO;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.*;
+import static gregtech.api.util.GT_StructureUtility.*;
+import static gregtech.api.enums.GT_Values.V;
+
+public class FuelRefineFactory extends GT_MetaTileEntity_MultiblockBase_EM implements TecTechEnabledMulti, IConstructable {
+
+    private IStructureDefinition<FuelRefineFactory> multiDefinition = null;
+    private int Tier = -1;
+    private int[] cnt = new int[]{0,0,0};
+    private static final Block[] coils = new Block[]{Loaders.FRF_Coil_1,Loaders.FRF_Coil_2,Loaders.FRF_Coil_3};
+
+    public FuelRefineFactory(String name){super(name);}
+
+    public FuelRefineFactory(int id, String name, String nameRegional){
+        super(id,name,nameRegional);
+    }
+
+    @Override
+    public List<GT_MetaTileEntity_Hatch_Energy> getVanillaEnergyHatches() {
+        return this.mEnergyHatches;
+    }
+
+    @Override
+    public List<GT_MetaTileEntity_Hatch_EnergyTunnel> getTecTechEnergyTunnels() {
+        return new ArrayList<>();
+    }
+
+    @Override
+    public List<GT_MetaTileEntity_Hatch_EnergyMulti> getTecTechEnergyMultis() {
+        return new ArrayList<>();
+    }
+
+    @Override
+    public void construct(ItemStack itemStack, boolean hintsOnly) {
+        structureBuild_EM(mName, 7, 12, 1, hintsOnly, itemStack);
+    }
+
+    @Override
+    public IStructureDefinition<FuelRefineFactory> getStructure_EM() {
+        if(multiDefinition == null) {
+            multiDefinition = StructureDefinition
+                    .<FuelRefineFactory>builder()
+                    .addShape(mName,
+                            transpose(new String[][]{
+                                    {"               ","      CCC      ","               "},
+                                    {"      XGX      ","    CCFFFCC    ","      XGX      "},
+                                    {"    CC   CC    ","   CFFCCCFFC   ","    CC   CC    "},
+                                    {"   C       C   ","  CFCC   CCFC  ","   C       C   "},
+                                    {"  C         C  "," CFC       CFC ","  C         C  "},
+                                    {"  C         C  "," CFC       CFC ","  C         C  "},
+                                    {" X           X ","CFC         CFC"," X           X "},
+                                    {" G           G ","CFC         CFC"," G           G "},
+                                    {" X           X ","CFC         CFC"," X           X "},
+                                    {"  C         C  "," CFC       CFC ","  C         C  "},
+                                    {"  C         C  "," CFC       CFC ","  C         C  "},
+                                    {"   C       C   ","  CFCC   CCFC  ","   C       C   "},
+                                    {"    CC   CC    ","   CFFC~CFFC   ","    CC   CC    "},
+                                    {"      XGX      ","    CCFFFCC    ","      XGX      "},
+                                    {"               ","      CCC      ","               "}
+                            })
+                    ).addElement(
+                        'X',
+                            ofChain(
+                                    ofHatchAdder(
+                                            FuelRefineFactory::addToFRFList,179,
+                                            Loaders.FRF_Casings,0
+                                    ),
+                                    ofBlock(
+                                            Loaders.FRF_Casings,0
+                                    )
+                            )
+                    ).addElement(
+                            'C',
+                            ofBlock(
+                                    Loaders.FRF_Casings,0
+                            )
+                    ).addElement(
+                            'G',
+                            ofBlock(
+                                    Loaders.fieldRestrictingGlass,0
+                            )
+                    ).addElement(
+                            'F',
+                            ofChain(
+                                    onElementPass(
+                                            x -> ++x.cnt[0],
+                                            ofFieldCoil(0)
+                                    ),
+                                    onElementPass(
+                                            x -> ++x.cnt[1],
+                                            ofFieldCoil(1)
+                                    ),
+                                    onElementPass(
+                                            x -> ++x.cnt[2],
+                                            ofFieldCoil(2)
+                                    )
+                            )
+                    )
+                    .build();
+        }
+        return multiDefinition;
+    }
+
+    public static <T> IStructureElement<T> ofFieldCoil(int aIndex) {
+        return new IStructureElement<T>() {
+            @Override
+            public boolean check(T t, World world, int x, int y, int z) {
+                Block block = world.getBlock(x, y, z);
+                return block.equals(coils[aIndex]);
+            }
+
+            @Override
+            public boolean spawnHint(T t, World world, int x, int y, int z, ItemStack trigger) {
+                StructureLibAPI.hintParticle(world, x, y, z, coils[getIndex(trigger)], 0);
+                return true;
+            }
+
+            private int getIndex(ItemStack trigger) {
+                int s = trigger.stackSize;
+                if (s > 3 || s <= 0) s = 3;
+                return s - 1;
+            }
+
+            @Override
+            public boolean placeBlock(T t, World world, int x, int y, int z, ItemStack trigger) {
+                return world.setBlock(x, y, z, coils[getIndex(trigger)], 0, 3);
+            }
+        };
+    }
+
+    @Override
+    public String[] getDescription(){
+        final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder();
+        tt.addMachineType("Naquadah Fuel Refinery")
+                .addInfo("Controller block for the Naquadah Fuel Refinery")
+                .addInfo("But at what cost?")
+                .addInfo("Produce the endgame naquadah fuel.")
+                .addInfo("Need field restriction coil to control the fatal radiation.")
+                .addInfo("Use higher tier coil to unlock more fuel and reduce the process time.")
+                .addInfo("The structure is too complex!")
+                .addInfo(BLUE_PRINT_INFO)
+                .addSeparator()
+                .beginStructureBlock(3, 15, 15, false)
+                .addInputHatch("The casings adjoin the field restriction glass.")
+                .addInputBus("The casings adjoin the field restriction glass.")
+                .addOutputHatch("The casings adjoin the field restriction glass.")
+                .addEnergyHatch("The casings adjoin the field restriction glass.")
+                .toolTipFinisher("Good Generator");
+        if (!Keyboard.isKeyDown(Keyboard.KEY_LSHIFT)) {
+            return tt.getInformation();
+        } else {
+            return tt.getStructureInformation();
+        }
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT){
+        this.Tier = aNBT.getInteger("mTier");
+        super.loadNBTData(aNBT);
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT){
+        aNBT.setInteger("mTier", this.Tier);
+        super.saveNBTData(aNBT);
+    }
+
+    @Override
+    public String[] getStructureDescription(ItemStack itemStack){
+        return DescTextLocalization.addText("FuelRefineFactory.hint", 8);
+    }
+
+    @Override
+    public boolean checkMachine_EM(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
+        cnt[0] = 0;cnt[1] = 0;cnt[2] = 0;
+        mWrench = true;
+        mScrewdriver = true;
+        mSoftHammer = true;
+        mHardHammer = true;
+        mSolderingTool = true;
+        mCrowbar = true;
+        return structureCheck_EM(mName, 7,12,1) && getTier() != -1;
+    }
+
+    public int getTier(){
+        for (int i = 0; i < 3; i ++) {
+            if (cnt[i] == 32) {
+                Tier = i + 1;
+                return i;
+            }
+        }
+        Tier = -1;
+        return -1;
+    }
+
+    @Override
+    public boolean checkRecipe_EM(ItemStack aStack){
+
+        mWrench = true;
+        mScrewdriver = true;
+        mSoftHammer = true;
+        mHardHammer = true;
+        mSolderingTool = true;
+        mCrowbar = true;
+
+        ArrayList<FluidStack> tFluids = getStoredFluids();
+        ArrayList<ItemStack> tItems = getStoredInputs();
+        MyRecipeAdder.NaqFuelRefineMapper tRecipes = MyRecipeAdder.instance.FRF;
+
+        for (int i = 0; i < tFluids.size() - 1; i++) {
+            for (int j = i + 1; j < tFluids.size(); j++) {
+                if (GT_Utility.areFluidsEqual(tFluids.get(i), tFluids.get(j))) {
+                    if ((tFluids.get(i)).amount >= (tFluids.get(j)).amount) {
+                        tFluids.remove(j--);
+                    } else {
+                        tFluids.remove(i--);
+                        break;
+                    }
+                }
+            }
+        }
+
+        for (int i = 0; i < tItems.size() - 1; i++) {
+            for (int j = i + 1; j < tItems.size(); j++) {
+                if (GT_Utility.areStacksEqual(tItems.get(i), tItems.get(j))) {
+                    if ((tItems.get(i)).stackSize >= (tItems.get(j)).stackSize) {
+                        tItems.remove(j--);
+                    } else {
+                        tItems.remove(i--);
+                        break;
+                    }
+                }
+            }
+        }
+
+        FluidStack[] inFluids = tFluids.toArray(new FluidStack[0]);
+        ItemStack[] inItems = tItems.toArray(new ItemStack[0]);
+        this.mEfficiency = 10000;
+
+        long tPower = getMaxInputEnergy_EM();
+        byte tTier = (byte) Math.max(1, GT_Utility.getTier(tPower));
+        GT_Recipe recipe = tRecipes.findRecipe(this.getBaseMetaTileEntity(), false, V[tTier], inFluids, inItems);
+        if (recipe != null) {
+            if (recipe.mSpecialValue > Tier) return false;
+            if (recipe.isRecipeInputEqual(true, inFluids, inItems)){
+                mEUt = recipe.mEUt * (1 << (Tier - recipe.mSpecialValue));
+                mEUt = -Math.abs(mEUt);
+                mMaxProgresstime = recipe.mDuration / (1 << (Tier - recipe.mSpecialValue));
+                this.mOutputFluids = recipe.mFluidOutputs;
+                this.updateSlots();
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public final boolean addToFRFList(IGregTechTileEntity aTileEntity, int aBaseCasingIndex){
+        if (aTileEntity == null) {
+            return false;
+        } else {
+            IMetaTileEntity aMetaTileEntity = aTileEntity.getMetaTileEntity();
+            if (aMetaTileEntity == null) {
+                return false;
+            } else {
+                if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch) {
+                    ((GT_MetaTileEntity_Hatch)aMetaTileEntity).updateTexture(aBaseCasingIndex);
+                }
+                if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Input) {
+                    return this.mInputHatches.add((GT_MetaTileEntity_Hatch_Input)aMetaTileEntity);
+                } else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Output) {
+                    return this.mOutputHatches.add((GT_MetaTileEntity_Hatch_Output)aMetaTileEntity);
+                } else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_InputBus) {
+                    return this.mInputBusses.add((GT_MetaTileEntity_Hatch_InputBus)aMetaTileEntity);
+                } else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Energy) {
+                    return this.mEnergyHatches.add((GT_MetaTileEntity_Hatch_Energy)aMetaTileEntity);
+                } else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_EnergyMulti) {
+                    return this.eEnergyMulti.add((GT_MetaTileEntity_Hatch_EnergyMulti)aMetaTileEntity);
+                } else {
+                    return false;
+                }
+            }
+        }
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new FuelRefineFactory(this.mName);
+    }
+
+    @Override
+    public int getMaxEfficiency(ItemStack aStack) {
+        return 10000;
+    }
+
+    @Override
+    public int getPollutionPerTick(ItemStack aStack) {
+        return 0;
+    }
+
+    @Override
+    public int getDamageToComponent(ItemStack aStack) {
+        return 0;
+    }
+
+    @Override
+    public boolean explodesOnComponentBreak(ItemStack aStack) {
+        return true;
+    }
+
+    @Override
+    public boolean isCorrectMachinePart(ItemStack aStack) {
+        return true;
+    }
+
+    @Override
+    public String[] getInfoData() {
+        String[] infoData = new String[super.getInfoData().length + 1];
+        System.arraycopy(super.getInfoData(),0,infoData,0, super.getInfoData().length);
+        infoData[super.getInfoData().length] = StatCollector.translateToLocal("scanner.info.FRF") + " " + this.Tier;
+        return infoData;
+    }
+
+    @Override
+    @SuppressWarnings("ALL")
+    public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) {
+        if(aSide == aFacing){
+            if(aActive) return new ITexture[]{Textures.BlockIcons.getCasingTextureForId(179), new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_ASSEMBLY_LINE_ACTIVE), TextureFactory.builder().addIcon(Textures.BlockIcons.OVERLAY_FRONT_ASSEMBLY_LINE_ACTIVE_GLOW).glow().build()};
+            return new ITexture[]{Textures.BlockIcons.getCasingTextureForId(179), new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_ASSEMBLY_LINE), TextureFactory.builder().addIcon(Textures.BlockIcons.OVERLAY_FRONT_ASSEMBLY_LINE_GLOW).glow().build()};
+        }
+        return new ITexture[]{Textures.BlockIcons.getCasingTextureForId(179)};
+    }
+}
diff --git a/src/main/java/goodgenerator/blocks/tileEntity/GTMetaTileEntity/NeutronAccelerator.java b/src/main/java/goodgenerator/blocks/tileEntity/GTMetaTileEntity/NeutronAccelerator.java
new file mode 100644
index 0000000000..1ee64e26c4
--- /dev/null
+++ b/src/main/java/goodgenerator/blocks/tileEntity/GTMetaTileEntity/NeutronAccelerator.java
@@ -0,0 +1,66 @@
+package goodgenerator.blocks.tileEntity.GTMetaTileEntity;
+
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Energy;
+import net.minecraft.nbt.NBTTagCompound;
+
+import static gregtech.api.enums.GT_Values.V;
+
+public class NeutronAccelerator extends GT_MetaTileEntity_Hatch_Energy {
+
+    public boolean isRunning;
+
+    public NeutronAccelerator(int aID, String aName, String aNameRegional, int aTier) {
+        super(aID, aName, aNameRegional, aTier);
+    }
+
+    public NeutronAccelerator(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, aDescription, aTextures);
+    }
+
+    public int getMaxEUConsume() {
+        return (int)(V[mTier] * 8 / 10);
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        super.loadNBTData(aNBT);
+        this.isRunning = aNBT.getBoolean("isRunning");
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        super.saveNBTData(aNBT);
+        aNBT.setBoolean("isRunning", this.isRunning);
+    }
+
+    @Override
+    public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new NeutronAccelerator(mName, mTier, this.getDescription(), mTextures);
+    }
+
+    @Override
+    public String[] getDescription() {
+        return new String[]{
+                "Input EU to Accelerate the Neutron!",
+                "Max EU input: " + this.maxEUInput(),
+                "Max EU consumption: " + this.getMaxEUConsume(),
+                "Every EU can be transformed into 10~20 eV Neutron Kinetic Energy."
+        };
+    }
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        if (this.getBaseMetaTileEntity().isServerSide()) {
+            if (aBaseMetaTileEntity.getStoredEU() >= getMaxEUConsume() && aBaseMetaTileEntity.isAllowedToWork()) {
+                setEUVar(aBaseMetaTileEntity.getStoredEU() - getMaxEUConsume());
+                isRunning = true;
+            } else {
+                isRunning = false;
+            }
+        }
+        super.onPostTick(aBaseMetaTileEntity, aTick);
+    }
+}
diff --git a/src/main/java/goodgenerator/blocks/tileEntity/GTMetaTileEntity/NeutronSensor.java b/src/main/java/goodgenerator/blocks/tileEntity/GTMetaTileEntity/NeutronSensor.java
new file mode 100644
index 0000000000..d69f0b75f8
--- /dev/null
+++ b/src/main/java/goodgenerator/blocks/tileEntity/GTMetaTileEntity/NeutronSensor.java
@@ -0,0 +1,168 @@
+package goodgenerator.blocks.tileEntity.GTMetaTileEntity;
+
+import goodgenerator.client.GUI.NeutronSensorGUIClient;
+import goodgenerator.common.container.NeutronSensorGUIContainer;
+import goodgenerator.main.GoodGenerator;
+import goodgenerator.network.MessageOpenNeutronSensorGUI;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.IIconContainer;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch;
+import gregtech.api.render.TextureFactory;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+
+public class NeutronSensor extends GT_MetaTileEntity_Hatch {
+
+    private static final IIconContainer textureFont = new Textures.BlockIcons.CustomIcon("icons/NeutronSensorFont");
+    private static final IIconContainer textureFont_Glow = new Textures.BlockIcons.CustomIcon("icons/NeutronSensorFont_GLOW");
+
+    protected String texts = "";
+    boolean isOn = false;
+
+    public NeutronSensor(int aID, String aName, String aNameRegional, int aTier) {
+        super(aID, aName, aNameRegional, aTier, 0, "Detect Neutron Kinetic Energy.");
+    }
+
+    public NeutronSensor(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, 0, aDescription, aTextures);
+    }
+
+    @Override
+    public String[] getDescription() {
+        return new String[]{
+                "Can be installed in Neutron Activator.",
+                "Output Redstone Signal according to the Neutron Kinetic Energy.",
+                "Right click to open the GUI and setting."
+        };
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        texts = aNBT.getString("mBoxContext");
+        super.loadNBTData(aNBT);
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        aNBT.setString("mBoxContext", texts);
+        super.saveNBTData(aNBT);
+    }
+
+    @Override
+    public void initDefaultModes(NBTTagCompound aNBT) {
+        getBaseMetaTileEntity().setActive(true);
+    }
+
+    @Override
+    public boolean isValidSlot(int aIndex) {
+        return false;
+    }
+
+    @Override
+    public boolean isSimpleMachine() {
+        return true;
+    }
+
+    @Override
+    public boolean isFacingValid(byte aFacing) {
+        return true;
+    }
+
+    @Override
+    public boolean isAccessAllowed(EntityPlayer aPlayer) {
+        return true;
+    }
+
+    @Override
+    public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+        return new NeutronSensorGUIClient(aPlayerInventory, aBaseMetaTileEntity, GoodGenerator.MOD_ID + ":textures/gui/NeutronSensorGUI.png", this.texts);
+    }
+
+    @Override
+    public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+        return new NeutronSensorGUIContainer(aPlayerInventory, aBaseMetaTileEntity);
+    }
+
+    @Override
+    public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer, byte aSide, float aX, float aY, float aZ) {
+        if (aBaseMetaTileEntity.isClientSide()) return true;
+        if (aSide == aBaseMetaTileEntity.getFrontFacing() && aPlayer instanceof EntityPlayerMP) {
+            GoodGenerator.CHANNEL.sendTo(new MessageOpenNeutronSensorGUI(aBaseMetaTileEntity, texts), (EntityPlayerMP) aPlayer);
+            return true;
+        }
+        return false;
+    }
+
+    public void setText(String text) {
+        texts = text == null ? "" : text;
+    }
+
+    public String getText() {
+        return texts == null ? "" : texts;
+    }
+
+    public void outputRedstoneSignal(){
+        isOn = true;
+    }
+
+    public void stopOutputRedstoneSignal(){
+        isOn = false;
+    }
+
+    @Override
+    public ITexture[] getTexturesActive(ITexture aBaseTexture) {
+        return new ITexture[] {
+                aBaseTexture,
+                TextureFactory.of(textureFont),
+                TextureFactory.builder().addIcon(textureFont_Glow).glow().build()
+        };
+    }
+
+    @Override
+    public ITexture[] getTexturesInactive(ITexture aBaseTexture) {
+        return new ITexture[] {
+                aBaseTexture,
+                TextureFactory.of(textureFont)
+        };
+    }
+
+    @Override
+    public boolean allowGeneralRedstoneOutput(){
+        return true;
+    }
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        if (isOn) {
+            for (byte i = 0; i < 6; i ++)
+                aBaseMetaTileEntity.setInternalOutputRedstoneSignal(i, (byte) 15);
+        }
+        else {
+            for (byte i = 0; i < 6; i ++)
+                aBaseMetaTileEntity.setInternalOutputRedstoneSignal(i, (byte) 0);
+        }
+        super.onPostTick(aBaseMetaTileEntity, aTick);
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new NeutronSensor(mName, mTier, mDescriptionArray, mTextures);
+    }
+
+    @Override
+    public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int