new render system and add SC fluid power system and XHE base, no recipe yet

8 files changed, 602 insertions, 13 deletions

diff --git a/src/main/java/goodgenerator/blocks/regularBlock/TurbineCasing.java b/src/main/java/goodgenerator/blocks/regularBlock/TurbineCasing.java
new file mode 100644
index 0000000000..8387662298
--- /dev/null
+++ b/src/main/java/goodgenerator/blocks/regularBlock/TurbineCasing.java
@@ -0,0 +1,106 @@
+package goodgenerator.blocks.regularBlock;
+
+import goodgenerator.client.render.BlockRenderHandler;
+import goodgenerator.blocks.tileEntity.base.GT_MetaTileEntity_LargeTurbineBase;
+import goodgenerator.main.GoodGenerator;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.IIconContainer;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.render.TextureFactory;
+import net.minecraft.block.Block;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.IBlockAccess;
+
+public class TurbineCasing extends Casing {
+
+    public static IIconContainer[][] turbineShape = new IIconContainer[3][9];
+    public IIconContainer base;
+
+    static {
+        for (int i = 0; i < 3; i ++)
+            for (int j = 1; j <= 9; j ++)
+                turbineShape[i][j - 1] = new Textures.BlockIcons.CustomIcon("icons/turbines/TURBINE_" + i + "" + j);
+    }
+
+    public TurbineCasing(String name, String texture) {
+        super(name, new String[]{GoodGenerator.MOD_ID + ":" + texture});
+        base = new Textures.BlockIcons.CustomIcon("icons/" + texture);
+    }
+
+    private static int isTurbineControllerWithSide(IBlockAccess aWorld, int aX, int aY, int aZ, int aSide) {
+        TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ);
+        if (!(tTileEntity instanceof IGregTechTileEntity)) return 0;
+        IGregTechTileEntity tTile = (IGregTechTileEntity) tTileEntity;
+        if (tTile.getMetaTileEntity() instanceof GT_MetaTileEntity_LargeTurbineBase && tTile.getFrontFacing() == aSide) {
+            if (tTile.isActive()) return 1;
+            return ((GT_MetaTileEntity_LargeTurbineBase) tTile.getMetaTileEntity()).hasTurbine() ? 2 : 3;
+        }
+        return 0;
+    }
+
+    public ITexture[] getTurbineCasing(int iconIndex, boolean active, boolean hasTurbine) {
+        int states = active ? 0 : hasTurbine ? 1 : 2;
+        return new ITexture[] {
+                TextureFactory.of(base),
+                TextureFactory.of(turbineShape[states][iconIndex])
+        };
+    }
+
+    public ITexture[] getTexture(Block aBlock, byte aSide) {
+        return new ITexture[] {
+                TextureFactory.of(base)
+        };
+    }
+
+    public ITexture[] getTexture(Block aBlock, byte aSide, IBlockAccess aWorld, int xCoord, int yCoord, int zCoord) {
+        int tInvertLeftRightMod = aSide % 2 * 2 - 1;
+        switch (aSide / 2) {
+            case 0:
+                for (int i = -1; i < 2; i++) {
+                    for (int j = -1; j < 2; j++) {
+                        if (i == 0 && j == 0)
+                            continue;
+                        int tState;
+                        if ((tState = isTurbineControllerWithSide(aWorld, xCoord + j, yCoord, zCoord + i, aSide)) != 0) {
+                            return getTurbineCasing(4 - i * 3 - j, tState == 1, tState == 2);
+                        }
+                    }
+                }
+                break;
+            case 1:
+                for (int i = -1; i < 2; i++) {
+                    for (int j = -1; j < 2; j++) {
+                        if (i == 0 && j == 0)
+                            continue;
+                        int tState;
+                        if ((tState = isTurbineControllerWithSide(aWorld, xCoord + j, yCoord + i, zCoord, aSide)) != 0) {
+                            return getTurbineCasing(4 + i * 3 - j * tInvertLeftRightMod, tState == 1, tState == 2);
+                        }
+                    }
+                }
+                break;
+            case 2:
+                for (int i = -1; i < 2; i++) {
+                    for (int j = -1; j < 2; j++) {
+                        if (i == 0 && j == 0)
+                            continue;
+                        int tState;
+                        if ((tState = isTurbineControllerWithSide(aWorld, xCoord, yCoord + i, zCoord + j, aSide)) != 0) {
+                            return getTurbineCasing(4 + i * 3 + j * tInvertLeftRightMod, tState == 1, tState == 2);
+                        }
+                    }
+                }
+                break;
+        }
+        return getTexture(aBlock, aSide);
+    }
+
+    @Override
+    public int getRenderType() {
+        if (BlockRenderHandler.INSTANCE == null) {
+            return super.getRenderType();
+        }
+        return BlockRenderHandler.INSTANCE.mRenderID;
+    }
+}
diff --git a/src/main/java/goodgenerator/blocks/tileEntity/ExtremeHeatExchanger.java b/src/main/java/goodgenerator/blocks/tileEntity/ExtremeHeatExchanger.java
new file mode 100644
index 0000000000..95fd4b3396
--- /dev/null
+++ b/src/main/java/goodgenerator/blocks/tileEntity/ExtremeHeatExchanger.java
@@ -0,0 +1,36 @@
+package goodgenerator.blocks.tileEntity;
+
+import com.github.technus.tectech.thing.metaTileEntity.multi.base.GT_MetaTileEntity_MultiblockBase_EM;
+import com.gtnewhorizon.structurelib.alignment.constructable.IConstructable;
+import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import net.minecraft.item.ItemStack;
+
+public class ExtremeHeatExchanger extends GT_MetaTileEntity_MultiblockBase_EM implements IConstructable {
+
+    protected IStructureDefinition<ExtremeHeatExchanger> multiDefinition = null;
+
+    public ExtremeHeatExchanger(String name) {
+        super(name);
+    }
+
+    public ExtremeHeatExchanger(int id, String name, String nameRegional) {
+        super(id, name, nameRegional);
+    }
+
+    @Override
+    public void construct(ItemStack stackSize, boolean hintsOnly) {
+
+    }
+
+    @Override
+    public String[] getStructureDescription(ItemStack stackSize) {
+        return new String[0];
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new ExtremeHeatExchanger(mName);
+    }
+}
diff --git a/src/main/java/goodgenerator/blocks/tileEntity/MetalVaporTurbine.java b/src/main/java/goodgenerator/blocks/tileEntity/MetalVaporTurbine.java
deleted file mode 100644
index 29aa1f3e1c..0000000000
--- a/src/main/java/goodgenerator/blocks/tileEntity/MetalVaporTurbine.java
+++ /dev/null
@@ -1,5 +0,0 @@
-package goodgenerator.blocks.tileEntity;
-
-public class MetalVaporTurbine{
-
-}
diff --git a/src/main/java/goodgenerator/blocks/tileEntity/SupercriticalFluidTurbine.java b/src/main/java/goodgenerator/blocks/tileEntity/SupercriticalFluidTurbine.java
new file mode 100644
index 0000000000..f2f63f5e01
--- /dev/null
+++ b/src/main/java/goodgenerator/blocks/tileEntity/SupercriticalFluidTurbine.java
@@ -0,0 +1,84 @@
+package goodgenerator.blocks.tileEntity;
+
+import goodgenerator.blocks.tileEntity.base.GT_MetaTileEntity_LargeTurbineBase;
+import goodgenerator.loader.Loaders;
+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.render.TextureFactory;
+import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
+import net.minecraft.block.Block;
+import net.minecraftforge.fluids.FluidStack;
+
+import java.util.ArrayList;
+
+public class SupercriticalFluidTurbine extends GT_MetaTileEntity_LargeTurbineBase {
+
+    private static final IIconContainer turbineOn = new Textures.BlockIcons.CustomIcon("icons/turbines/TURBINE_05");
+    private static final IIconContainer turbineOff = new Textures.BlockIcons.CustomIcon("icons/turbines/TURBINE_15");
+    private static final IIconContainer turbineEmpty = new Textures.BlockIcons.CustomIcon("icons/turbines/TURBINE_25");
+
+    public SupercriticalFluidTurbine(int aID, String aName, String aNameRegional) {
+        super(aID, aName, aNameRegional);
+    }
+
+    public SupercriticalFluidTurbine(String aName) {
+        super(aName);
+    }
+
+    @Override
+    public int fluidIntoPower(ArrayList<FluidStack> aFluids, int aOptFlow, int aBaseEff) {
+        return 0;
+    }
+
+    @Override
+    public Block getCasingBlock() {
+        return Loaders.supercriticalFluidTurbineCasing;
+    }
+
+    @Override
+    public int getCasingMeta() {
+        return 0;
+    }
+
+    @Override
+    public int getCasingTextureIndex() {
+        return 1538;
+    }
+
+    @Override
+    protected GT_Multiblock_Tooltip_Builder createTooltip() {
+        final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder();
+        tt.addMachineType("Supercritical Fluid Turbine")
+                .addInfo("Controller block for Supercritical Fluid Turbine")
+                .addInfo("Needs a Turbine, place inside controller")
+                .addInfo("The Supercritical Fluid's temperature gives extra efficiency.")
+                .addSeparator()
+                .beginStructureBlock(3, 3, 4, true)
+                .addController("Front center")
+                .addCasingInfo("SC Turbine Casing", 24)
+                .addDynamoHatch("Back center", 1)
+                .addMaintenanceHatch("Side centered", 2)
+                .addMufflerHatch("Side centered", 2)
+                .addInputHatch("Supercritical Fluid, Side centered", 2)
+                .toolTipFinisher("Good Generator");
+        return tt;
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new SupercriticalFluidTurbine(mName);
+    }
+
+    @Override
+    public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) {
+        return new ITexture[] {
+                Textures.BlockIcons.getCasingTextureForId(1538),
+                aFacing == aSide ?
+                        (aActive ? TextureFactory.of(turbineOn) : hasTurbine() ? TextureFactory.of(turbineOff) : TextureFactory.of(turbineEmpty))
+                        : Textures.BlockIcons.getCasingTextureForId(1538)
+        };
+    }
+}
diff --git a/src/main/java/goodgenerator/blocks/tileEntity/base/GT_MetaTileEntity_LargeTurbineBase.java b/src/main/java/goodgenerator/blocks/tileEntity/base/GT_MetaTileEntity_LargeTurbineBase.java
new file mode 100644
index 0000000000..5b9bfaaf79
--- /dev/null
+++ b/src/main/java/goodgenerator/blocks/tileEntity/base/GT_MetaTileEntity_LargeTurbineBase.java
@@ -0,0 +1,256 @@
+//copied from gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_LargeTurbine
+//The origin one in gt made the abstract method private so i can't imp it.
+package goodgenerator.blocks.tileEntity.base;
+
+import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
+import com.gtnewhorizon.structurelib.structure.IStructureElementCheckOnly;
+import com.gtnewhorizon.structurelib.structure.StructureDefinition;
+import gregtech.api.gui.GT_GUIContainer_MultiMachine;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.items.GT_MetaGenerated_Tool;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_EnhancedMultiBlockBase;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Dynamo;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Muffler;
+import gregtech.api.util.GT_Utility;
+import gregtech.common.items.GT_MetaGenerated_Tool_01;
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.StatCollector;
+import net.minecraftforge.fluids.FluidStack;
+
+import java.util.ArrayList;
+
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.lazy;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlock;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.transpose;
+import static gregtech.api.util.GT_StructureUtility.ofHatchAdder;
+import static gregtech.api.util.GT_StructureUtility.ofHatchAdderOptional;
+
+public abstract class GT_MetaTileEntity_LargeTurbineBase extends GT_MetaTileEntity_EnhancedMultiBlockBase<GT_MetaTileEntity_LargeTurbineBase> {
+    private static final String STRUCTURE_PIECE_MAIN = "main";
+    private static final ClassValue<IStructureDefinition<GT_MetaTileEntity_LargeTurbineBase>> STRUCTURE_DEFINITION = new ClassValue<IStructureDefinition<GT_MetaTileEntity_LargeTurbineBase>>() {
+        @Override
+        protected IStructureDefinition<GT_MetaTileEntity_LargeTurbineBase> computeValue(Class<?> type) {
+            return StructureDefinition.<GT_MetaTileEntity_LargeTurbineBase>builder()
+                    .addShape(STRUCTURE_PIECE_MAIN, transpose(new String[][]{
+                            {"     ", "xxxxx", "xxxxx", "xxxxx", "xxxxx",},
+                            {" --- ", "xcccx", "xchcx", "xchcx", "xcccx",},
+                            {" --- ", "xc~cx", "xh-hx", "xh-hx", "xcdcx",},
+                            {" --- ", "xcccx", "xchcx", "xchcx", "xcccx",},
+                            {"     ", "xxxxx", "xxxxx", "xxxxx", "xxxxx",},
+                    }))
+                    .addElement('c', lazy(t -> ofBlock(t.getCasingBlock(), t.getCasingMeta())))
+                    .addElement('d', lazy(t -> ofHatchAdder(GT_MetaTileEntity_LargeTurbineBase::addDynamoToMachineList, t.getCasingTextureIndex(), 1)))
+                    .addElement('h', lazy(t -> ofHatchAdderOptional(GT_MetaTileEntity_LargeTurbineBase::addToMachineList, t.getCasingTextureIndex(), 2, t.getCasingBlock(), t.getCasingMeta())))
+                    .addElement('x', (IStructureElementCheckOnly<GT_MetaTileEntity_LargeTurbineBase>) (aContext, aWorld, aX, aY, aZ) -> {
+                        TileEntity tTile = aWorld.getTileEntity(aX, aY, aZ);
+                        return !(tTile instanceof IGregTechTileEntity) || !(((IGregTechTileEntity) tTile).getMetaTileEntity() instanceof GT_MetaTileEntity_LargeTurbineBase);
+                    })
+                    .build();
+        }
+    };
+
+    protected int baseEff = 0;
+    protected int optFlow = 0;
+    protected double realOptFlow = 0;
+    protected int storedFluid = 0;
+    protected int counter = 0;
+    protected boolean looseFit = false;
+
+    public GT_MetaTileEntity_LargeTurbineBase(int aID, String aName, String aNameRegional) {
+        super(aID, aName, aNameRegional);
+    }
+
+    public GT_MetaTileEntity_LargeTurbineBase(String aName) {
+        super(aName);
+    }
+
+    @Override
+    public boolean isCorrectMachinePart(ItemStack aStack) {
+        return getMaxEfficiency(aStack) > 0;
+    }
+
+    @Override
+    public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+        return new GT_GUIContainer_MultiMachine(aPlayerInventory, aBaseMetaTileEntity, getLocalName(), "LargeTurbine.png");
+    }
+
+    @Override
+    public IStructureDefinition<GT_MetaTileEntity_LargeTurbineBase> getStructureDefinition() {
+        return STRUCTURE_DEFINITION.get(getClass());
+    }
+
+    @Override
+    public boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
+        return checkPiece(STRUCTURE_PIECE_MAIN, 2, 2, 1) && mMaintenanceHatches.size() == 1 && mMufflerHatches.isEmpty() == (getPollutionPerTick(null) == 0);
+    }
+
+    public abstract Block getCasingBlock();
+
+    public abstract int getCasingMeta();
+
+    public abstract int getCasingTextureIndex();
+
+    @Override
+    public boolean addToMachineList(IGregTechTileEntity tTileEntity, int aBaseCasingIndex) {
+        return addMaintenanceToMachineList(tTileEntity, getCasingTextureIndex()) || addInputToMachineList(tTileEntity, getCasingTextureIndex()) || addOutputToMachineList(tTileEntity, getCasingTextureIndex()) || addMufflerToMachineList(tTileEntity, getCasingTextureIndex());
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        super.saveNBTData(aNBT);
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        super.loadNBTData(aNBT);
+    }
+
+    @Override
+    public boolean checkRecipe(ItemStack aStack) {
+        if ((counter & 7) == 0 && (aStack == null || !(aStack.getItem() instanceof GT_MetaGenerated_Tool) || aStack.getItemDamage() < 170 || aStack.getItemDamage() > 179)) {
+            stopMachine();
+            return false;
+        }
+        ArrayList<FluidStack> tFluids = getStoredFluids();
+        if (tFluids.size() > 0) {
+            if (baseEff == 0 || optFlow == 0 || counter >= 512 || this.getBaseMetaTileEntity().hasWorkJustBeenEnabled()
+                    || this.getBaseMetaTileEntity().hasInventoryBeenModified()) {
+                counter = 0;
+                baseEff = GT_Utility.safeInt((long) ((5F + ((GT_MetaGenerated_Tool) aStack.getItem()).getToolCombatDamage(aStack)) * 1000F));
+                optFlow = GT_Utility.safeInt((long) Math.max(Float.MIN_NORMAL,
+                        ((GT_MetaGenerated_Tool) aStack.getItem()).getToolStats(aStack).getSpeedMultiplier()
+                                * GT_MetaGenerated_Tool.getPrimaryMaterial(aStack).mToolSpeed
+                                * 50));
+                if(optFlow<=0 || baseEff<=0){
+                    stopMachine();//in case the turbine got removed
+                    return false;
+                }
+            } else {
+                counter++;
+            }
+        }
+
+        int newPower = fluidIntoPower(tFluids, optFlow, baseEff);  // How much the turbine should be producing with this flow
+        int difference = newPower - this.mEUt; // difference between current output and new output
+
+        // Magic numbers: can always change by at least 10 eu/t, but otherwise by at most 1 percent of the difference in power level (per tick)
+        // This is how much the turbine can actually change during this tick
+        int maxChangeAllowed = Math.max(10, GT_Utility.safeInt((long)Math.abs(difference)/100));
+
+        if (Math.abs(difference) > maxChangeAllowed) { // If this difference is too big, use the maximum allowed change
+            int change = maxChangeAllowed * (difference > 0 ? 1 : -1); // Make the change positive or negative.
+            this.mEUt += change; // Apply the change
+        } else
+            this.mEUt = newPower;
+
+        if (this.mEUt <= 0) {
+            //stopMachine();
+            this.mEUt=0;
+            this.mEfficiency=0;
+            return false;
+        } else {
+            this.mMaxProgresstime = 1;
+            this.mEfficiencyIncrease = 10;
+            // Overvoltage is handled inside the MultiBlockBase when pushing out to dynamos.  no need to do it here.
+            return true;
+        }
+    }
+
+    public abstract int fluidIntoPower(ArrayList<FluidStack> aFluids, int aOptFlow, int aBaseEff);
+
+    @Override
+    public int getDamageToComponent(ItemStack aStack) {
+        return 1;
+    }
+
+    @Override
+    public int getMaxEfficiency(ItemStack aStack) {
+        if (GT_Utility.isStackInvalid(aStack)) {
+            return 0;
+        }
+        if (aStack.getItem() instanceof GT_MetaGenerated_Tool_01) {
+            return 10000;
+        }
+        return 0;
+    }
+
+    @Override
+    public boolean explodesOnComponentBreak(ItemStack aStack) {
+        return true;
+    }
+
+    @Override
+    public String[] getInfoData() {
+        int mPollutionReduction=0;
+        for (GT_MetaTileEntity_Hatch_Muffler tHatch : mMufflerHatches) {
+            if (isValidMetaTileEntity(tHatch)) {
+                mPollutionReduction=Math.max(tHatch.calculatePollutionReduction(100),mPollutionReduction);
+            }
+        }
+
+        String tRunning = mMaxProgresstime>0 ?
+
+                EnumChatFormatting.GREEN+StatCollector.translateToLocal("GT5U.turbine.running.true")+EnumChatFormatting.RESET :
+                EnumChatFormatting.RED+StatCollector.translateToLocal("GT5U.turbine.running.false")+EnumChatFormatting.RESET;
+        String tMaintainance = getIdealStatus() == getRepairStatus() ?
+                EnumChatFormatting.GREEN+StatCollector.translateToLocal("GT5U.turbine.maintenance.false")+EnumChatFormatting.RESET :
+                EnumChatFormatting.RED+StatCollector.translateToLocal("GT5U.turbine.maintenance.true")+EnumChatFormatting.RESET ;
+        int tDura = 0;
+
+        if (mInventory[1] != null && mInventory[1].getItem() instanceof GT_MetaGenerated_Tool_01) {
+            tDura = GT_Utility.safeInt((long)(100.0f / GT_MetaGenerated_Tool.getToolMaxDamage(mInventory[1]) * (GT_MetaGenerated_Tool.getToolDamage(mInventory[1]))+1));
+        }
+
+        long storedEnergy=0;
+        long maxEnergy=0;
+        for(GT_MetaTileEntity_Hatch_Dynamo tHatch : mDynamoHatches) {
+            if (isValidMetaTileEntity(tHatch)) {
+                storedEnergy+=tHatch.getBaseMetaTileEntity().getStoredEU();
+                maxEnergy+=tHatch.getBaseMetaTileEntity().getEUCapacity();
+            }
+        }
+        String[] ret = new String[]{
+                // 8 Lines available for information panels
+                tRunning + ": " + EnumChatFormatting.RED + GT_Utility.formatNumbers(mEUt) + EnumChatFormatting.RESET + " EU/t", /* 1 */
+                tMaintainance, /* 2 */
+                StatCollector.translateToLocal("GT5U.turbine.efficiency") + ": " +
+                        EnumChatFormatting.YELLOW + (mEfficiency / 100F) + EnumChatFormatting.RESET + "%", /* 2 */
+                StatCollector.translateToLocal("GT5U.multiblock.energy") + ": " +
+                        EnumChatFormatting.GREEN + GT_Utility.formatNumbers(storedEnergy) + EnumChatFormatting.RESET + " EU / " + /* 3 */
+                        EnumChatFormatting.YELLOW + GT_Utility.formatNumbers(maxEnergy) + EnumChatFormatting.RESET + " EU",
+                StatCollector.translateToLocal("GT5U.turbine.flow") + ": " +
+                        EnumChatFormatting.YELLOW + GT_Utility.formatNumbers(GT_Utility.safeInt((long) realOptFlow)) + EnumChatFormatting.RESET + " L/t" + /* 4 */
+                        EnumChatFormatting.YELLOW + " (" + (looseFit ? StatCollector.translateToLocal("GT5U.turbine.loose") : StatCollector.translateToLocal("GT5U.turbine.tight")) + ")", /* 5 */
+                StatCollector.translateToLocal("GT5U.turbine.fuel") + ": " +
+                        EnumChatFormatting.GOLD + GT_Utility.formatNumbers(storedFluid) + EnumChatFormatting.RESET + "L", /* 6 */
+                StatCollector.translateToLocal("GT5U.turbine.dmg") + ": " +
+                        EnumChatFormatting.RED + tDura + EnumChatFormatting.RESET + "%", /* 7 */
+                StatCollector.translateToLocal("GT5U.multiblock.pollution") + ": " +
+                        EnumChatFormatting.GREEN + mPollutionReduction + EnumChatFormatting.RESET + " %" /* 8 */
+        };
+        if (!this.getClass().getName().contains("Steam"))
+            ret[4] = StatCollector.translateToLocal("GT5U.turbine.flow") + ": " + EnumChatFormatting.YELLOW + GT_Utility.safeInt((long) realOptFlow) + EnumChatFormatting.RESET + " L/t";
+        return ret;
+
+
+    }
+
+    public boolean hasTurbine() {
+        return this.getMaxEfficiency(mInventory[1]) > 0;
+    }
+
+    @Override
+    public boolean isGivingInformation() {
+        return true;
+    }
+
+    @Override
+    public void construct(ItemStack stackSize, boolean hintsOnly) {
+        buildPiece(STRUCTURE_PIECE_MAIN, stackSize, hintsOnly, 2, 2, 1);
+    }
+}
diff --git a/src/main/java/goodgenerator/client/render/BlockRenderHandler.java b/src/main/java/goodgenerator/client/render/BlockRenderHandler.java
new file mode 100644
index 0000000000..3d705baae6
--- /dev/null
+++ b/src/main/java/goodgenerator/client/render/BlockRenderHandler.java
@@ -0,0 +1,103 @@
+package goodgenerator.client.render;
+
+import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
+import cpw.mods.fml.client.registry.RenderingRegistry;
+import goodgenerator.blocks.regularBlock.TurbineCasing;
+import gregtech.GT_Mod;
+import net.minecraft.block.Block;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.world.IBlockAccess;
+import org.lwjgl.opengl.GL11;
+
+import static gregtech.common.render.GT_Renderer_Block.*;
+import static net.minecraftforge.common.util.ForgeDirection.*;
+import static net.minecraftforge.common.util.ForgeDirection.EAST;
+
+public class BlockRenderHandler implements ISimpleBlockRenderingHandler {
+
+    public static final float blockMin = 0.0F;
+    public static final float blockMax = 1.0F;
+    public static BlockRenderHandler INSTANCE;
+    public final int mRenderID;
+
+    public BlockRenderHandler() {
+        this.mRenderID = RenderingRegistry.getNextAvailableRenderId();
+        INSTANCE = this;
+        RenderingRegistry.registerBlockHandler(this);
+    }
+
+    @Override
+    public void renderInventoryBlock(Block aBlock, int metadata, int modelId, RenderBlocks aRenderer) {
+        aRenderer.enableAO = false;
+        aRenderer.useInventoryTint = true;
+
+        GL11.glRotatef(90.0F, 0.0F, 1.0F, 0.0F);
+        GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
+
+        if (aBlock instanceof TurbineCasing) {
+            TurbineCasing tc = (TurbineCasing) aBlock;
+            aBlock.setBlockBoundsForItemRender();
+            aRenderer.setRenderBoundsFromBlock(aBlock);
+            Tessellator.instance.startDrawingQuads();
+            Tessellator.instance.setNormal(0, -1, 0);
+            renderNegativeYFacing(null, aRenderer, aBlock, 0, 0, 0, tc.getTexture(aBlock, (byte) DOWN.ordinal()), true);
+            Tessellator.instance.draw();
+            Tessellator.instance.startDrawingQuads();
+            Tessellator.instance.setNormal(0, 1, 0);
+            renderPositiveYFacing(null, aRenderer, aBlock, 0, 0, 0, tc.getTexture(aBlock, (byte) UP.ordinal()), true);
+            Tessellator.instance.draw();
+            Tessellator.instance.startDrawingQuads();
+            Tessellator.instance.setNormal(0, 0, -1);
+            renderNegativeZFacing(null, aRenderer, aBlock, 0, 0, 0, tc.getTexture(aBlock, (byte) NORTH.ordinal()), true);
+            Tessellator.instance.draw();
+            Tessellator.instance.startDrawingQuads();
+            Tessellator.instance.setNormal(0, 0, 1);
+            renderPositiveZFacing(null, aRenderer, aBlock, 0, 0, 0, tc.getTexture(aBlock, (byte) SOUTH.ordinal()), true);
+            Tessellator.instance.draw();
+            Tessellator.instance.startDrawingQuads();
+            Tessellator.instance.setNormal(-1, 0, 0);
+            renderNegativeXFacing(null, aRenderer, aBlock, 0, 0, 0, tc.getTexture(aBlock, (byte) WEST.ordinal()), true);
+            Tessellator.instance.draw();
+            Tessellator.instance.startDrawingQuads();
+            Tessellator.instance.setNormal(1, 0, 0);
+            renderPositiveXFacing(null, aRenderer, aBlock, 0, 0, 0, tc.getTexture(aBlock, (byte) EAST.ordinal()), true);
+            Tessellator.instance.draw();
+        }
+
+        aBlock.setBlockBounds(blockMin, blockMin, blockMin, blockMax, blockMax, blockMax);
+        aRenderer.setRenderBoundsFromBlock(aBlock);
+
+        GL11.glTranslatef(0.5F, 0.5F, 0.5F);
+        aRenderer.useInventoryTint = false;
+    }
+
+    @Override
+    public boolean renderWorldBlock(IBlockAccess aWorld, int aX, int aY, int aZ, Block aBlock, int aModelID, RenderBlocks aRenderer) {
+        aRenderer.enableAO = Minecraft.isAmbientOcclusionEnabled() && GT_Mod.gregtechproxy.mRenderTileAmbientOcclusion;
+        aRenderer.useInventoryTint = false;
+        if (aBlock instanceof TurbineCasing) {
+            aBlock.setBlockBounds(blockMin, blockMin, blockMin, blockMax, blockMax, blockMax);
+            aRenderer.setRenderBoundsFromBlock(aBlock);
+            TurbineCasing tc = (TurbineCasing) aBlock;
+            renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tc.getTexture(aBlock, (byte) DOWN.ordinal(), aWorld, aX, aY, aZ), true);
+            renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tc.getTexture(aBlock, (byte) UP.ordinal(), aWorld, aX, aY, aZ), true);
+            renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tc.getTexture(aBlock, (byte) NORTH.ordinal(), aWorld, aX, aY, aZ), true);
+            renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tc.getTexture(aBlock, (byte) SOUTH.ordinal(), aWorld, aX, aY, aZ), true);
+            renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tc.getTexture(aBlock, (byte) WEST.ordinal(), aWorld, aX, aY, aZ), true);
+            renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tc.getTexture(aBlock, (byte) EAST.ordinal(), aWorld, aX, aY, aZ), true);
+        }
+        return false;
+    }
+
+    @Override
+    public boolean shouldRender3DInInventory(int modelId) {
+        return true;
+    }
+
+    @Override
+    public int getRenderId() {
+        return this.mRenderID;
+    }
+}
diff --git a/src/main/java/goodgenerator/loader/Loaders.java b/src/main/java/goodgenerator/loader/Loaders.java
index 7883459194..6b0b3477bc 100644
--- a/src/main/java/goodgenerator/loader/Loaders.java
+++ b/src/main/java/goodgenerator/loader/Loaders.java
@@ -1,10 +1,8 @@
 package goodgenerator.loader;
 
 import goodgenerator.blocks.myFluids.FluidsBuilder;
