add Neutron Activator related blocks

12 files changed, 668 insertions, 13 deletions

diff --git a/src/main/java/GoodGenerator/Blocks/TEs/FuelRefineFactory.java b/src/main/java/GoodGenerator/Blocks/TEs/FuelRefineFactory.java
index 856828d2d7..b046866409 100644
--- a/src/main/java/GoodGenerator/Blocks/TEs/FuelRefineFactory.java
+++ b/src/main/java/GoodGenerator/Blocks/TEs/FuelRefineFactory.java
@@ -190,14 +190,14 @@ public class FuelRefineFactory extends GT_MetaTileEntity_MultiblockBase_EM imple
 
     @Override
     public void loadNBTData(NBTTagCompound aNBT){
-        super.loadNBTData(aNBT);
         this.Tier = aNBT.getInteger("mTier");
+        super.loadNBTData(aNBT);
     }
 
     @Override
     public void saveNBTData(NBTTagCompound aNBT){
-        super.saveNBTData(aNBT);
         aNBT.setInteger("mTier", this.Tier);
+        super.saveNBTData(aNBT);
     }
 
     @Override
diff --git a/src/main/java/GoodGenerator/Blocks/TEs/MetaTE/NeutronAccelerator.java b/src/main/java/GoodGenerator/Blocks/TEs/MetaTE/NeutronAccelerator.java
new file mode 100644
index 0000000000..b6f087eba7
--- /dev/null
+++ b/src/main/java/GoodGenerator/Blocks/TEs/MetaTE/NeutronAccelerator.java
@@ -0,0 +1,66 @@
+package GoodGenerator.Blocks.TEs.MetaTE;
+
+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] * 10 / 8);
+    }
+
+    @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 0.1~0.2 KeV Neutron Kinetic Energy."
+        };
+    }
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        if (this.getBaseMetaTileEntity().isServerSide()) {
+            if (aBaseMetaTileEntity.getStoredEU() >= getMaxEUConsume()) {
+                setEUVar(aBaseMetaTileEntity.getStoredEU() - getMaxEUConsume());
+                isRunning = true;
+            } else {
+                isRunning = false;
+            }
+        }
+        super.onPostTick(aBaseMetaTileEntity, aTick);
+    }
+}
diff --git a/src/main/java/GoodGenerator/Blocks/TEs/MetaTE/NeutronSensor.java b/src/main/java/GoodGenerator/Blocks/TEs/MetaTE/NeutronSensor.java
new file mode 100644
index 0000000000..0c9071671e
--- /dev/null
+++ b/src/main/java/GoodGenerator/Blocks/TEs/MetaTE/NeutronSensor.java
@@ -0,0 +1,141 @@
+package GoodGenerator.Blocks.TEs.MetaTE;
+
+import GoodGenerator.Client.GUI.NeutronSensorGUIClient;
+import GoodGenerator.Common.Container.NeutronSensorGUIContainer;
+import GoodGenerator.Main.GoodGenerator;
+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 gregtech.api.util.GT_Log;
+import net.minecraft.entity.player.EntityPlayer;
+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 = "";
+
+    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");
+        GT_Log.out.print(texts + "\n");
+        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);
+        texts = aNBT.getString("mBoxContext");
+    }
+
+    @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) {
+        GT_Log.out.print(texts + "\n");
+        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()) aBaseMetaTileEntity.openGUI(aPlayer);
+        return true;
+    }
+
+    public void setText(String text) {
+        texts = text;
+    }
+
+    @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 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 aIndex, byte aSide, ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        super.onPostTick(aBaseMetaTileEntity, aTick);
+        //if (aTick % 100 == 0) GT_Log.out.print(texts + "\n");
+    }
+}
diff --git a/src/main/java/GoodGenerator/Blocks/TEs/MultiNqGenerator.java b/src/main/java/GoodGenerator/Blocks/TEs/MultiNqGenerator.java
index 769f4fefc6..4fc44e9469 100644
--- a/src/main/java/GoodGenerator/Blocks/TEs/MultiNqGenerator.java
+++ b/src/main/java/GoodGenerator/Blocks/TEs/MultiNqGenerator.java
@@ -135,9 +135,11 @@ public class MultiNqGenerator extends GT_MetaTileEntity_MultiblockBase_EM implem
         return multiDefinition;
     }
 
