Move GoodGen sources

10 files changed, 2443 insertions, 0 deletions

diff --git a/src/main/java/goodgenerator/items/DepletedFuelRod.java b/src/main/java/goodgenerator/items/DepletedFuelRod.java
new file mode 100644
index 0000000000..308f149933
--- /dev/null
+++ b/src/main/java/goodgenerator/items/DepletedFuelRod.java
@@ -0,0 +1,54 @@
+package goodgenerator.items;
+
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.item.ItemStack;
+
+import ic2.api.item.IBoxable;
+import ic2.api.reactor.IReactor;
+import ic2.api.reactor.IReactorComponent;
+
+public class DepletedFuelRod extends RadioactiveItem implements IReactorComponent, IBoxable {
+
+    public DepletedFuelRod(String name, String[] tooltip, CreativeTabs Tab, int Rad) {
+        super(name, tooltip, Tab, Rad);
+    }
+
+    @Override
+    public boolean canBeStoredInToolbox(ItemStack itemStack) {
+        return true;
+    }
+
+    @Override
+    public void processChamber(IReactor iReactor, ItemStack itemStack, int i, int i1, boolean b) {}
+
+    @Override
+    public boolean acceptUraniumPulse(IReactor iReactor, ItemStack itemStack, ItemStack itemStack1, int i, int i1,
+        int i2, int i3, boolean b) {
+        return false;
+    }
+
+    @Override
+    public boolean canStoreHeat(IReactor iReactor, ItemStack itemStack, int i, int i1) {
+        return false;
+    }
+
+    @Override
+    public int getMaxHeat(IReactor iReactor, ItemStack itemStack, int i, int i1) {
+        return 0;
+    }
+
+    @Override
+    public int getCurrentHeat(IReactor iReactor, ItemStack itemStack, int i, int i1) {
+        return 0;
+    }
+
+    @Override
+    public int alterHeat(IReactor iReactor, ItemStack itemStack, int i, int i1, int i2) {
+        return 0;
+    }
+
+    @Override
+    public float influenceExplosion(IReactor iReactor, ItemStack itemStack) {
+        return 0;
+    }
+}
diff --git a/src/main/java/goodgenerator/items/FuelRod.java b/src/main/java/goodgenerator/items/FuelRod.java
new file mode 100644
index 0000000000..00ca8b3491
--- /dev/null
+++ b/src/main/java/goodgenerator/items/FuelRod.java
@@ -0,0 +1,215 @@
+package goodgenerator.items;
+
+import static goodgenerator.util.DescTextLocalization.addText;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.StatCollector;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import gregtech.api.util.GT_Utility;
+import ic2.api.item.IBoxable;
+import ic2.api.reactor.IReactor;
+import ic2.api.reactor.IReactorComponent;
+import ic2.core.util.StackUtil;
+import ic2.core.util.Util;
+
+public class FuelRod extends RadioactiveItem implements IReactorComponent, IBoxable {
+
+    private final int numberOfCells;
+    private final int maxDmg;
+    private final float Power;
+    private final int Heat;
+    private float HeatBonus = 0;
+    private final ItemStack result;
+
+    public FuelRod(String aName, int aCells, int aEUt, int aHeat, int aRads, int aDuration, ItemStack aResult,
+        CreativeTabs Tab) {
+        super(aName, Tab, aRads);
+        this.setMaxStackSize(64);
+        this.numberOfCells = aCells;
+        this.maxDmg = aDuration;
+        this.Power = (float) aEUt / 25.0F;
+        this.result = aResult;
+        this.Heat = aHeat;
+        setMaxDamage(100);
+    }
+
+    public FuelRod(String aName, int aCells, int aEUt, int aHeat, int aRads, int aDuration, float aHeatBonus,
+        ItemStack aResult, CreativeTabs Tab) {
+        super(aName, Tab, aRads);
+        this.setMaxStackSize(64);
+        this.numberOfCells = aCells;
+        this.maxDmg = aDuration;
+        this.Power = (float) aEUt / 25.0F;
+        this.result = aResult;
+        this.Heat = aHeat;
+        this.HeatBonus = aHeatBonus;
+        setMaxDamage(100);
+    }
+
+    public void processChamber(IReactor reactor, ItemStack stack, int x, int y, boolean heatRun) {
+        if (reactor.produceEnergy()) {
+            for (int iteration = 0; iteration < this.numberOfCells; ++iteration) {
+                int pulses = 1 + this.numberOfCells / 2;
+                int heat;
+                if (!heatRun) {
+                    for (heat = 0; heat < pulses; ++heat) {
+                        this.acceptUraniumPulse(reactor, stack, stack, x, y, x, y, heatRun);
+                    }
+                    checkPulseable(reactor, x - 1, y, stack, x, y, heatRun);
+                    checkPulseable(reactor, x + 1, y, stack, x, y, heatRun);
+                    checkPulseable(reactor, x, y - 1, stack, x, y, heatRun);
+                    checkPulseable(reactor, x, y + 1, stack, x, y, heatRun);
+                } else {
+                    pulses += checkPulseable(reactor, x - 1, y, stack, x, y, heatRun)
+                        + checkPulseable(reactor, x + 1, y, stack, x, y, heatRun)
+                        + checkPulseable(reactor, x, y - 1, stack, x, y, heatRun)
+                        + checkPulseable(reactor, x, y + 1, stack, x, y, heatRun);
+                    heat = sumUp(pulses) * this.Heat;
+                    ArrayList<FuelRod.ItemStackCoord> heatAcceptors = new ArrayList<>();
+                    this.checkHeatAcceptor(reactor, x - 1, y, heatAcceptors);
+                    this.checkHeatAcceptor(reactor, x + 1, y, heatAcceptors);
+                    this.checkHeatAcceptor(reactor, x, y - 1, heatAcceptors);
+                    this.checkHeatAcceptor(reactor, x, y + 1, heatAcceptors);
+
+                    while (heatAcceptors.size() > 0 && heat > 0) {
+                        int dheat = heat / heatAcceptors.size();
+                        heat -= dheat;
+                        dheat = ((IReactorComponent) heatAcceptors.get(0).stack.getItem()).alterHeat(
+                            reactor,
+                            heatAcceptors.get(0).stack,
+                            heatAcceptors.get(0).x,
+                            heatAcceptors.get(0).y,
+                            dheat);
+                        heat += dheat;
+                        heatAcceptors.remove(0);
+                    }
+
+                    if (heat > 0) {
+                        reactor.addHeat(heat);
+                    }
+                }
+            }
+            if (this.getCustomDamage(stack) >= this.getMaxCustomDamage(stack) - 1) {
+                reactor.setItemAt(x, y, GT_Utility.copyAmount(1, result));
+            } else if (heatRun) {
+                this.applyCustomDamage(stack, 1, null);
+            }
+        }
+    }
+
+    private static int checkPulseable(IReactor reactor, int x, int y, ItemStack me, int mex, int mey, boolean heatrun) {
+        ItemStack other = reactor.getItemAt(x, y);
+        return other != null && other.getItem() instanceof IReactorComponent
+            && ((IReactorComponent) other.getItem()).acceptUraniumPulse(reactor, other, me, x, y, mex, mey, heatrun) ? 1
+                : 0;
+    }
+
+    private static int sumUp(int x) {
+        return (x * x + x) / 2;
+    }
+
+    private void checkHeatAcceptor(IReactor reactor, int x, int y, ArrayList<FuelRod.ItemStackCoord> heatAcceptors) {
+        ItemStack thing = reactor.getItemAt(x, y);
+        if (thing != null && thing.getItem() instanceof IReactorComponent
+            && ((IReactorComponent) thing.getItem()).canStoreHeat(reactor, thing, x, y)) {
+            heatAcceptors.add(new ItemStackCoord(thing, x, y));
+        }
+    }
+
+    public boolean acceptUraniumPulse(IReactor reactor, ItemStack yourStack, ItemStack pulsingStack, int youX, int youY,
+        int pulseX, int pulseY, boolean heatrun) {
+        if (!heatrun) {
+            reactor.addOutput(Power * (1 + HeatBonus * ((float) reactor.getHeat() / (float) reactor.getMaxHeat())));
+        }
+        return true;
+    }
+
+    public boolean canStoreHeat(IReactor reactor, ItemStack yourStack, int x, int y) {
+        return false;
+    }
+
+    public int getMaxHeat(IReactor reactor, ItemStack yourStack, int x, int y) {
+        return 0;
+    }
+
+    public int getCurrentHeat(IReactor reactor, ItemStack yourStack, int x, int y) {
+        return 0;
+    }
+
+    public int alterHeat(IReactor reactor, ItemStack yourStack, int x, int y, int heat) {
+        return heat;
+    }
+
+    public float influenceExplosion(IReactor reactor, ItemStack yourStack) {
+        return (float) (2 * this.numberOfCells);
+    }
+
+    @Override
+    public boolean canBeStoredInToolbox(ItemStack itemStack) {
+        return true;
+    }
+
+    private static class ItemStackCoord {
+
+        public ItemStack stack;
+        public int x;
+        public int y;
+
+        public ItemStackCoord(ItemStack stack1, int x1, int y1) {
+            this.stack = stack1;
+            this.x = x1;
+            this.y = y1;
+        }
+    }
+
+    public int getCustomDamage(ItemStack stack) {
+        NBTTagCompound nbt = StackUtil.getOrCreateNbtData(stack);
+        return nbt.getInteger("advDmg");
+    }
+
+    public int getMaxCustomDamage(ItemStack stack) {
+        return this.maxDmg;
+    }
+
+    public void setCustomDamage(ItemStack stack, int damage) {
+        NBTTagCompound nbt = StackUtil.getOrCreateNbtData(stack);
+        nbt.setInteger("advDmg", damage);
+        int maxStackDamage = stack.getMaxDamage();
+        if (maxStackDamage > 2) {
+            stack.setItemDamage(1 + (int) Util.map(damage, this.maxDmg, maxStackDamage - 2));
+        }
+    }
+
+    public boolean applyCustomDamage(ItemStack stack, int damage, EntityLivingBase src) {
+        this.setCustomDamage(stack, this.getCustomDamage(stack) + damage);
+        return true;
+    }
+
+    @SideOnly(Side.CLIENT)
+    @SuppressWarnings("unchecked")
+    @Override
+    public void addInformation(ItemStack item, EntityPlayer player, List tooltip, boolean p_77624_4_) {
+        super.addInformation(item, player, tooltip, p_77624_4_);
+        tooltip.add(
+            String.format(
+                addText("fuelrod.tooltip", 1)[0],
+                getMaxCustomDamage(item) - getCustomDamage(item),
+                getMaxCustomDamage(item)));
+        double tMut = this.Heat / 4.0;
+        if (this.Heat == 4) {
+            tooltip.add(StatCollector.translateToLocal("fuelrodheat.tooltip.0"));
+        } else {
+            tooltip.add(String.format(StatCollector.translateToLocal("fuelrodheat.tooltip.1"), tMut));
+        }
+        if (this.HeatBonus != 0) tooltip.add(StatCollector.translateToLocal("fuelrodheat.tooltip.2"));
+    }
+}
diff --git a/src/main/java/goodgenerator/items/MyItemBlocks.java b/src/main/java/goodgenerator/items/MyItemBlocks.java
new file mode 100644
index 0000000000..3ee7347e97
--- /dev/null
+++ b/src/main/java/goodgenerator/items/MyItemBlocks.java
@@ -0,0 +1,105 @@
+package goodgenerator.items;
+
+import static goodgenerator.loader.Loaders.essentiaCell;
+import static goodgenerator.loader.Loaders.yottaFluidTankCell;
+import static goodgenerator.util.CharExchanger.tierName;
+
+import java.util.Arrays;
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.StatCollector;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import goodgenerator.blocks.regularBlock.TEBlock;
+import goodgenerator.blocks.tileEntity.EssentiaOutputHatch;
+import goodgenerator.main.GoodGenerator;
+import goodgenerator.util.CharExchanger;
+import goodgenerator.util.DescTextLocalization;
+import gregtech.api.util.GT_LanguageManager;
+
+public class MyItemBlocks extends ItemBlock {
+
+    private final String mNoMobsToolTip = GT_LanguageManager
+        .addStringLocalization("gt.nomobspawnsonthisblock", "Mobs cannot Spawn on this Block");
+    private final String mNoTileEntityToolTip = GT_LanguageManager
+        .addStringLocalization("gt.notileentityinthisblock", "This is NOT a TileEntity!");
+
+    public MyItemBlocks(Block block) {
+        super(block);
+        this.setMaxDamage(0);
+        this.setHasSubtypes(true);
+        this.setCreativeTab(GoodGenerator.GG);
+    }
+
+    @Override
+    public int getMetadata(int aMeta) {
+        return aMeta;
+    }
+
+    @Override
+    public String getUnlocalizedName(ItemStack aStack) {
+        return this.field_150939_a.getUnlocalizedName() + "." + this.getDamage(aStack);
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public IIcon getIcon(ItemStack stack, int pass) {
+        return this.field_150939_a.getIcon(0, stack.getItemDamage());
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public IIcon getIcon(ItemStack stack, int renderPass, EntityPlayer player, ItemStack usingItem, int useRemaining) {
+        return this.getIcon(stack, renderPass);
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public IIcon getIconFromDamageForRenderPass(int p_77618_1_, int p_77618_2_) {
+        return this.field_150939_a.getIcon(0, p_77618_2_);
+    }
+
+    @Override
+    @SuppressWarnings({ "unchecked" })
+    @SideOnly(Side.CLIENT)
+    public void addInformation(ItemStack stack, EntityPlayer playerIn, List tooltip, boolean advanced) {
+        if (stack == null) return;
+        tooltip.add(mNoMobsToolTip);
+        if (Block.getBlockFromItem(stack.getItem()) instanceof TEBlock) {
+            TEBlock tile = (TEBlock) Block.getBlockFromItem(stack.getItem());
+            if (tile.getIndex() == 1)
+                tooltip.addAll(Arrays.asList(DescTextLocalization.addText("EssentiaHatch.tooltip", 2)));
+            if (tile.getIndex() == 2) {
+                tooltip.add(StatCollector.translateToLocal("EssentiaOutputHatch.tooltip.0"));
+                tooltip.add(
+                    StatCollector.translateToLocal("EssentiaOutputHatch.tooltip.1") + " "
+                        + EssentiaOutputHatch.CAPACITY);
+            }
+        } else {
+            tooltip.add(mNoTileEntityToolTip);
+        }
+
+        if (Block.getBlockFromItem(stack.getItem())
+            .equals(yottaFluidTankCell)) {
+            StringBuilder cap = new StringBuilder();
+            cap.append(" 1000000");
+            for (int i = 0; i < stack.getItemDamage(); i++) cap.append("00");
+            cap.append(" L");
+            tooltip.add(
+                StatCollector.translateToLocal("YOTTankCell.tooltip.0") + CharExchanger.formatNumber(cap.toString()));
+            tooltip.add(StatCollector.translateToLocal("YOTTankCell.tooltip.1"));
+        }
+
+        if (Block.getBlockFromItem(stack.getItem())
+            .equals(essentiaCell)) {
+            tooltip
+                .add(StatCollector.translateToLocal("hatchTier.tooltip.0") + " " + tierName[stack.getItemDamage() + 4]);
+        }
+    }
+}
diff --git a/src/main/java/goodgenerator/items/MyItems.java b/src/main/java/goodgenerator/items/MyItems.java
new file mode 100644
index 0000000000..71a67d4fd6
--- /dev/null
+++ b/src/main/java/goodgenerator/items/MyItems.java
@@ -0,0 +1,127 @@
+package goodgenerator.items;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.IIcon;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import goodgenerator.main.GoodGenerator;
+
+public class MyItems extends Item {
+
+    @SideOnly(Side.CLIENT)
+    protected IIcon[] texture;
+
+    private String tex;
+    private String[] textureNames;
+    private final String Name;
+    private List<String> tooltips = new ArrayList<>();
+    private List<String> tooltipses = new ArrayList<>();
+
+    public MyItems(String name, CreativeTabs Tab) {
+        this.setUnlocalizedName(name);
+        this.setCreativeTab(Tab);
+        this.tex = name;
+        this.Name = name;
+    }
+
+    public MyItems(String name, CreativeTabs Tab, String[] textures) {
+        this.setUnlocalizedName(name);
+        this.setCreativeTab(Tab);
+        this.setHasSubtypes(true);
+        this.textureNames = textures;
+        this.Name = name;
+    }
+
+    public MyItems(String name, String[] tooltip, CreativeTabs Tab, String[] textures) {
+        this.setUnlocalizedName(name);
+        this.setCreativeTab(Tab);
+        this.setHasSubtypes(true);
+        this.textureNames = textures;
+        this.Name = name;
+        this.tooltipses = Arrays.asList(tooltip);
+    }
+
+    public MyItems(String name, String tooltip, CreativeTabs Tab) {
+        this.setUnlocalizedName(name);
+        this.setCreativeTab(Tab);
+        this.tex = name;
+        this.tooltips.add(tooltip);
+        this.Name = name;
+    }
+
+    public MyItems(String name, String[] tooltip, CreativeTabs Tab) {
+        this.setUnlocalizedName(name);
+        this.setCreativeTab(Tab);
+        this.tex = name;
+        this.tooltips = Arrays.asList(tooltip);
+        this.Name = name;
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public IIcon getIconFromDamage(int meta) {
+        if (this.texture == null || this.texture.length < 1) return this.itemIcon;
+        else return meta < this.texture.length ? this.texture[meta] : this.texture[0];
+    }
+
+    @Override
+    public int getMetadata(int aMeta) {
+        return aMeta;
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void registerIcons(IIconRegister iconRegister) {
+        if (this.textureNames == null || this.textureNames.length < 1) {
+            this.itemIcon = iconRegister.registerIcon(GoodGenerator.MOD_ID + ":" + this.tex);
+        } else {
+            this.texture = new IIcon[this.textureNames.length];
+            for (int i = 0; i < this.textureNames.length; ++i) {
+                this.texture[i] = iconRegister.registerIcon(this.textureNames[i]);
+            }
+        }
+    }
+
+    @Override
+    public String getUnlocalizedName(ItemStack p_77667_1_) {
+        if (this.textureNames == null || this.textureNames.length < 1) {
+            return "item." + this.Name;
+        } else {
+            return "item." + this.Name + "." + p_77667_1_.getItemDamage();
+        }
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    @SuppressWarnings("unchecked")
+    public void getSubItems(Item item, CreativeTabs tab, List list) {
+        if (this.texture == null || this.texture.length < 1) list.add(new ItemStack(item, 1, 0));
+        else {
+            for (int i = 0; i < this.texture.length; ++i) {
+                list.add(new ItemStack(item, 1, i));
+            }
+        }
+    }
+
+    @SideOnly(Side.CLIENT)
+    @SuppressWarnings({ "unchecked" })
+    public void addInformation(ItemStack p_77624_1_, EntityPlayer p_77624_2_, List p_77624_3_, boolean p_77624_4_) {
+        if (tooltips.size() > 0) {
+            p_77624_3_.addAll(tooltips);
+        }
+        if (tooltipses.size() > 0) {
+            int meta = p_77624_1_.getItemDamage();
+            if (tooltipses.size() - 1 < meta) meta = tooltipses.size() - 1;
+            p_77624_3_.add(tooltipses.get(meta));
+        }
+    }
+}
diff --git a/src/main/java/goodgenerator/items/MyMaterial.java b/src/main/java/goodgenerator/items/MyMaterial.java
new file mode 100644
index 0000000000..1e75167ef0
--- /dev/null
+++ b/src/main/java/goodgenerator/items/MyMaterial.java
@@ -0,0 +1,1524 @@
+package goodgenerator.items;
+
+import static com.github.bartimaeusnek.bartworks.util.BW_Util.subscriptNumbers;
+import static gregtech.api.enums.Materials.*;
+
+import com.github.bartimaeusnek.bartworks.system.material.Werkstoff;
+import com.github.bartimaeusnek.bartworks.system.material.WerkstoffLoader;
+import com.github.bartimaeusnek.bartworks.util.Pair;
+
+import goodgenerator.util.CharExchanger;
+import gregtech.api.enums.TextureSet;
+
+@SuppressWarnings({ "unchecked" })
+public class MyMaterial implements Runnable {
+
+    protected static final int OffsetID = 10001;
+
+    // Uranium Based Fuel Line
+    public static final Werkstoff graphiteUraniumMixture = new Werkstoff(
+        new short[] { 0x3a, 0x77, 0x3d },
+        "Graphite-Uranium Mixture",
+        subscriptNumbers("C3U"),
+        new Werkstoff.Stats(),
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addMixerRecipes()
+            .onlyDust(),
+        OffsetID,
+        TextureSet.SET_DULL,
+        new Pair<>(Graphite, 3),
+        new Pair<>(Uranium, 1));
+
+    public static final Werkstoff uraniumBasedLiquidFuel = new Werkstoff(
+        new short[] { 0x00, 0xff, 0x00 },
+        "Uranium Based Liquid Fuel",
+        subscriptNumbers("U36K8Qt4Rn"),
+        new Werkstoff.Stats().setRadioactive(true),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 1,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff uraniumBasedLiquidFuelExcited = new Werkstoff(
+        new short[] { 0x00, 0xff, 0x00 },
+        "Uranium Based Liquid Fuel (Excited State)",
+        subscriptNumbers("*(U36K8Qt4Rn)*"),
+        new Werkstoff.Stats().setRadioactive(true),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 2,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff uraniumBasedLiquidFuelDepleted = new Werkstoff(
+        new short[] { 0x6e, 0x8b, 0x3d },
+        "Uranium Based Liquid Fuel (Depleted)",
+        subscriptNumbers("Pb?Bi?Ba?Xe?"),
+        new Werkstoff.Stats().setToxic(true),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 3,
+        TextureSet.SET_FLUID);
+
+    // Thorium Based Fuel
+    public static final Werkstoff uraniumCarbideThoriumMixture = new Werkstoff(
+        new short[] { 0x16, 0x32, 0x07 },
+        "Uranium Carbide-Thorium Mixture",
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addMixerRecipes()
+            .onlyDust(),
+        OffsetID + 4,
+        TextureSet.SET_DULL,
+        new Pair<>(Thorium, 11),
+        new Pair<>(WerkstoffLoader.Thorium232, 1),
+        new Pair<>(Uranium235, 1),
+        new Pair<>(Carbon, 3));
+
+    public static final Werkstoff thoriumBasedLiquidFuel = new Werkstoff(
+        new short[] { 0x50, 0x32, 0x66 },
+        "Thorium Based Liquid Fuel",
+        subscriptNumbers("Th432Li4D2Hg"),
+        new Werkstoff.Stats().setRadioactive(true),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 5,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff thoriumBasedLiquidFuelExcited = new Werkstoff(
+        new short[] { 0x50, 0x32, 0x66 },
+        "Thorium Based Liquid Fuel (Excited State)",
+        subscriptNumbers("*(Th432Li4D2Hg)*"),
+        new Werkstoff.Stats().setRadioactive(true),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 6,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff thoriumBasedLiquidFuelDepleted = new Werkstoff(
+        new short[] { 0x7d, 0x6c, 0x8a },
+        "Thorium Based Liquid Fuel (Depleted)",
+        subscriptNumbers("Th?Pr?B?In?"),
+        new Werkstoff.Stats().setToxic(true),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 7,
+        TextureSet.SET_FLUID);
+
+    // Plutonium Based Fuel
+    public static final Werkstoff plutoniumOxideUraniumMixture = new Werkstoff(
+        new short[] { 0xd1, 0x1f, 0x4a },
+        "Plutonium Oxide-Uranium Mixture",
+        Werkstoff.Types.MIXTURE,
+        new Werkstoff.GenerationFeatures().disable()
+            .addMixerRecipes()
+            .onlyDust(),
+        OffsetID + 8,
+        TextureSet.SET_SHINY,
+        new Pair<>(Plutonium, 10),
+        new Pair<>(Oxygen, 12),
+        new Pair<>(Uranium, 2),
+        new Pair<>(Carbon, 8));
+
+    public static final Werkstoff plutoniumBasedLiquidFuel = new Werkstoff(
+        new short[] { 0xef, 0x15, 0x15 },
+        "Plutonium Based Liquid Fuel",
+        subscriptNumbers("Pu45Nt8Cs16Nq2"),
+        new Werkstoff.Stats().setRadioactive(true),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 9,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff plutoniumBasedLiquidFuelExcited = new Werkstoff(
+        new short[] { 0xef, 0x15, 0x15 },
+        "Plutonium Based Liquid Fuel (Excited State)",
+        subscriptNumbers("*(Pu45Nt8Cs16Nq2)*"),
+        new Werkstoff.Stats().setRadioactive(true),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 10,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff plutoniumBasedLiquidFuelDepleted = new Werkstoff(
+        new short[] { 0x67, 0x19, 0x19 },
+        "Plutonium Based Liquid Fuel (Depleted)",
+        subscriptNumbers("Tn?Ce?Au?Kr?"),
+        new Werkstoff.Stats().setToxic(true),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 11,
+        TextureSet.SET_FLUID);
+
+    // Thorium-233
+    public static final Werkstoff oxalate = new Werkstoff(
+        new short[] { 0x79, 0xd8, 0x55 },
+        "Oxalate",
+        Werkstoff.Types.BIOLOGICAL,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 12,
+        TextureSet.SET_FLUID,
+        new Pair<>(Hydrogen, 2),
+        new Pair<>(Carbon, 2),
+        new Pair<>(Oxygen, 4));
+
+    public static final Werkstoff vanadiumPentoxide = new Werkstoff(
+        new short[] { 0xde, 0x8d, 0x12 },
+        "Vanadium Pentoxide",
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .onlyDust(),
+        OffsetID + 13,
+        TextureSet.SET_SHINY,
+        new Pair<>(Vanadium, 2),
+        new Pair<>(Oxygen, 5));
+
+    public static final Werkstoff thoriumNitrate = new Werkstoff(
+        new short[] { 0xba, 0xe8, 0x26 },
+        "Thorium Nitrate",
+        subscriptNumbers("Th(NO3)4"),
+        new Werkstoff.Stats(),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 14,
+        TextureSet.SET_DULL);
+
+    public static final Werkstoff thoriumOxalate = new Werkstoff(
+        new short[] { 0x50, 0x63, 0x13 },
+        "Thorium Oxalate",
+        subscriptNumbers("Th(C2O4)2"),
+        new Werkstoff.Stats(),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .onlyDust(),
+        OffsetID + 15,
+        TextureSet.SET_DULL);
+
+    public static final Werkstoff thoriumHydroxide = new Werkstoff(
+        new short[] { 0x92, 0xae, 0x89 },
+        "Thorium Hydroxide",
+        subscriptNumbers("Th(OH)4"),
+        new Werkstoff.Stats(),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .onlyDust(),
+        OffsetID + 16,
+        TextureSet.SET_SHINY);
+
+    public static final Werkstoff sodiumOxalate = new Werkstoff(
+        new short[] { 0xe4, 0xf8, 0x9b },
+        "Sodium Oxalate",
+        subscriptNumbers("Na2C2O4"),
+        new Werkstoff.Stats(),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .onlyDust(),
+        OffsetID + 17,
+        TextureSet.SET_DULL);
+
+    public static final Werkstoff thoriumTetrachloride = new Werkstoff(
+        new short[] { 0x13, 0x7c, 0x16 },
+        "Thorium Tetrachloride",
+        subscriptNumbers("ThCl4"),
+        new Werkstoff.Stats(),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 18,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff thoriumTetrafluoride = new Werkstoff(
+        new short[] { 0x15, 0x6a, 0x6a },
+        "Thorium Tetrafluoride",
+        subscriptNumbers("ThF4"),
+        new Werkstoff.Stats(),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 19,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff thorium232Tetrafluoride = new Werkstoff(
+        new short[] { 0x15, 0x6a, 0x6a },
+        "Thorium-232 Tetrafluoride",
+        new Werkstoff.Stats(),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 20,
+        TextureSet.SET_FLUID,
+        new Pair<>(WerkstoffLoader.Thorium232, 1),
+        new Pair<>(Fluorine, 4));
+
+    // Atomic Separation Catalyst
+    public static final Werkstoff orundum = new Werkstoff(
+        new short[] { 0xcd, 0x26, 0x26 },
+        "Orundum",
+        "Or",
+        new Werkstoff.Stats().setProtons(120)
+            .setMass(300),
+        Werkstoff.Types.ELEMENT,
+        new Werkstoff.GenerationFeatures().addGems()
+            .addMolten(),
+        OffsetID + 22,
+        TextureSet.SET_DIAMOND);
+
+    public static final Werkstoff atomicSeparationCatalyst = new Werkstoff(
+        new short[] { 0xe8, 0x5e, 0x0c },
+        "Atomic Separation Catalyst",
+        "the melting core...",
+        new Werkstoff.Stats().setMeltingPoint(5000),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .onlyDust()
+            .addMolten()
+            .addMetalItems()
+            .addSimpleMetalWorkingItems()
+            .addCraftingMetalWorkingItems()
+            .addMultipleIngotMetalWorkingItems(),
+        OffsetID + 21,
+        TextureSet.SET_SHINY,
+        new Pair<>(MyMaterial.orundum, 2),
+        new Pair<>(Plutonium, 1),
+        new Pair<>(Naquadah, 2));
+
+    // Naquadah Fuel Rework
+    public static final Werkstoff extremelyUnstableNaquadah = new Werkstoff(
+        new short[] { 0x06, 0x26, 0x05 },
+        "Extremely Unstable Naquadah",
+        "Nq" + CharExchanger.shifter(9734),
+        new Werkstoff.Stats().setMeltingPoint(7000)
+            .setBlastFurnace(true)
+            .setProtons(200)
+            .setMass(450)
+            .setRadioactive(true),
+        Werkstoff.Types.ELEMENT,
+        new Werkstoff.GenerationFeatures().disable()
+            .onlyDust()
+            .addMolten()
+            .addMetalItems()
+            .addSimpleMetalWorkingItems()
+            .addCraftingMetalWorkingItems()
+            .addMultipleIngotMetalWorkingItems(),
+        OffsetID + 23,
+        TextureSet.SET_SHINY);
+
+    public static final Werkstoff lightNaquadahFuel = new Werkstoff(
+        new short[] { 92, 203, 92 },
+        "Light Naquadah Fuel",
+        "far from enough",
+        new Werkstoff.Stats().setToxic(true)
+            .setRadioactive(true),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 24,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff heavyNaquadahFuel = new Werkstoff(
+        new short[] { 54, 255, 54 },
+        "Heavy Naquadah Fuel",
+        "still need processing",
+        new Werkstoff.Stats().setToxic(true)
+            .setRadioactive(true),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 25,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff naquadahGas = new Werkstoff(
+        new short[] { 93, 219, 0 },
+        "Naquadah Gas",
+        "Who need it?",
+        new Werkstoff.Stats().setToxic(true)
+            .setRadioactive(true)
+            .setGas(true),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 26,
+        TextureSet.SET_FLUID);
+
+    public static final Werkstoff naquadahAsphalt = new Werkstoff(
+        new short[] { 5, 37, 5 },
+        "Naquadah Asphalt",
+        "It will damage the reactor.",
+        new Werkstoff.Stats().setToxic(true)
+            .setRadioactive(true),
+        Werkstoff.Types.COMPOUND,
+        new Werkstoff.GenerationFeatures().disable()
+            .addCells(),
+        OffsetID + 27,
+        TextureSet.SET_FLUID);