-import goodgenerator.blocks.regularBlock.Casing;
-import goodgenerator.blocks.regularBlock.ComplexTextureCasing;
-import goodgenerator.blocks.regularBlock.Frame;
-import goodgenerator.blocks.regularBlock.TEBlock;
+import goodgenerator.blocks.regularBlock.*;
+import goodgenerator.client.render.BlockRenderHandler;
 import goodgenerator.blocks.tileEntity.*;
 import goodgenerator.blocks.tileEntity.GTMetaTileEntity.DieselGenerator;
 import goodgenerator.blocks.tileEntity.GTMetaTileEntity.NeutronAccelerator;
@@ -82,6 +80,8 @@ public class Loaders {
     public static final Block yottaFluidTankCell = new Casing("yottaFluidTankCell", new String[]{GoodGenerator.MOD_ID+":yottaFluidTankCell/1", GoodGenerator.MOD_ID+":yottaFluidTankCell/2", GoodGenerator.MOD_ID+":yottaFluidTankCell/3", GoodGenerator.MOD_ID+":yottaFluidTankCell/4", GoodGenerator.MOD_ID+":yottaFluidTankCell/5",
             GoodGenerator.MOD_ID+":yottaFluidTankCell/6", GoodGenerator.MOD_ID+":yottaFluidTankCell/7", GoodGenerator.MOD_ID+":yottaFluidTankCell/8", GoodGenerator.MOD_ID+":yottaFluidTankCell/9", GoodGenerator.MOD_ID+":yottaFluidTankCell/10",});
     public static final Block yottaFluidTankCasing = new ComplexTextureCasing("yottaFluidTankCasing", new String[]{GoodGenerator.MOD_ID+":yottaFluidTankCasing_SIDE"}, new String[]{GoodGenerator.MOD_ID+":yottaFluidTankCasing_TOP"});
+    public static final Block supercriticalFluidTurbineCasing = new TurbineCasing("supercriticalFluidTurbineCasing", "supercriticalFluidTurbineCasing");
+    public static final Block pressureResistantWalls = new Casing("pressureResistantWalls", new String[]{GoodGenerator.MOD_ID+":pressureResistantWalls"});
 
     public static Block essentiaHatch;
 
@@ -93,6 +93,7 @@ public class Loaders {
     public static ItemStack NA;
     public static ItemStack YFT;
     public static ItemStack YFH;
+    public static ItemStack SCTurbine;
 
     public static ItemStack[] NeutronAccelerators = new ItemStack[9];
     public static ItemStack[] Generator_Diesel = new ItemStack[2];
@@ -109,9 +110,10 @@ public class Loaders {
         Loaders.NS = new NeutronSensor(IDOffset + 11, "Neutron Sensor", "Neutron Sensor", 5).getStackForm(1L);
         Loaders.NA = new NeutronActivator(IDOffset + 12, "NeutronActivator", "Neutron Activator").getStackForm(1L);
         Loaders.YFT = new YottaFluidTank(IDOffset + 13, "YottaFluidTank", "YOTTank").getStackForm(1L);
-        Loaders.YFH = new YOTTAHatch(IDOffset + 14, "YottaFluidTankHatch", "YOTHatch", 5).getStackForm(1);
-        Loaders.Generator_Diesel[0] = new DieselGenerator(1113, "basicgenerator.diesel.tier.04", "Turbo Supercharging Combustion Generator", 4).getStackForm(1);
-        Loaders.Generator_Diesel[1] = new DieselGenerator(1114, "basicgenerator.diesel.tier.05", "Ultimate Chemical Energy Releaser", 5).getStackForm(1);
+        Loaders.YFH = new YOTTAHatch(IDOffset + 14, "YottaFluidTankHatch", "YOTHatch", 5).getStackForm(1L);
+        Loaders.SCTurbine = new SupercriticalFluidTurbine(IDOffset + 15, "SupercriticalFluidTurbine", "SC Fluid Turbine").getStackForm(1L);
+        Loaders.Generator_Diesel[0] = new DieselGenerator(1113, "basicgenerator.diesel.tier.04", "Turbo Supercharging Combustion Generator", 4).getStackForm(1L);
+        Loaders.Generator_Diesel[1] = new DieselGenerator(1114, "basicgenerator.diesel.tier.05", "Ultimate Chemical Energy Releaser", 5).getStackForm(1L);
     }
 
     public static void Register() {
@@ -131,6 +133,8 @@ public class Loaders {
         GameRegistry.registerBlock(speedingPipe, MyItemBlocks.class, "speedingPipe");
         GameRegistry.registerBlock(yottaFluidTankCell, MyItemBlocks.class, "yottaFluidTankCells");
         GameRegistry.registerBlock(yottaFluidTankCasing, MyItemBlocks.class, "yottaFluidTankCasing");
+        GameRegistry.registerBlock(supercriticalFluidTurbineCasing, MyItemBlocks.class, "supercriticalFluidTurbineCasing");
+        GameRegistry.registerBlock(pressureResistantWalls, MyItemBlocks.class, "pressureResistantWalls");
         GameRegistry.registerItem(radiationProtectionPlate, "radiationProtectionPlate", GoodGenerator.MOD_ID);
         GameRegistry.registerItem(wrappedUraniumIngot, "wrappedUraniumIngot", GoodGenerator.MOD_ID);
         GameRegistry.registerItem(highDensityUraniumNugget, "highDensityUraniumNugget", GoodGenerator.MOD_ID);
@@ -182,10 +186,11 @@ public class Loaders {
             Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage] = new ITexture[128];
             Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage][0] = TextureFactory.of(magicCasing);
             Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage][1] = TextureFactory.of(yottaFluidTankCasing);
+            Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage][2] = TextureFactory.of(supercriticalFluidTurbineCasing);
         }
     }
 