-    public MultiNqGenerator(String name){super(name);}
+    public MultiNqGenerator(String name) {
+        super(name);
+    }
 
-    public MultiNqGenerator(int id, String name, String nameRegional){
+    public MultiNqGenerator(int id, String name, String nameRegional) {
         super(id,name,nameRegional);
     }
 
@@ -148,7 +150,6 @@ public class MultiNqGenerator extends GT_MetaTileEntity_MultiblockBase_EM implem
 
     @Override
     public void loadNBTData(NBTTagCompound aNBT){
-        super.loadNBTData(aNBT);
         this.ticker = aNBT.getInteger("mTicker");
         this.fluidLocker = aNBT.getBoolean("mIsLocked");
         this.times = aNBT.getInteger("mTimes");
@@ -156,11 +157,11 @@ public class MultiNqGenerator extends GT_MetaTileEntity_MultiblockBase_EM implem
         if (FluidRegistry.getFluid(aNBT.getString("mLockedFluidName")) != null)
             this.lockedFluid = new FluidStack(FluidRegistry.getFluid(aNBT.getString("mLockedFluidName")), aNBT.getInteger("mLockedFluidAmount"));
         else this.lockedFluid = null;
+        super.loadNBTData(aNBT);
     }
 
     @Override
     public void saveNBTData(NBTTagCompound aNBT){
-        super.saveNBTData(aNBT);
         aNBT.setInteger("mTicker", this.ticker);
         aNBT.setBoolean("mIsLocked", this.fluidLocker);
         aNBT.setInteger("mTimes", this.times);
@@ -169,6 +170,7 @@ public class MultiNqGenerator extends GT_MetaTileEntity_MultiblockBase_EM implem
             aNBT.setString("mLockedFluidName", this.lockedFluid.getFluid().getName());
             aNBT.setInteger("mLockedFluidAmount", this.lockedFluid.amount);
         }
+        super.saveNBTData(aNBT);
     }
 
     @Override
