Merge addon sources

8 files changed, 727 insertions, 0 deletions

diff --git a/src/main/java/gtPlusPlus/xmod/thermalfoundation/HANDLER_TF.java b/src/main/java/gtPlusPlus/xmod/thermalfoundation/HANDLER_TF.java
new file mode 100644
index 0000000000..460a5e9fbe
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/thermalfoundation/HANDLER_TF.java
@@ -0,0 +1,36 @@
+package gtPlusPlus.xmod.thermalfoundation;
+
+import static gregtech.api.enums.Mods.COFHCore;
+
+import gtPlusPlus.xmod.thermalfoundation.block.TF_Blocks;
+import gtPlusPlus.xmod.thermalfoundation.fluid.TF_Fluids;
+import gtPlusPlus.xmod.thermalfoundation.item.TF_Items;
+import gtPlusPlus.xmod.thermalfoundation.recipe.TF_Gregtech_Recipes;
+
+public class HANDLER_TF {
+
+    public static void preInit() {
+        if (COFHCore.isModLoaded()) {
+            TF_Fluids.preInit();
+            TF_Items.preInit();
+            TF_Blocks.preInit();
+        }
+    }
+
+    public static void init() {
+        if (COFHCore.isModLoaded()) {
+            TF_Fluids.init();
+            TF_Blocks.init();
+            TF_Items.init();
+        }
+    }
+
+    public static void postInit() {
+        if (COFHCore.isModLoaded()) {
+            TF_Fluids.postInit();
+            TF_Items.postInit();
+            TF_Blocks.postInit();
+            TF_Gregtech_Recipes.run();
+        }
+    }
+}
diff --git a/src/main/java/gtPlusPlus/xmod/thermalfoundation/block/TF_Block_Fluid_Cryotheum.java b/src/main/java/gtPlusPlus/xmod/thermalfoundation/block/TF_Block_Fluid_Cryotheum.java
new file mode 100644
index 0000000000..b48be445e5
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/thermalfoundation/block/TF_Block_Fluid_Cryotheum.java
@@ -0,0 +1,178 @@
+package gtPlusPlus.xmod.thermalfoundation.block;
+
+import static gregtech.api.enums.Mods.GTPlusPlus;
+
+import java.util.Random;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.MapColor;
+import net.minecraft.block.material.Material;
+import net.minecraft.block.material.MaterialLiquid;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.monster.EntityBlaze;
+import net.minecraft.entity.monster.EntityCreeper;
+import net.minecraft.entity.monster.EntitySnowman;
+import net.minecraft.entity.monster.EntityZombie;
+import net.minecraft.init.Blocks;
+import net.minecraft.potion.Potion;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import cofh.core.fluid.BlockFluidInteractive;
+import cofh.lib.util.BlockWrapper;
+import cofh.lib.util.helpers.DamageHelper;
+import cofh.lib.util.helpers.ServerHelper;
+import cpw.mods.fml.common.registry.GameRegistry;
+import gtPlusPlus.xmod.thermalfoundation.fluid.TF_Fluids;
+
+public class TF_Block_Fluid_Cryotheum extends BlockFluidInteractive {
+
+    public static final Material materialFluidCryotheum = new MaterialLiquid(MapColor.iceColor);
+    private static boolean enableSourceFall = true;
+    private static boolean effect = true;
+
+    public TF_Block_Fluid_Cryotheum() {
+        super(GTPlusPlus.ID, TF_Fluids.fluidCryotheum, materialFluidCryotheum, "cryotheum");
+        this.setQuantaPerBlock(5);
+        this.setTickRate(15);
+
+        this.setHardness(1000.0F);
+        this.setLightOpacity(1);
+        this.setParticleColor(0.15F, 0.7F, 1.0F);
+    }
+
+    @Override
+    public boolean preInit() {
+        GameRegistry.registerBlock(this, "FluidCryotheum");
+
+        this.addInteraction(Blocks.grass, Blocks.dirt);
+        this.addInteraction(Blocks.water, 0, Blocks.ice);
+        this.addInteraction(Blocks.water, Blocks.snow);
+        this.addInteraction(Blocks.flowing_water, 0, Blocks.ice);
+        this.addInteraction(Blocks.flowing_water, Blocks.snow);
+        this.addInteraction(Blocks.lava, 0, Blocks.obsidian);
+        this.addInteraction(Blocks.lava, Blocks.stone);
+        this.addInteraction(Blocks.flowing_lava, 0, Blocks.obsidian);
+        this.addInteraction(Blocks.flowing_lava, Blocks.stone);
+        this.addInteraction(Blocks.leaves, Blocks.air);
+        this.addInteraction(Blocks.tallgrass, Blocks.air);
+        this.addInteraction(Blocks.fire, Blocks.air);
+
+        effect = true;
+        enableSourceFall = true;
+
+        return true;
+    }
+
+    @Override
+    public void onEntityCollidedWithBlock(final World paramWorld, final int paramInt1, final int paramInt2,
+        final int paramInt3, final Entity paramEntity) {
+        paramEntity.extinguish();
+        if (!effect) {
+            return;
+        }
+        if ((paramEntity.motionY < -0.05D) || (paramEntity.motionY > 0.05D)) {
+            paramEntity.motionY *= 0.05D;
+        }
+        if ((paramEntity.motionZ < -0.05D) || (paramEntity.motionZ > 0.05D)) {
+            paramEntity.motionZ *= 0.05D;
+        }
+        if ((paramEntity.motionX < -0.05D) || (paramEntity.motionX > 0.05D)) {
+            paramEntity.motionX *= 0.05D;
+        }
+        if (ServerHelper.isClientWorld(paramWorld)) {
+            return;
+        }
+        if ((paramWorld.getTotalWorldTime() % 8L) != 0L) {
+            return;
+        }
+        if (((paramEntity instanceof EntityZombie)) || ((paramEntity instanceof EntityCreeper))) {
+            final EntitySnowman localEntitySnowman = new EntitySnowman(paramWorld);
+            localEntitySnowman.setLocationAndAngles(
+                paramEntity.posX,
+                paramEntity.posY,
+                paramEntity.posZ,
+                paramEntity.rotationYaw,
+                paramEntity.rotationPitch);
+            paramWorld.spawnEntityInWorld(localEntitySnowman);
+
+            paramEntity.setDead();
+        } else if (
+        /* ((paramEntity instanceof EntityBlizz)) || */ ((paramEntity instanceof EntitySnowman))) {
+            ((EntityLivingBase) paramEntity).addPotionEffect(new PotionEffect(Potion.moveSpeed.id, 120, 0));
+            ((EntityLivingBase) paramEntity).addPotionEffect(new PotionEffect(Potion.regeneration.id, 120, 0));
+        } else if ((paramEntity instanceof EntityBlaze)) {
+            paramEntity.attackEntityFrom(DamageHelper.cryotheum, 10.0F);
+        } else {
+            final boolean bool = paramEntity.velocityChanged;
+            paramEntity.attackEntityFrom(DamageHelper.cryotheum, 2.0F);
+            paramEntity.velocityChanged = bool;
+        }
+    }
+
+    @Override
+    public int getLightValue(final IBlockAccess paramIBlockAccess, final int paramInt1, final int paramInt2,
+        final int paramInt3) {
+        return TF_Fluids.fluidCryotheum.getLuminosity();
+    }
+
+    @Override
+    public void updateTick(final World paramWorld, final int paramInt1, final int paramInt2, final int paramInt3,
+        final Random paramRandom) {
+        if (effect) {
+            this.checkForInteraction(paramWorld, paramInt1, paramInt2, paramInt3);
+        }
+        if ((enableSourceFall) && (paramWorld.getBlockMetadata(paramInt1, paramInt2, paramInt3) == 0)) {
+            final Block localBlock = paramWorld.getBlock(paramInt1, paramInt2 + this.densityDir, paramInt3);
+            final int i = paramWorld.getBlockMetadata(paramInt1, paramInt2 + this.densityDir, paramInt3);
+            if ((localBlock == this) && (i != 0)) {
+                paramWorld.setBlock(paramInt1, paramInt2 + this.densityDir, paramInt3, this, 0, 3);
+                paramWorld.setBlockToAir(paramInt1, paramInt2, paramInt3);
+                return;
+            }
+        }
+        super.updateTick(paramWorld, paramInt1, paramInt2, paramInt3, paramRandom);
+    }
+
+    protected void checkForInteraction(final World paramWorld, final int paramInt1, final int paramInt2,
+        final int paramInt3) {
+        if (paramWorld.getBlock(paramInt1, paramInt2, paramInt3) != this) {
+            return;
+        }
+        int i = paramInt1;
+        int j = paramInt2;
+        int k = paramInt3;
+        for (int m = 0; m < 6; m++) {
+            i = paramInt1 + cofh.lib.util.helpers.BlockHelper.SIDE_COORD_MOD[m][0];
+            j = paramInt2 + cofh.lib.util.helpers.BlockHelper.SIDE_COORD_MOD[m][1];
+            k = paramInt3 + cofh.lib.util.helpers.BlockHelper.SIDE_COORD_MOD[m][2];
+
+            this.interactWithBlock(paramWorld, i, j, k);
+        }
+        this.interactWithBlock(paramWorld, paramInt1 - 1, paramInt2, paramInt3 - 1);
+        this.interactWithBlock(paramWorld, paramInt1 - 1, paramInt2, paramInt3 + 1);
+        this.interactWithBlock(paramWorld, paramInt1 + 1, paramInt2, paramInt3 - 1);
+        this.interactWithBlock(paramWorld, paramInt1 + 1, paramInt2, paramInt3 + 1);
+    }
+
+    protected void interactWithBlock(final World paramWorld, final int paramInt1, final int paramInt2,
+        final int paramInt3) {
+        final Block localBlock = paramWorld.getBlock(paramInt1, paramInt2, paramInt3);
+        if ((localBlock == Blocks.air) || (localBlock == this)) {
+            return;
+        }
+        final int i = paramWorld.getBlockMetadata(paramInt1, paramInt2, paramInt3);
+        if (this.hasInteraction(localBlock, i)) {
+            final BlockWrapper localBlockWrapper = this.getInteraction(localBlock, i);
+            paramWorld
+                .setBlock(paramInt1, paramInt2, paramInt3, localBlockWrapper.block, localBlockWrapper.metadata, 3);
+        } else if ((paramWorld.isSideSolid(paramInt1, paramInt2, paramInt3, ForgeDirection.UP))
+            && (paramWorld.isAirBlock(paramInt1, paramInt2 + 1, paramInt3))) {
+                paramWorld.setBlock(paramInt1, paramInt2 + 1, paramInt3, Blocks.snow_layer, 0, 3);
+            }
+    }
+
+}
diff --git a/src/main/java/gtPlusPlus/xmod/thermalfoundation/block/TF_Block_Fluid_Ender.java b/src/main/java/gtPlusPlus/xmod/thermalfoundation/block/TF_Block_Fluid_Ender.java
new file mode 100644
index 0000000000..9f89d01250
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/thermalfoundation/block/TF_Block_Fluid_Ender.java
@@ -0,0 +1,61 @@
+package gtPlusPlus.xmod.thermalfoundation.block;
+
+import static gregtech.api.enums.Mods.GTPlusPlus;
+
+import net.minecraft.block.material.MapColor;
+import net.minecraft.block.material.Material;
+import net.minecraft.block.material.MaterialLiquid;
+import net.minecraft.entity.Entity;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+
+import cofh.core.fluid.BlockFluidCoFHBase;
+import cofh.core.util.CoreUtils;
+import cpw.mods.fml.common.registry.GameRegistry;
+import gtPlusPlus.xmod.thermalfoundation.fluid.TF_Fluids;
+
+public class TF_Block_Fluid_Ender extends BlockFluidCoFHBase {
+
+    public static final Material materialFluidEnder = new MaterialLiquid(MapColor.greenColor);
+    private static boolean effect = true;
+
+    public TF_Block_Fluid_Ender() {
+        super(GTPlusPlus.ID, TF_Fluids.fluidEnder, materialFluidEnder, "ender");
+        setQuantaPerBlock(4);
+        setTickRate(20);
+
+        setHardness(2000.0F);
+        setLightOpacity(7);
+        setParticleColor(0.05F, 0.2F, 0.2F);
+    }
+
+    @Override
+    public boolean preInit() {
+        GameRegistry.registerBlock(this, "FluidEnder");
+
+        return true;
+    }
+
+    @Override
+    public void onEntityCollidedWithBlock(World paramWorld, int paramInt1, int paramInt2, int paramInt3,
+        Entity paramEntity) {
+        if ((!effect) || (paramWorld.isRemote)) {
+            return;
+        }
+        if (paramWorld.getTotalWorldTime() % 8L == 0L) {
+            int i = paramInt1 - 8 + paramWorld.rand.nextInt(17);
+            int j = paramInt2 + paramWorld.rand.nextInt(8);
+            int k = paramInt3 - 8 + paramWorld.rand.nextInt(17);
+            if (!paramWorld.getBlock(i, j, k)
+                .getMaterial()
+                .isSolid()) {
+                CoreUtils.teleportEntityTo(paramEntity, i, j, k);
+            }
+        }
+    }
+
+    @Override
+    public int getLightValue(IBlockAccess paramIBlockAccess, int paramInt1, int paramInt2, int paramInt3) {
+        return TF_Fluids.fluidEnder.getLuminosity();
+    }
+}
diff --git a/src/main/java/gtPlusPlus/xmod/thermalfoundation/block/TF_Block_Fluid_Pyrotheum.java b/src/main/java/gtPlusPlus/xmod/thermalfoundation/block/TF_Block_Fluid_Pyrotheum.java
new file mode 100644
index 0000000000..90c8be8bf7
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/thermalfoundation/block/TF_Block_Fluid_Pyrotheum.java
@@ -0,0 +1,192 @@
+package gtPlusPlus.xmod.thermalfoundation.block;
+
+import static gregtech.api.enums.Mods.GTPlusPlus;
+
+import java.util.Random;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.monster.EntityCreeper;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import cofh.core.fluid.BlockFluidInteractive;
+import cofh.lib.util.BlockWrapper;
+import cofh.lib.util.helpers.ServerHelper;
+import cpw.mods.fml.common.registry.GameRegistry;
+import gtPlusPlus.xmod.thermalfoundation.fluid.TF_Fluids;
+
+public class TF_Block_Fluid_Pyrotheum extends BlockFluidInteractive {
+
+    Random random = new Random();
+    private static boolean effect = true;
+    private static boolean enableSourceFall = true;
+
+    public TF_Block_Fluid_Pyrotheum() {
+        super(GTPlusPlus.ID, TF_Fluids.fluidPyrotheum, Material.lava, "pyrotheum");
+        this.setQuantaPerBlock(5);
+        this.setTickRate(10);
+
+        this.setHardness(1000.0F);
+        this.setLightOpacity(1);
+        this.setParticleColor(1.0F, 0.7F, 0.15F);
+    }
+
+    @Override
+    public boolean preInit() {
+        GameRegistry.registerBlock(this, "FluidPyrotheum");
+
+        this.addInteraction(Blocks.cobblestone, Blocks.stone);
+        this.addInteraction(Blocks.grass, Blocks.dirt);
+        this.addInteraction(Blocks.sand, Blocks.glass);
+        this.addInteraction(Blocks.water, Blocks.stone);
+        this.addInteraction(Blocks.flowing_water, Blocks.stone);
+        this.addInteraction(Blocks.clay, Blocks.hardened_clay);
+        this.addInteraction(Blocks.ice, Blocks.stone);
+        this.addInteraction(Blocks.snow, Blocks.air);
+        this.addInteraction(Blocks.snow_layer, Blocks.air);
+        for (int i = 0; i < 8; i++) {
+            this.addInteraction(Blocks.stone_stairs, i, Blocks.stone_brick_stairs, i);
+        }
+        final String str1 = "Fluid.Pyrotheum";
+        String str2 = "Enable this for Fluid Pyrotheum to be worse than lava.";
+        effect = true;
+
+        str2 = "Enable this for Fluid Pyrotheum Source blocks to gradually fall downwards.";
+        enableSourceFall = true;
+
+        return true;
+    }
+
+    @Override
+    public void onEntityCollidedWithBlock(final World paramWorld, final int paramInt1, final int paramInt2,
+        final int paramInt3, final Entity paramEntity) {
+        if (!effect) {
+            return;
+        }
+        if (ServerHelper.isClientWorld(paramWorld)) {
+            return;
+        }
+        if (!(paramEntity instanceof EntityPlayer)) {
+            if ((paramEntity instanceof EntityCreeper)) {
+                paramWorld.createExplosion(
+                    paramEntity,
+                    paramEntity.posX,
+                    paramEntity.posY,
+                    paramEntity.posZ,
+                    6.0F,
+                    paramEntity.worldObj.getGameRules()
+                        .getGameRuleBooleanValue("mobGriefing"));
+                paramEntity.setDead();
+            }
+        }
+    }
+
+    @Override
+    public int getLightValue(final IBlockAccess paramIBlockAccess, final int paramInt1, final int paramInt2,
+        final int paramInt3) {
+        return TF_Fluids.fluidPyrotheum.getLuminosity();
+    }
+
+    @Override
+    public int getFireSpreadSpeed(final IBlockAccess paramIBlockAccess, final int paramInt1, final int paramInt2,
+        final int paramInt3, final ForgeDirection paramForgeDirection) {
+        return effect ? 800 : 0;
+    }
+
+    @Override
+    public int getFlammability(final IBlockAccess paramIBlockAccess, final int paramInt1, final int paramInt2,
+        final int paramInt3, final ForgeDirection paramForgeDirection) {
+        return 0;
+    }
+
+    @Override
+    public boolean isFlammable(final IBlockAccess paramIBlockAccess, final int paramInt1, final int paramInt2,
+        final int paramInt3, final ForgeDirection paramForgeDirection) {
+        return (effect) && (paramForgeDirection.ordinal() > ForgeDirection.UP.ordinal())
+            && (paramIBlockAccess.getBlock(paramInt1, paramInt2 - 1, paramInt3) != this);
+    }
+
+    @Override
+    public boolean isFireSource(final World paramWorld, final int paramInt1, final int paramInt2, final int paramInt3,
+        final ForgeDirection paramForgeDirection) {
+        return effect;
+    }
+
+    @Override
+    public void updateTick(final World paramWorld, final int paramInt1, final int paramInt2, final int paramInt3,
+        final Random paramRandom) {
+        if (effect) {
+            this.checkForInteraction(paramWorld, paramInt1, paramInt2, paramInt3);
+        }
+        if ((enableSourceFall) && (paramWorld.getBlockMetadata(paramInt1, paramInt2, paramInt3) == 0)) {
+            final Block localBlock = paramWorld.getBlock(paramInt1, paramInt2 + this.densityDir, paramInt3);
+            final int i = paramWorld.getBlockMetadata(paramInt1, paramInt2 + this.densityDir, paramInt3);
+            if (((localBlock == this) && (i != 0)) || (localBlock
+                .isFlammable(paramWorld, paramInt1, paramInt2 + this.densityDir, paramInt3, ForgeDirection.UP))) {
+                paramWorld.setBlock(paramInt1, paramInt2 + this.densityDir, paramInt3, this, 0, 3);
+                paramWorld.setBlockToAir(paramInt1, paramInt2, paramInt3);
+                return;
+            }
+        }
+        super.updateTick(paramWorld, paramInt1, paramInt2, paramInt3, paramRandom);
+    }
+
+    protected void checkForInteraction(final World paramWorld, final int paramInt1, final int paramInt2,
+        final int paramInt3) {
+        if (paramWorld.getBlock(paramInt1, paramInt2, paramInt3) != this) {
+            return;
+        }
+        int i = paramInt1;
+        int j = paramInt2;
+        int k = paramInt3;
+        for (int m = 0; m < 6; m++) {
+            i = paramInt1 + cofh.lib.util.helpers.BlockHelper.SIDE_COORD_MOD[m][0];
+            j = paramInt2 + cofh.lib.util.helpers.BlockHelper.SIDE_COORD_MOD[m][1];
+            k = paramInt3 + cofh.lib.util.helpers.BlockHelper.SIDE_COORD_MOD[m][2];
+
+            this.interactWithBlock(paramWorld, i, j, k);
+        }
+        this.interactWithBlock(paramWorld, paramInt1 - 1, paramInt2, paramInt3 - 1);
+        this.interactWithBlock(paramWorld, paramInt1 - 1, paramInt2, paramInt3 + 1);
+        this.interactWithBlock(paramWorld, paramInt1 + 1, paramInt2, paramInt3 - 1);
+        this.interactWithBlock(paramWorld, paramInt1 + 1, paramInt2, paramInt3 + 1);
+    }
+
+    protected void interactWithBlock(final World paramWorld, final int paramInt1, final int paramInt2,
+        final int paramInt3) {
+        final Block localBlock = paramWorld.getBlock(paramInt1, paramInt2, paramInt3);
+        if ((localBlock == Blocks.air) || (localBlock == this)) {
+            return;
+        }
+        final int i = paramWorld.getBlockMetadata(paramInt1, paramInt2, paramInt3);
+        if (this.hasInteraction(localBlock, i)) {
+            final BlockWrapper localBlockWrapper = this.getInteraction(localBlock, i);
+            paramWorld
+                .setBlock(paramInt1, paramInt2, paramInt3, localBlockWrapper.block, localBlockWrapper.metadata, 3);
+            this.triggerInteractionEffects(paramWorld, paramInt1, paramInt2, paramInt3);
+        } else if (localBlock.isFlammable(paramWorld, paramInt1, paramInt2, paramInt3, ForgeDirection.UP)) {
+            paramWorld.setBlock(paramInt1, paramInt2, paramInt3, Blocks.fire);
+        } else if ((paramWorld.isSideSolid(paramInt1, paramInt2, paramInt3, ForgeDirection.UP))
+            && (paramWorld.isAirBlock(paramInt1, paramInt2 + 1, paramInt3))) {
+                paramWorld.setBlock(paramInt1, paramInt2 + 1, paramInt3, Blocks.fire, 0, 3);
+            }
+    }
+
+    protected void triggerInteractionEffects(final World paramWorld, final int paramInt1, final int paramInt2,
+        final int paramInt3) {
+        if (this.random.nextInt(16) == 0) {
+            paramWorld.playSoundEffect(
+                paramInt1 + 0.5F,
+                paramInt2 + 0.5F,
+                paramInt3 + 0.5F,
+                "random.fizz",
+                0.5F,
+                2.2F + ((paramWorld.rand.nextFloat() - paramWorld.rand.nextFloat()) * 0.8F));
+        }
+    }
+}
diff --git a/src/main/java/gtPlusPlus/xmod/thermalfoundation/block/TF_Blocks.java b/src/main/java/gtPlusPlus/xmod/thermalfoundation/block/TF_Blocks.java
new file mode 100644
index 0000000000..38fed4c137
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/thermalfoundation/block/TF_Blocks.java
@@ -0,0 +1,23 @@
+package gtPlusPlus.xmod.thermalfoundation.block;
+
+import cofh.core.fluid.BlockFluidCoFHBase;
+
+public class TF_Blocks {
+
+    public static BlockFluidCoFHBase blockFluidPyrotheum;
+    public static BlockFluidCoFHBase blockFluidCryotheum;
+    public static BlockFluidCoFHBase blockFluidEnder;
+
+    public static void preInit() {
+        blockFluidPyrotheum = new TF_Block_Fluid_Pyrotheum();
+        blockFluidCryotheum = new TF_Block_Fluid_Cryotheum();
+        blockFluidEnder = new TF_Block_Fluid_Ender();
+        blockFluidPyrotheum.preInit();
+        blockFluidCryotheum.preInit();
+        blockFluidEnder.preInit();
+    }
+
+    public static void init() {}
+
+    public static void postInit() {}
+}
diff --git a/src/main/java/gtPlusPlus/xmod/thermalfoundation/fluid/TF_Fluids.java b/src/main/java/gtPlusPlus/xmod/thermalfoundation/fluid/TF_Fluids.java
new file mode 100644
index 0000000000..27a0c8e080
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/thermalfoundation/fluid/TF_Fluids.java
@@ -0,0 +1,69 @@
+package gtPlusPlus.xmod.thermalfoundation.fluid;
+
+import net.minecraft.item.EnumRarity;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidRegistry;
+
+import gtPlusPlus.api.objects.Logger;
+
+public class TF_Fluids {
+
+    public static Fluid fluidPyrotheum;
+    public static Fluid fluidCryotheum;
+    public static Fluid fluidEnder;
+
+    public static void preInit() {
+        Logger.INFO("Adding in our own versions of Thermal Foundation Fluids - Non-GT");
+        final Fluid pyrotheum = FluidRegistry.getFluid("pyrotheum");
+        final Fluid cryotheum = FluidRegistry.getFluid("cryotheum");
+        final Fluid ender = FluidRegistry.getFluid("ender");
+
+        if (pyrotheum == null) {
+            Logger.INFO("Registering Blazing Pyrotheum as it does not exist.");
+            fluidPyrotheum = new Fluid("pyrotheum").setLuminosity(15)
+                .setDensity(2000)
+                .setViscosity(1200)
+                .setTemperature(4000)
+                .setRarity(EnumRarity.rare);
+            registerFluid(fluidPyrotheum, "pyrotheum");
+        } else {
+            Logger.INFO("Registering Blazing Pyrotheum as it is an already existing Fluid.");
+            fluidPyrotheum = pyrotheum;
+        }
+        if (cryotheum == null) {
+            Logger.INFO("Registering Gelid Cryotheum as it does not exist.");
+            fluidCryotheum = new Fluid("cryotheum").setLuminosity(0)
+                .setDensity(4000)
+                .setViscosity(3000)
+                .setTemperature(50)
+                .setRarity(EnumRarity.rare);
+            registerFluid(fluidCryotheum, "cryotheum");
+        } else {
+            Logger.INFO("Registering Gelid Cryotheum as it is an already existing Fluid.");
+            fluidCryotheum = cryotheum;
+        }
+
+        if (ender == null) {
+            Logger.INFO("Registering Resonant Ender as it does not exist.");
+            fluidEnder = new Fluid("ender").setLuminosity(3)
+                .setDensity(4000)
+                .setViscosity(3000)
+                .setTemperature(300)
+                .setRarity(EnumRarity.uncommon);
+            registerFluid(fluidEnder, "ender");
+        } else {
+            Logger.INFO("Registering Resonant Ender as it is an already existing Fluid.");
+            fluidEnder = ender;
+        }
+    }
+
+    public static void init() {}
+
+    public static void postInit() {}
+
+    public static void registerFluid(final Fluid paramFluid, final String paramString) {
+        if (!FluidRegistry.isFluidRegistered(paramString)) {
+            FluidRegistry.registerFluid(paramFluid);
+        }
+    }
+}
diff --git a/src/main/java/gtPlusPlus/xmod/thermalfoundation/item/TF_Items.java b/src/main/java/gtPlusPlus/xmod/thermalfoundation/item/TF_Items.java
new file mode 100644
index 0000000000..d2ea7ea2d1
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/thermalfoundation/item/TF_Items.java
@@ -0,0 +1,75 @@
+package gtPlusPlus.xmod.thermalfoundation.item;
+
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.FluidContainerRegistry;
+
+import cofh.core.item.ItemBase;
+import cofh.core.item.ItemBucket;
+import cofh.core.util.energy.FurnaceFuelHandler;
+import cofh.core.util.fluid.BucketHandler;
+import gtPlusPlus.core.creative.AddToCreativeTab;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+import gtPlusPlus.core.util.reflect.ReflectionUtils;
+import gtPlusPlus.xmod.thermalfoundation.block.TF_Blocks;
+import gtPlusPlus.xmod.thermalfoundation.fluid.TF_Fluids;
+
+public class TF_Items {
+
+    public static ItemBase itemMaterial;
+    public static ItemStack rodBlizz;
+    public static ItemStack dustBlizz;
+    public static ItemStack dustPyrotheum;
+    public static ItemStack dustCryotheum;
+    public static ItemBucket itemBucket;
+    public static ItemStack bucketPyrotheum;
+    public static ItemStack bucketCryotheum;
+    public static ItemStack bucketEnder;
+
+    public static ItemStack itemDustBlizz;
+    public static ItemStack itemDustPyrotheum;
+    public static ItemStack itemDustCryotheum;
+    public static ItemStack itemRodBlizz;
+
+    public static void preInit() {
+
+        itemBucket = (ItemBucket) new ItemBucket("MiscUtils").setUnlocalizedName("bucket")
+            .setCreativeTab(AddToCreativeTab.tabMisc);
+        itemMaterial = (ItemBase) new ItemBase("MiscUtils").setUnlocalizedName("material")
+            .setCreativeTab(AddToCreativeTab.tabMisc);
+
+        bucketPyrotheum = itemBucket.addOreDictItem(1, "bucketPyrotheum");
+        bucketCryotheum = itemBucket.addOreDictItem(2, "bucketCryotheum");
+        bucketEnder = itemBucket.addOreDictItem(3, "bucketEnder", 1);
+        rodBlizz = itemMaterial.addOreDictItem(1, "rodBlizz");
+        dustBlizz = itemMaterial.addOreDictItem(2, "dustBlizz");
+        dustPyrotheum = itemMaterial.addOreDictItem(3, "dustPyrotheum");
+        dustCryotheum = itemMaterial.addOreDictItem(4, "dustCryotheum");
+
+        if (ReflectionUtils.doesClassExist("cofh.core.util.energy.FurnaceFuelHandler")) {
+            FurnaceFuelHandler.registerFuel(dustPyrotheum, 2400); // cofh.core.util.energy.FurnaceFuelHandler.registerFuel(ItemStack,
+                                                                  // int)
+        }
+
+        ItemUtils.addItemToOreDictionary(rodBlizz, "stickBlizz");
+
+        itemRodBlizz = ItemUtils.simpleMetaStack(itemMaterial, 1, 1);
+        itemDustBlizz = ItemUtils.simpleMetaStack(itemMaterial, 2, 1);
+        itemDustPyrotheum = ItemUtils.simpleMetaStack(itemMaterial, 3, 1);
+        itemDustCryotheum = ItemUtils.simpleMetaStack(itemMaterial, 4, 1);
+    }
+
+    public static void init() {
+
+        BucketHandler.registerBucket(TF_Blocks.blockFluidPyrotheum, 0, bucketPyrotheum);
+        BucketHandler.registerBucket(TF_Blocks.blockFluidCryotheum, 0, bucketCryotheum);
+        BucketHandler.registerBucket(TF_Blocks.blockFluidEnder, 0, bucketEnder);
+        FluidContainerRegistry
+            .registerFluidContainer(TF_Fluids.fluidPyrotheum, bucketPyrotheum, FluidContainerRegistry.EMPTY_BUCKET);
+        FluidContainerRegistry
+            .registerFluidContainer(TF_Fluids.fluidCryotheum, bucketCryotheum, FluidContainerRegistry.EMPTY_BUCKET);
+        FluidContainerRegistry
+            .registerFluidContainer(TF_Fluids.fluidEnder, bucketEnder, FluidContainerRegistry.EMPTY_BUCKET);
+    }
+
+    public static void postInit() {}
+}
diff --git a/src/main/java/gtPlusPlus/xmod/thermalfoundation/recipe/TF_Gregtech_Recipes.java b/src/main/java/gtPlusPlus/xmod/thermalfoundation/recipe/TF_Gregtech_Recipes.java
new file mode 100644
index 0000000000..cd48964d37
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/thermalfoundation/recipe/TF_Gregtech_Recipes.java
@@ -0,0 +1,93 @@
+package gtPlusPlus.xmod.thermalfoundation.recipe;
+
+import static gregtech.api.recipe.RecipeMaps.chemicalBathRecipes;
+import static gregtech.api.recipe.RecipeMaps.mixerRecipes;
+import static gregtech.api.recipe.RecipeMaps.vacuumFreezerRecipes;
+import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
+import static gregtech.api.util.GT_RecipeBuilder.TICKS;
+
+import net.minecraft.init.Items;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.FluidStack;
+
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.enums.TierEU;
+import gregtech.api.util.GT_OreDictUnificator;
+import gtPlusPlus.core.util.minecraft.FluidUtils;
+
+public class TF_Gregtech_Recipes {
+
+    public static void run() {
+        start();
+    }
+
+    private static void start() {
+
+        final FluidStack moltenBlaze = getFluidStack("molten.blaze", 1440);
+
+        // Gelid Cryotheum
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_OreDictUnificator.get(OrePrefixes.ore, Materials.Cinnabar, 1L))
+            .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Cinnabar, 3L))
+            .fluidInputs(getFluidStack("cryotheum", 144))
+            .duration(20 * SECONDS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(chemicalBathRecipes);
+
+        // Blizz Powder
+        GT_Values.RA.stdBuilder()
+            .itemInputs(new ItemStack(Items.snowball, 4))
+            .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Blizz, 1L))
+            .fluidInputs(moltenBlaze)
+            .duration(20 * SECONDS)
+            .eut(TierEU.RECIPE_HV / 2)
+            .addTo(chemicalBathRecipes);
+
+        // Blizz Rod
+        GT_Values.RA.stdBuilder()
+            .itemInputs(new ItemStack(Items.blaze_rod))
+            .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.stick, Materials.Blizz, 1L))
+            .duration(((int) Math.max((Materials.Blaze.getMass() * 4) * 3L, 1L)) * TICKS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(vacuumFreezerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Coal, 1L),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Sulfur, 1L),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Redstone, 1L),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Blaze, 1L))
+            .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Pyrotheum, 1L))
+            .duration(8 * SECONDS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(mixerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Saltpeter, 1L),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Snow, 1L),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Redstone, 1L),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Blizz, 1L))
+            .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Cryotheum, 1L))
+            .duration(8 * SECONDS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(mixerRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Niter, 1L),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Snow, 1L),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Redstone, 1L),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Blizz, 1L))
+            .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Cryotheum, 1L))
+            .duration(8 * SECONDS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(mixerRecipes);
+    }
+
+    private static FluidStack getFluidStack(final String fluidName, final int amount) {
+        return FluidUtils.getFluidStack(fluidName, amount);
+    }
+}