-    public static void preInitLoad(){
+    public static void preInitLoad() {
         Register();
         addOreDic();
         addTexturePage();
@@ -196,6 +201,7 @@ public class Loaders {
     }
 
     public static void initLoad(){
+        new BlockRenderHandler();
         GTMetaTileRegister();
         initLoadRecipes();
         IMCForNEI.IMCSender();
diff --git a/src/main/java/goodgenerator/util/ItemRefer.java b/src/main/java/goodgenerator/util/ItemRefer.java
index 8bb80e10df..f666fea41d 100644
--- a/src/main/java/goodgenerator/util/ItemRefer.java
+++ b/src/main/java/goodgenerator/util/ItemRefer.java
@@ -94,6 +94,8 @@ public final class ItemRefer {
     public static ItemRefer YOTTank_Cell_T8 = getItemStack(yottaFluidTankCell, 7);
     public static ItemRefer YOTTank_Cell_T9 = getItemStack(yottaFluidTankCell, 8);
     public static ItemRefer YOTTank_Cell_T10 = getItemStack(yottaFluidTankCell, 9);
+    public static ItemRefer SC_Turbine_Casing = getItemStack(supercriticalFluidTurbineCasing);
+    public static ItemRefer Pressure_Resistant_Wall = getItemStack(pressureResistantWalls);
 
     public static ItemRefer Large_Naquadah_Reactor = getItemStack(MAR);
     public static ItemRefer Naquadah_Fuel_Refinery = getItemStack(FRF);
@@ -102,6 +104,7 @@ public final class ItemRefer {
     public static ItemRefer YOTTank = getItemStack(YFT);
     public static ItemRefer Combustion_Generator_EV = getItemStack(Generator_Diesel[0]);
     public static ItemRefer Combustion_Generator_IV = getItemStack(Generator_Diesel[1]);
+    public static ItemRefer SC_Fluid_Turbine = getItemStack(SCTurbine);
 
     private Item mItem = null;
     private Block mBlock = null;