diff --git a/src/main/java/GoodGenerator/Blocks/TEs/NeutronActivator.java b/src/main/java/GoodGenerator/Blocks/TEs/NeutronActivator.java
new file mode 100644
index 0000000000..2498f81d2a
--- /dev/null
+++ b/src/main/java/GoodGenerator/Blocks/TEs/NeutronActivator.java
@@ -0,0 +1,177 @@
+package GoodGenerator.Blocks.TEs;
+
+import GoodGenerator.Blocks.TEs.MetaTE.NeutronAccelerator;
+import GoodGenerator.Blocks.TEs.MetaTE.NeutronSensor;
+import com.github.technus.tectech.mechanics.structure.IStructureDefinition;
+import com.github.technus.tectech.mechanics.structure.StructureDefinition;
+import com.github.technus.tectech.thing.metaTileEntity.multi.base.GT_MetaTileEntity_MultiblockBase_EM;
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.Materials;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch;
+import ic2.core.Ic2Items;
+import net.minecraft.block.Block;
+import net.minecraft.item.ItemStack;
+
+import java.util.ArrayList;
+
+import static GoodGenerator.util.StructureHelper.addFrame;
+import static com.github.technus.tectech.mechanics.structure.StructureUtility.*;
+import static org.apache.commons.lang3.RandomUtils.nextInt;
+
+public class NeutronActivator extends GT_MetaTileEntity_MultiblockBase_EM {
+
+    protected IStructureDefinition<NeutronActivator> multiDefinition = null;
+    protected final ArrayList<NeutronAccelerator> mNeutronAccelerator = new ArrayList<>();
+    protected final ArrayList<NeutronSensor> mNeutronSensor = new ArrayList<>();
+    protected int casingAmount = 0;
+    protected int KeV;
+
+    public NeutronActivator(String name) {
+        super(name);
+    }
+
+    public NeutronActivator(int id, String name, String nameRegional) {
+        super(id,name,nameRegional);
+    }
+
+    @Override
+    public IStructureDefinition<NeutronActivator> getStructure_EM() {
+        if(multiDefinition == null) {
+            multiDefinition = StructureDefinition
+                    .<NeutronActivator>builder()
+                    .addShape(mName,
+                            transpose(new String[][]{
+                                    {"CCCCC","CDDDC","CDDDC","CDDDC","CCCCC"},
+                                    {"F   F"," GGG "," GPG "," GGG ","F   F"},
+                                    {"F   F"," GGG "," GPG "," GGG ","F   F"},
+                                    {"F   F"," GGG "," GPG "," GGG ","F   F"},
+                                    {"F   F"," GGG "," GPG "," GGG ","F   F"},
+                                    {"XX~XX","XDDDX","XDDDX","XDDDX","XXXXX"},
+                            })
+                    )
+                    .addElement(
+                            'C',
+                            ofChain(
+                                    ofHatchAdder(
+                                            NeutronActivator::addClassicInputToMachineList, 49,
+                                            1
+                                    ),
+                                    onElementPass(
+                                            x -> x.casingAmount ++,
+                                            ofBlock(
+                                                    GregTech_API.sBlockCasings4, 1
+                                            )
+                                    )
+                            )
+                    )
+                    .addElement(
+                            'D',
+                            ofBlock(
+                                    GregTech_API.sBlockCasings2, 6
+                            )
+                    )
+                    .addElement(
+                            'F',
+                            addFrame(
+                                    Materials.Steel
+                            )
+                    )
+                    .addElement(
+                            'G',
+                            ofBlock(
+                                    Block.getBlockFromItem(Ic2Items.reinforcedGlass.getItem()), 0
+                            )
+                    )
+                    .addElement(
+                            'P',
+                            ofBlock(
+                                    GregTech_API.sBlockCasings2, 13
+                            )
+                    )
+                    .addElement(
+                            'X',
+                            ofChain(
+                                    ofHatchAdder(
+                                            NeutronActivator::addClassicOutputToMachineList, 49,
+                                            2
+                                    ),
+                                    ofHatchAdder(
+                                            NeutronActivator::addMaintenanceToMachineList, 49,
+                                            2
+                                    ),
+                                    ofHatchAdder(
+                                            NeutronActivator::addAccelerator, 49,
+                                            2
+                                    ),
+                                    onElementPass(
+                                            x -> x.casingAmount ++,
+                                            ofBlock(
+                                                    GregTech_API.sBlockCasings4, 1
+                                            )
+                                    )
+                            )
+                    )
+                    .build();
+        }
+        return multiDefinition;
+    }
+
+    @Override
+    public boolean checkMachine_EM(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
+        this.casingAmount = 0;
+        this.mNeutronAccelerator.clear();
+        this.mNeutronSensor.clear();
+        return structureCheck_EM(mName, 2, 5, 0) && casingAmount >= 7;
+    }
+
+    public final boolean addAccelerator(IGregTechTileEntity aTileEntity, int aBaseCasingIndex) {
+        if (aTileEntity == null) {
+            return false;
+        } else {
+            IMetaTileEntity aMetaTileEntity = aTileEntity.getMetaTileEntity();
+            if (aMetaTileEntity instanceof NeutronAccelerator){
+                ((GT_MetaTileEntity_Hatch)aMetaTileEntity).updateTexture(aBaseCasingIndex);
+                return this.mNeutronAccelerator.add((NeutronAccelerator)aMetaTileEntity);
+            } else if (aMetaTileEntity instanceof NeutronSensor){
+                ((GT_MetaTileEntity_Hatch)aMetaTileEntity).updateTexture(aBaseCasingIndex);
+                return this.mNeutronSensor.add((NeutronSensor)aMetaTileEntity);
+            }
+        }
+        return false;
+    }
+
+    public int maxNeutronKineticEnergy() {
+        return 10000000;
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new NeutronActivator(this.mName);
+    }
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        super.onPostTick(aBaseMetaTileEntity, aTick);
+        boolean anyWorking = false;
+        if (this.getBaseMetaTileEntity().isServerSide()) {
+            for (NeutronAccelerator tHatch : mNeutronAccelerator) {
+                if (tHatch.isRunning) {
+                    anyWorking = true;
+                    this.KeV += nextInt(tHatch.getMaxEUConsume(), tHatch.getMaxEUConsume() * 2 + 1) / 10;
+                }
+            }
+            if (!anyWorking) {
+                if (this.KeV >= 80 && aTick % 20 == 0) {
+                    this.KeV -= 80;
+                }
+                else if (this.KeV > 0 && aTick % 20 == 0) {
+                    this.KeV = 0;
+                }
+            }
+            if (this.KeV < 0) this.KeV = 0;
+            if (this.KeV > maxNeutronKineticEnergy()) doExplosion(4 * 32);
+        }
+    }
+}
diff --git a/src/main/java/GoodGenerator/Client/GUI/NeutronSensorGUIClient.java b/src/main/java/GoodGenerator/Client/GUI/NeutronSensorGUIClient.java
new file mode 100644
index 0000000000..b80f1d7d90
--- /dev/null
+++ b/src/main/java/GoodGenerator/Client/GUI/NeutronSensorGUIClient.java
@@ -0,0 +1,111 @@
+package GoodGenerator.Client.GUI;
+
+import GoodGenerator.Blocks.TEs.MetaTE.NeutronSensor;
+import GoodGenerator.Main.GoodGenerator;
+import GoodGenerator.util.CharExchanger;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import gregtech.api.gui.GT_GUIContainerMetaTile_Machine;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch;
+import net.minecraft.client.gui.GuiTextField;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.StatCollector;
+
+@SideOnly(Side.CLIENT)
+public class NeutronSensorGUIClient extends GT_GUIContainerMetaTile_Machine {
+
+    protected final String mName;
+
+    private GuiTextField TextBox;
+    private String context;
+    private GT_MetaTileEntity_Hatch mTile;
+
+    public NeutronSensorGUIClient(InventoryPlayer aInventoryPlayer, IGregTechTileEntity aTileEntity, String aTexture, String text) {
+        super(aInventoryPlayer, aTileEntity, aTexture);
+        this.mName = "Neutron Sensor";
+        this.mTile = (GT_MetaTileEntity_Hatch) aTileEntity.getMetaTileEntity();
+        this.mContainer.detectAndSendChanges();
+        if (text == null) this.context = "";
+            else this.context = text;
+    }
+
+    public void initGui(){
+        super.initGui();
+        this.TextBox = new GuiTextField(this.fontRendererObj, 8, 48, 100, 18);
+        TextBox.setMaxStringLength(20);
+        TextBox.setText(context);
+        this.TextBox.setFocused(true);
+    }
+
+    protected void drawGuiContainerForegroundLayer(int par1, int par2) {
+        this.fontRendererObj.drawString(this.mName, 8, 4, 4210752);
+        this.fontRendererObj.drawString(StatCollector.translateToLocal("gui.NeutronSensor.0"), 8, 16, 0x000000);
+        this.fontRendererObj.drawString(StatCollector.translateToLocal("gui.NeutronSensor.1"), 8, 28, 0x000000);
+        this.TextBox.drawTextBox();
+        if (TextBox.getText() != null) {
+            if (isValidSuffix(TextBox.getText())) {
+                if (CharExchanger.isValidCompareExpress(rawProcessExp(TextBox.getText())))
+                    this.fontRendererObj.drawString(StatCollector.translateToLocal("gui.NeutronSensor.2"), 120, 53, 0x077d02);
+                else this.fontRendererObj.drawString(StatCollector.translateToLocal("gui.NeutronSensor.3"), 120, 53, 0xff0000);
+            }
+            else this.fontRendererObj.drawString(StatCollector.translateToLocal("gui.NeutronSensor.3"), 120, 53, 0xff0000);
+        }
+        this.mc.getTextureManager().bindTexture(new ResourceLocation(GoodGenerator.MOD_ID + ":textures/gui/NeutronSensorGUI.png"));
+    }
+
+    protected void drawGuiContainerBackgroundLayer(float par1, int par2, int par3) {
+        super.drawGuiContainerBackgroundLayer(par1, par2, par3);
+        int x = (this.width - this.xSize) / 2;
+        int y = (this.height - this.ySize) / 2;
+        this.drawTexturedModalRect(x, y, 0, 0, this.xSize, this.ySize);
+    }
+
+    protected void keyTyped(char par1, int par2) {
+        if (!this.TextBox.isFocused())
+            super.keyTyped(par1, par2);
+        if (par2 == 1) this.mc.thePlayer.closeScreen();
+        this.TextBox.textboxKeyTyped(par1, par2);
+    }
+
+    public void updateScreen() {
+        super.updateScreen();
+        this.TextBox.updateCursorCounter();
+    }
+
+    protected void mouseClicked(int x, int y, int btn) {
+        super.mouseClicked(x, y, btn);
+        this.TextBox.mouseClicked(x - this.getLeft(), y - this.getTop(), btn);
+    }
+
+    public void onGuiClosed() {
+        ((NeutronSensor) mTile).setText(context);
+        super.onGuiClosed();
+    }
+
+    protected String rawProcessExp(String exp) {
+        StringBuilder ret = new StringBuilder();
+        for (char c: exp.toCharArray()) {
+            if (exp.length() - ret.length() == 3) {
+                if (Character.isDigit(c)) ret.append(c);
+                break;
+            }
+            ret.append(c);
+        }
+        return ret.toString();
+    }
+
+    protected boolean isValidSuffix(String exp) {
+        int index;
+        index = exp.length() - 1;
+        if (index < 0) return false;
+        if (exp.charAt(index) != 'V' && exp.charAt(index) != 'v') return false;
+        index = exp.length() - 2;
+        if (index < 0) return false;
+        if (exp.charAt(index) != 'E' && exp.charAt(index) != 'e') return false;
+        index = exp.length() - 3;
+        if (index < 0) return false;
+        return exp.charAt(index) == 'M' || exp.charAt(index) == 'm' || exp.charAt(index) == 'K' || exp.charAt(index) == 'k' || Character.isDigit(exp.charAt(index));
+    }
+}
diff --git a/src/main/java/GoodGenerator/Common/Container/NeutronSensorGUIContainer.java b/src/main/java/GoodGenerator/Common/Container/NeutronSensorGUIContainer.java
new file mode 100644
index 0000000000..0c243b0a69
--- /dev/null
+++ b/src/main/java/GoodGenerator/Common/Container/NeutronSensorGUIContainer.java
@@ -0,0 +1,12 @@
+package GoodGenerator.Common.Container;
+
+import gregtech.api.gui.GT_ContainerMetaTile_Machine;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import net.minecraft.entity.player.InventoryPlayer;
+
+public class NeutronSensorGUIContainer extends GT_ContainerMetaTile_Machine {
+
+    public NeutronSensorGUIContainer(InventoryPlayer aInventoryPlayer, IGregTechTileEntity aTileEntity) {
+        super(aInventoryPlayer, aTileEntity);
+    }
+}
diff --git a/src/main/java/GoodGenerator/Items/MyMaterial.java b/src/main/java/GoodGenerator/Items/MyMaterial.java
index 47ed7df2b7..65913501ba 100644
--- a/src/main/java/GoodGenerator/Items/MyMaterial.java
+++ b/src/main/java/GoodGenerator/Items/MyMaterial.java
@@ -257,10 +257,10 @@ public class MyMaterial implements Runnable {
             new Pair<> (Fluorine,4)
     );
 
