+Electric Blast Furnace clone - For Testing

+Added Blazing Pyrotheum
+Added Gelid Cryotheum
+Added Blizz Rods

3 files changed, 355 insertions, 0 deletions

diff --git a/src/Java/miscutil/gregtech/common/Meta_GT_Proxy.java b/src/Java/miscutil/gregtech/common/Meta_GT_Proxy.java
new file mode 100644
index 0000000000..0d40c312d7
--- /dev/null
+++ b/src/Java/miscutil/gregtech/common/Meta_GT_Proxy.java
@@ -0,0 +1,84 @@
+package miscutil.gregtech.common;
+
+import gregtech.api.enums.Dyes;
+import gregtech.api.enums.GT_Values;
+import gregtech.api.objects.GT_Fluid;
+import gregtech.api.util.GT_LanguageManager;
+import gregtech.api.util.GT_Utility;
+import miscutil.gregtech.api.enums.GregtechOrePrefixes.GT_Materials;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidContainerRegistry;
+import net.minecraftforge.fluids.FluidRegistry;
+import net.minecraftforge.fluids.FluidStack;
+
+public class Meta_GT_Proxy {
+
+	public static Fluid addFluid(String aName, String aLocalized, GT_Materials aMaterial, int aState, int aTemperatureK) {
+		return addFluid(aName, aLocalized, aMaterial, aState, aTemperatureK, null, null, 0);
+	}
+
+	public static Fluid addFluid(String aName, String aLocalized, GT_Materials cryotheum, int aState, int aTemperatureK, ItemStack aFullContainer,
+			ItemStack aEmptyContainer, int aFluidAmount) {
+		return addFluid(aName, aName.toLowerCase(), aLocalized, cryotheum, null, aState, aTemperatureK, aFullContainer, aEmptyContainer, aFluidAmount);
+	}
+
+	public static Fluid addFluid(String aName, String aTexture, String aLocalized, GT_Materials aMaterial, short[] aRGBa, int aState, int aTemperatureK,
+			ItemStack aFullContainer, ItemStack aEmptyContainer, int aFluidAmount) {
+		aName = aName.toLowerCase();
+		Fluid rFluid = new GT_Fluid(aName, aTexture, aRGBa != null ? aRGBa : Dyes._NULL.getRGBA());
+		GT_LanguageManager.addStringLocalization(rFluid.getUnlocalizedName(), aLocalized == null ? aName : aLocalized);
+		if (FluidRegistry.registerFluid(rFluid)) {
+			switch (aState) {
+			case 0:
+				rFluid.setGaseous(false);
+				rFluid.setViscosity(10000);
+				break;
+			case 1:
+			case 4:
+				rFluid.setGaseous(false);
+				rFluid.setViscosity(1000);
+				break;
+			case 2:
+				rFluid.setGaseous(true);
+				rFluid.setDensity(-100);
+				rFluid.setViscosity(200);
+				break;
+			case 3:
+				rFluid.setGaseous(true);
+				rFluid.setDensity(55536);
+				rFluid.setViscosity(10);
+				rFluid.setLuminosity(15);
+			}
+		} else {
+			rFluid = FluidRegistry.getFluid(aName);
+		}
+		if (rFluid.getTemperature() == new Fluid("test").getTemperature()) {
+			rFluid.setTemperature(aTemperatureK);
+		}
+		if (aMaterial != null) {
+			switch (aState) {
+			case 0:
+				aMaterial.mSolid = rFluid;
+				break;
+			case 1:
+				aMaterial.mFluid = rFluid;
+				break;
+			case 2:
+				aMaterial.mGas = rFluid;
+				break;
+			case 3:
+				aMaterial.mPlasma = rFluid;
+				break;
+			case 4:
+				aMaterial.mStandardMoltenFluid = rFluid;
+			}
+		}
+		if ((aFullContainer != null) && (aEmptyContainer != null)
+				&& (!FluidContainerRegistry.registerFluidContainer(new FluidStack(rFluid, aFluidAmount), aFullContainer, aEmptyContainer))) {
+			GT_Values.RA.addFluidCannerRecipe(aFullContainer, GT_Utility.getContainerItem(aFullContainer, false), null, new FluidStack(rFluid, aFluidAmount));
+		}
+		return rFluid;
+	}
+	
+}
diff --git a/src/Java/miscutil/gregtech/common/blocks/fluid/GregtechFluidHandler.java b/src/Java/miscutil/gregtech/common/blocks/fluid/GregtechFluidHandler.java
new file mode 100644
index 0000000000..cfda074689
--- /dev/null
+++ b/src/Java/miscutil/gregtech/common/blocks/fluid/GregtechFluidHandler.java
@@ -0,0 +1,35 @@
+package miscutil.gregtech.common.blocks.fluid;
+
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.util.GT_OreDictUnificator;
+import miscutil.gregtech.api.enums.GregtechOrePrefixes.GT_Materials;
+import miscutil.gregtech.common.Meta_GT_Proxy;
+
+public class GregtechFluidHandler {
+
+	public static void run(){
+		start();
+	}
+	
+	private static void start(){
+		
+    /*    Meta_GT_Proxy.addFluid("lubricant", "Lubricant", Materials.Lubricant, 1, 295, GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Lubricant, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
+        Meta_GT_Proxy.addFluid("creosote", "Creosote Oil", Materials.Creosote, 1, 295, GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Creosote, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
+        Meta_GT_Proxy.addFluid("seedoil", "Seed Oil", Materials.SeedOil, 1, 295, GT_OreDictUnificator.get(OrePrefixes.cell, Materials.SeedOil, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
+        Meta_GT_Proxy.addFluid("fishoil", "Fish Oil", Materials.FishOil, 1, 295, GT_OreDictUnificator.get(OrePrefixes.cell, Materials.FishOil, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
+        Meta_GT_Proxy.addFluid("oil", "Oil", Materials.Oil, 1, 295, GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Oil, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
+        Meta_GT_Proxy.addFluid("fuel", "Diesel", Materials.Fuel, 1, 295, GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Fuel, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
+        Meta_GT_Proxy.addFluid("for.honey", "Honey", Materials.Honey, 1, 295, GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Honey, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
+        Meta_GT_Proxy.addFluid("biomass", "Biomass", Materials.Biomass, 1, 295, GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Biomass, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
+        Meta_GT_Proxy.addFluid("bioethanol", "Bio Ethanol", Materials.Ethanol, 1, 295, GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Ethanol, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
+        Meta_GT_Proxy.addFluid("sulfuricacid", "Sulfuric Acid", Materials.SulfuricAcid, 1, 295, GT_OreDictUnificator.get(OrePrefixes.cell, Materials.SulfuricAcid, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
+        Meta_GT_Proxy.addFluid("milk", "Milk", Materials.Milk, 1, 290, GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Milk, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
+        Meta_GT_Proxy.addFluid("mcguffium", "Mc Guffium 239", Materials.McGuffium239, 1, 295, GT_OreDictUnificator.get(OrePrefixes.cell, Materials.McGuffium239, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
+        Meta_GT_Proxy.addFluid("glue", "Glue", Materials.Glue, 1, 295, GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Glue, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
+        */
+		Meta_GT_Proxy.addFluid("gelidcryotheum", "Gelic Cryotheum", GT_Materials.Cryotheum, 1, 400, GT_OreDictUnificator.get(OrePrefixes.cell, GT_Materials.Cryotheum, 1L), ItemList.Cell_Empty.get(1L, new Object[0]), 1000);
+
+	}
+	
+}
diff --git a/src/Java/miscutil/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityElectricBlastFurnace.java b/src/Java/miscutil/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityElectricBlastFurnace.java
new file mode 100644
index 0000000000..0b77693648
--- /dev/null
+++ b/src/Java/miscutil/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityElectricBlastFurnace.java
@@ -0,0 +1,236 @@
+package miscutil.gregtech.common.tileentities.machines.multi;
+
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.Textures;
+import gregtech.api.gui.GT_GUIContainer_MultiMachine;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_MultiBlockBase;
+import gregtech.api.objects.GT_RenderedTexture;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GT_Utility;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidStack;
+
+public class GregtechMetaTileEntityElectricBlastFurnace
+        extends GT_MetaTileEntity_MultiBlockBase {
+    private int mHeatingCapacity = 0;
+
+    public GregtechMetaTileEntityElectricBlastFurnace(int aID, String aName, String aNameRegional) {
+        super(aID, aName, aNameRegional);
+    }
+
+    public GregtechMetaTileEntityElectricBlastFurnace(String aName) {
+        super(aName);
+    }
+
+    @Override
+	public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new GregtechMetaTileEntityElectricBlastFurnace(this.mName);
+    }
+
+    @Override
+	public String[] getDescription() {
+        return new String[]{"Controller Block for the Blast Furnace",
+        		"Size: 3x3x4 (Hollow)", "Controller (front middle at bottom)",
+        		"16x Heating Coils (two middle Layers, hollow)",
+        		"1x Input (one of bottom)",
+        		"1x Output (one of bottom)",
+        		"1x Energy Hatch (one of bottom)",
+        		"1x Maintenance Hatch (one of bottom)",
+        		"1x Muffler Hatch (top middle)",
+        		"Heat Proof Machine Casings for the rest"};
+    }
+
+    @Override
+	public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) {
+        if (aSide == aFacing) {
+            return new ITexture[]{Textures.BlockIcons.CASING_BLOCKS[11], new GT_RenderedTexture(aActive ? Textures.BlockIcons.OVERLAY_FRONT_ELECTRIC_BLAST_FURNACE_ACTIVE : Textures.BlockIcons.OVERLAY_FRONT_ELECTRIC_BLAST_FURNACE)};
+        }
+        return new ITexture[]{Textures.BlockIcons.CASING_BLOCKS[11]};
+    }
+
+    @Override
+	public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+        return new GT_GUIContainer_MultiMachine(aPlayerInventory, aBaseMetaTileEntity, getLocalName(), "ElectricBlastFurnace.png");
+    }
+
+    @Override
+	public GT_Recipe.GT_Recipe_Map getRecipeMap() {
+        return GT_Recipe.GT_Recipe_Map.sBlastRecipes;
+    }
+
+    @Override
+	public boolean isCorrectMachinePart(ItemStack aStack) {
+        return true;
+    }
+
+    @Override
+	public boolean isFacingValid(byte aFacing) {
+        return aFacing > 1;
+    }
+
+    @Override
+	public boolean checkRecipe(ItemStack aStack) {
+        ArrayList<ItemStack> tInputList = getStoredInputs();
+        for (int i = 0; i < tInputList.size() - 1; i++) {
+            for (int j = i + 1; j < tInputList.size(); j++) {
+                if (GT_Utility.areStacksEqual((ItemStack) tInputList.get(i), (ItemStack) tInputList.get(j))) {
+                    if (((ItemStack) tInputList.get(i)).stackSize >= ((ItemStack) tInputList.get(j)).stackSize) {
+                        tInputList.remove(j--);
+                    } else {
+                        tInputList.remove(i--);
+                        break;
+                    }
+                }
+            }
+        }
+        ItemStack[] tInputs = (ItemStack[]) Arrays.copyOfRange(tInputList.toArray(new ItemStack[tInputList.size()]), 0, 2);
+
+        ArrayList<FluidStack> tFluidList = getStoredFluids();
+        for (int i = 0; i < tFluidList.size() - 1; i++) {
+            for (int j = i + 1; j < tFluidList.size(); j++) {
+                if (GT_Utility.areFluidsEqual((FluidStack) tFluidList.get(i), (FluidStack) tFluidList.get(j))) {
+                    if (((FluidStack) tFluidList.get(i)).amount >= ((FluidStack) tFluidList.get(j)).amount) {
+                        tFluidList.remove(j--);
+                    } else {
+                        tFluidList.remove(i--);
+                        break;
+                    }
+                }
+            }
+        }
+        FluidStack[] tFluids = (FluidStack[]) Arrays.copyOfRange(tFluidList.toArray(new FluidStack[tInputList.size()]), 0, 1);
+        if (tInputList.size() > 0) {
+            long tVoltage = getMaxInputVoltage();
+            byte tTier = (byte) Math.max(1, GT_Utility.getTier(tVoltage));
+            GT_Recipe tRecipe = GT_Recipe.GT_Recipe_Map.sBlastRecipes.findRecipe(getBaseMetaTileEntity(), false, gregtech.api.enums.GT_Values.V[tTier], tFluids, tInputs);
+            if ((tRecipe != null) && (this.mHeatingCapacity >= tRecipe.mSpecialValue) && (tRecipe.isRecipeInputEqual(true, tFluids, tInputs))) {
+                this.mEfficiency = (10000 - (getIdealStatus() - getRepairStatus()) * 1000);
+                this.mEfficiencyIncrease = 10000;
+                if (tRecipe.mEUt <= 16) {
+                    this.mEUt = (tRecipe.mEUt * (1 << tTier - 1) * (1 << tTier - 1));
+                    this.mMaxProgresstime = (tRecipe.mDuration / (1 << tTier - 1));
+                } else {
+                    this.mEUt = tRecipe.mEUt;
+                    this.mMaxProgresstime = tRecipe.mDuration;
+                    while (this.mEUt <= gregtech.api.enums.GT_Values.V[(tTier - 1)]) {
+                        this.mEUt *= 4;
+                        this.mMaxProgresstime /= 2;
+                    }
+                }
+                if (this.mEUt > 0) {
+                    this.mEUt = (-this.mEUt);
+                }
+                this.mMaxProgresstime = Math.max(1, this.mMaxProgresstime);
+                this.mOutputItems = new ItemStack[]{tRecipe.getOutput(0), tRecipe.getOutput(1)};
+                updateSlots();
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+	public boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
+        int xDir = ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()).offsetX;
+        int zDir = ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()).offsetZ;
+
+        this.mHeatingCapacity = 0;
+        if (!aBaseMetaTileEntity.getAirOffset(xDir, 1, zDir)) {
+            return false;
+        }
+        if (!aBaseMetaTileEntity.getAirOffset(xDir, 2, zDir)) {
+            return false;
+        }
+        addMufflerToMachineList(aBaseMetaTileEntity.getIGregTechTileEntityOffset(xDir, 3, zDir), 11);
+
+        byte tUsedMeta = aBaseMetaTileEntity.getMetaIDOffset(xDir + 1, 2, zDir);
+        switch (tUsedMeta) {
+            case 12:
+                this.mHeatingCapacity = 1800;
+                break;
+            case 13:
+                this.mHeatingCapacity = 2700;
+                break;
+            case 14:
+                this.mHeatingCapacity = 3600;
+                break;
+            default:
+                return false;
+        }
+        for (int i = -1; i < 2; i++) {
+            for (int j = -1; j < 2; j++) {
+                if ((i != 0) || (j != 0)) {
+                    if (aBaseMetaTileEntity.getBlockOffset(xDir + i, 2, zDir + j) != GregTech_API.sBlockCasings1) {
+                        return false;
+                    }
+                    if (aBaseMetaTileEntity.getMetaIDOffset(xDir + i, 2, zDir + j) != tUsedMeta) {
+                        return false;
+                    }
+                    if (aBaseMetaTileEntity.getBlockOffset(xDir + i, 1, zDir + j) != GregTech_API.sBlockCasings1) {
+                        return false;
+                    }
+                    if (aBaseMetaTileEntity.getMetaIDOffset(xDir + i, 1, zDir + j) != tUsedMeta) {
+                        return false;
+                    }
+                    if (aBaseMetaTileEntity.getBlockOffset(xDir + i, 3, zDir + j) != GregTech_API.sBlockCasings1) {
+                        return false;
+                    }
+                    if (aBaseMetaTileEntity.getMetaIDOffset(xDir + i, 3, zDir + j) != 11) {
+                        return false;
+                    }
+                }
+            }
+        }
+        for (int i = -1; i < 2; i++) {
+            for (int j = -1; j < 2; j++) {
+                if ((xDir + i != 0) || (zDir + j != 0)) {
+                    IGregTechTileEntity tTileEntity = aBaseMetaTileEntity.getIGregTechTileEntityOffset(xDir + i, 0, zDir + j);
+                    if ((!addMaintenanceToMachineList(tTileEntity, 11)) && (!addInputToMachineList(tTileEntity, 11)) && (!addOutputToMachineList(tTileEntity, 11)) && (!addEnergyInputToMachineList(tTileEntity, 11))) {
+                        if (aBaseMetaTileEntity.getBlockOffset(xDir + i, 0, zDir + j) != GregTech_API.sBlockCasings1) {
+                            return false;
+                        }
+                        if (aBaseMetaTileEntity.getMetaIDOffset(xDir + i, 0, zDir + j) != 11) {
+                            return false;
+                        }
+                    }
+                }
+            }
+        }
+        this.mHeatingCapacity += 100 * (GT_Utility.getTier(getMaxInputVoltage()) - 2);
+        return true;
+    }
+
+    @Override
+	public int getMaxEfficiency(ItemStack aStack) {
+        return 10000;
+    }
+
+    @Override
+	public int getPollutionPerTick(ItemStack aStack) {
+        return 10;
+    }
+
+    @Override
+	public int getDamageToComponent(ItemStack aStack) {
+        return 0;
+    }
+
+    @Override
+	public int getAmountOfOutputs() {
+        return 2;
+    }
+
+    @Override
+	public boolean explodesOnComponentBreak(ItemStack aStack) {
+        return false;
+    }
+}