-    //Naquadria Catalyst
+    //Atomic Separation Catalyst
     public static final Werkstoff atomicSeparationCatalyst = new Werkstoff(
             new short[]{0xe8,0x5e,0x0c},
-            "Naquadria Catalyst",
+            "Atomic Separation Catalyst",
             "the melting core...",
             new Werkstoff.Stats().setMeltingPoint(5000).setBlastFurnace(true),
             Werkstoff.Types.COMPOUND,
@@ -338,7 +338,7 @@ public class MyMaterial implements Runnable {
 
     public static final Werkstoff ether = new Werkstoff(
             new short[]{0xeb,0xbc,0x2f},
-            "Diethyl Ether",
+            "Ether",
             subscriptNumbers("CH3CH2OCH2CH3"),
             new Werkstoff.Stats(),
             Werkstoff.Types.COMPOUND,
diff --git a/src/main/java/GoodGenerator/Loader/Loaders.java b/src/main/java/GoodGenerator/Loader/Loaders.java
index a69651c38b..88ea24b226 100644
--- a/src/main/java/GoodGenerator/Loader/Loaders.java
+++ b/src/main/java/GoodGenerator/Loader/Loaders.java
@@ -4,11 +4,14 @@ import GoodGenerator.Blocks.RegularBlock.Casing;
 import GoodGenerator.Blocks.RegularBlock.Frame;
 import GoodGenerator.Blocks.RegularBlock.TEBlock;
 import GoodGenerator.Blocks.TEs.*;
+import GoodGenerator.Blocks.TEs.MetaTE.NeutronAccelerator;
+import GoodGenerator.Blocks.TEs.MetaTE.NeutronSensor;
 import GoodGenerator.Items.MyItemBlocks;
 import GoodGenerator.Items.MyItems;
 import GoodGenerator.Main.GoodGenerator;
 import cpw.mods.fml.common.Loader;
 import cpw.mods.fml.common.registry.GameRegistry;
+import gregtech.api.enums.GT_Values;
 import gregtech.api.enums.Textures;
 import gregtech.api.interfaces.ITexture;
 import gregtech.api.render.TextureFactory;
@@ -57,6 +60,9 @@ public class Loaders {
     public static ItemStack FRF;
     public static ItemStack UCFE;
     public static ItemStack LEG;
+    public static ItemStack NS;
+
+    public static ItemStack[] NeutronAccelerators = new ItemStack[9];
 
     public static void Register(){
         GameRegistry.registerBlock(MAR_Casing, MyItemBlocks.class, "MAR_Casing");
@@ -93,6 +99,10 @@ public class Loaders {
             GameRegistry.registerTileEntity(EssentiaHatch.class, "EssentiaHatch");
             Loaders.LEG = new LargeEssentiaGenerator(IDOffset + 1, "LargeEssentiaGenerator", "Large Essentia Generator").getStackForm(1L);
         }
+        for (int i = 0; i < 9; i ++) {
+            Loaders.NeutronAccelerators[i] = new NeutronAccelerator(IDOffset + 2 + i, "Neutron Accelerator " + GT_Values.VN[i], "Neutron Accelerator " + GT_Values.VN[i], i).getStackForm(1L);
+        }
+       Loaders.NS = new NeutronSensor(IDOffset + 11, "Neutron Sensor", "Neutron Sensor", 5).getStackForm(1L);
     }
 
     public static void addOreDic(){
diff --git a/src/main/java/GoodGenerator/Loader/RecipeLoader.java b/src/main/java/GoodGenerator/Loader/RecipeLoader.java
index c68624d244..94f52b8ec5 100644
--- a/src/main/java/GoodGenerator/Loader/RecipeLoader.java
+++ b/src/main/java/GoodGenerator/Loader/RecipeLoader.java
@@ -1088,7 +1088,7 @@ public class RecipeLoader {
                 FluidRegistry.getFluidStack("refinedglue",1000),
                 null,
                 new ItemStack(Loaders.specialCeramics,9),
-                1000,
+                100,
                 1980
         );
 
@@ -1100,7 +1100,7 @@ public class RecipeLoader {
                 FluidRegistry.getFluidStack("refinedglue",1000),
                 null,
                 new ItemStack(Loaders.specialCeramics,9),
-                1000,
+                100,
                 1980
         );
 
diff --git a/src/main/java/GoodGenerator/util/CharExchanger.java b/src/main/java/GoodGenerator/util/CharExchanger.java
index afd5a49999..e2b95c040b 100644
--- a/src/main/java/GoodGenerator/util/CharExchanger.java
+++ b/src/main/java/GoodGenerator/util/CharExchanger.java
@@ -1,8 +1,83 @@
 package GoodGenerator.util;
 
 public class CharExchanger {
+
     public static char shifter(int unicode){
-        char c = (char)unicode;
-        return c;
+        return (char)unicode;
+    }
+
+    public static boolean isValidCompareExpressChar(char c) {
+        return Character.isDigit(c) || c == '<' || c == '>' || c == '=' || c == '!';
+    }
+
+    public static boolean isValidCompareExpress(String exp) {
+        if (exp.length() < 2) return false;
+        for (char c: exp.toCharArray())
+            if (!isValidCompareExpressChar(c)) return false;
+        char c1 = exp.charAt(0), c2 = exp.charAt(1);
+        String subExp = "" + c1;
+        if (!Character.isDigit(c2)) subExp = subExp + c2;
+        switch (subExp) {
+            case ">":
+            case "<":
+            case ">=":
+            case "<=":
+            case "==":
+            case "!=":
+                break;
+            default: return false;
+        }
+        if (exp.length() == subExp.length()) return false;
+        for (int i = subExp.length(); i < exp.length(); i ++) {
+            if (!Character.isDigit(exp.charAt(i))) return false;
+        }
+        return true;
+    }
+
+    /**
+     *  ">" : 1 <BR>
+     *  "<" : 2 <BR>
+     *  "==" : 13 <BR>
+     *  "!=" : 14 <BR>
+     *  ">=" : 11 <BR>
+     *  "<=" : 12 <BR>
+     *  INVALID : -1
+     */
+    public static int getOperator(String exp){
+        char c1, c2;
+        int ret;
+        if (exp.length() < 1) return -1;
+        c1 = exp.charAt(0);
+        switch (c1) {
+            case '>': ret = 1;break;
+            case '<': ret = 2;break;
+            case '=': ret = 3;break;
+            case '!': ret = 4;break;
+            default: return -1;
+        }
+        if (exp.length() > 1) c2 = exp.charAt(1);
+        else return ret;
+        if (c2 == '=') {
+            ret += 10;
+        }
+        return ret;
+    }
+
+    public static boolean compareExpression(String exp, int num) {
+        int op = getOperator(exp);
+        String NumExp = exp;
+        String[] opChar = new String[]{">", "<", "<=", ">=", "==", "!="};
+        if (op == -1) throw new IllegalArgumentException();
+        for (String re: opChar) NumExp = NumExp.replace(re, "");
+        int num2 = Integer.getInteger(NumExp);
+        switch (op) {
+            case 1: return num > num2;
+            case 2: return num < num2;
+            case 13: return num == num2;
+            case 14: return num != num2;
+            case 11: return num >= num2;
+            case 12: return num <= num2;
+            default: return false;
+        }
     }
 }
diff --git a/src/main/java/GoodGenerator/util/StructureHelper.java b/src/main/java/GoodGenerator/util/StructureHelper.java
new file mode 100644
index 0000000000..2c5feadab8
--- /dev/null
+++ b/src/main/java/GoodGenerator/util/StructureHelper.java
@@ -0,0 +1,61 @@
+package GoodGenerator.util;
+
+import com.github.technus.tectech.TecTech;
+import com.github.technus.tectech.mechanics.structure.IStructureElement;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.metatileentity.BaseMetaPipeEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaPipeEntity_Frame;
+import gregtech.api.util.GT_OreDictUnificator;
+import net.minecraft.init.Items;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.World;
+
+import java.util.Arrays;
+
+public class StructureHelper {
+
+    public static <T>IStructureElement<T> addFrame(Materials aMaterials) {
+        return new IStructureElement<T>() {
+
+            private IIcon[] mIcons;
+
+            @Override
+            public boolean check(T t, World world, int x, int y, int z) {
+                TileEntity tBlock = world.getTileEntity(x, y, z);
+                if (tBlock instanceof BaseMetaPipeEntity) {
+                    BaseMetaPipeEntity tFrame = (BaseMetaPipeEntity) tBlock;
+                    if (tFrame.isInvalidTileEntity()) return false;
+                    if (tFrame.getMetaTileEntity() instanceof GT_MetaPipeEntity_Frame) {
+                        return ((GT_MetaPipeEntity_Frame) tFrame.getMetaTileEntity()).mMaterial == aMaterials;
+                    }
+                }
+                return false;
+            }
+
+            @Override
+            public boolean spawnHint(T t, World world, int x, int y, int z, ItemStack trigger) {
+                if (mIcons == null) {
+                    mIcons = new IIcon[6];
+                    Arrays.fill(mIcons, aMaterials.mIconSet.mTextures[OrePrefixes.frameGt.mTextureIndex].getIcon());
+                }
+                TecTech.proxy.hint_particle_tinted(world, x, y, z, mIcons, aMaterials.mRGBa);
+                return true;
+            }
+
+            @Override
+            public boolean placeBlock(T t, World world, int x, int y, int z, ItemStack trigger) {
+                ItemStack tFrame = GT_OreDictUnificator.get(OrePrefixes.frameGt, aMaterials, 1);
+                if (tFrame.getItem() instanceof ItemBlock) {
+                    ItemBlock tFrameStackItem = (ItemBlock) tFrame.getItem();
+                    return tFrameStackItem.placeBlockAt(tFrame, null, world, x, y, z, 6, 0, 0, 0, Items.feather.getDamage(tFrame));
+                }
+                return false;
+            }
+        };
+    }
+
+}