3 files changed, 210 insertions, 1 deletions
diff --git a/src/main/java/GoodGenerator/Items/FuelRod.java b/src/main/java/GoodGenerator/Items/FuelRod.java
new file mode 100644
index 0000000000..5886cce095
--- /dev/null
+++ b/src/main/java/GoodGenerator/Items/FuelRod.java
@@ -0,0 +1,167 @@
+package GoodGenerator.Items;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+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;
+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 java.util.ArrayList;
+import java.util.List;
+
+import static GoodGenerator.util.DescTextLocalization.addText;
+
+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 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;
+    }
+
+    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);
+                    }
+                } 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, 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);
+        }
+        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)
+    @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)));
+    }
+}
diff --git a/src/main/java/GoodGenerator/Items/MyMaterial.java b/src/main/java/GoodGenerator/Items/MyMaterial.java
index 96a5dfcda7..e4ab266b7a 100644
--- a/src/main/java/GoodGenerator/Items/MyMaterial.java
+++ b/src/main/java/GoodGenerator/Items/MyMaterial.java
@@ -942,6 +942,38 @@ public class MyMaterial implements Runnable {
             TextureSet.SET_FLUID
     );
 
+    //material for reactor stuff
+    public static final Werkstoff zircaloy4 = new Werkstoff(
+            new short[]{0x8a,0x6e,0x68},
+            "Zircaloy-4",
+            subscriptNumbers("Zr34Sn5Fe2Cr"),
+            new Werkstoff.Stats().setCentrifuge(true).setBlastFurnace(true).setMeltingPoint(2800),
+            Werkstoff.Types.MIXTURE,
+            new Werkstoff.GenerationFeatures().onlyDust().addMolten().addMetalItems().addCraftingMetalWorkingItems().addSimpleMetalWorkingItems(),
+            OffsetID + 81,
+            TextureSet.SET_METALLIC,
+            new Pair<>(WerkstoffLoader.Zirconium, 34),
+            new Pair<>(Tin, 5),
+            new Pair<>(Iron, 2),
+            new Pair<>(Chrome, 1)
+    );
+
+    public static final Werkstoff zircaloy2 = new Werkstoff(
+            new short[]{0xa4,0x8f,0x8b},
+            "Zircaloy-2",
+            subscriptNumbers("Zr34Sn4FeCrNi"),
+            new Werkstoff.Stats().setCentrifuge(true).setBlastFurnace(true).setMeltingPoint(2800),
+            Werkstoff.Types.MIXTURE,
+            new Werkstoff.GenerationFeatures().onlyDust().addMolten().addMetalItems().addCraftingMetalWorkingItems().addSimpleMetalWorkingItems(),
+            OffsetID + 82,
+            TextureSet.SET_METALLIC,
+            new Pair<>(WerkstoffLoader.Zirconium, 34),
+            new Pair<>(Tin, 4),
+            new Pair<>(Iron, 1),
+            new Pair<>(Chrome, 1),
+            new Pair<>(Nickel, 1)
+    );
+
     @Override
     public void run() { }
 }
diff --git a/src/main/java/GoodGenerator/Items/RadioactiveItem.java b/src/main/java/GoodGenerator/Items/RadioactiveItem.java
index 408246ba67..8be42f94e8 100644
--- a/src/main/java/GoodGenerator/Items/RadioactiveItem.java
+++ b/src/main/java/GoodGenerator/Items/RadioactiveItem.java
@@ -12,13 +12,23 @@ import net.minecraft.world.World;
 
 public class RadioactiveItem extends MyItems{
 
-    private final int mRadio;
+    protected final int mRadio;
 
     public RadioactiveItem(String name, CreativeTabs Tab, int Rad) {
         super(name, Tab);
         this.mRadio = Rad;
     }
 
+    public RadioactiveItem(String name, String[] tooltip, CreativeTabs Tab, int Rad) {
+        super(name, tooltip, Tab);
+        this.mRadio = Rad;
+    }
+
+    public RadioactiveItem(String name, String tooltip, CreativeTabs Tab, int Rad) {
+        super(name, tooltip, Tab);
+        this.mRadio = Rad;
+    }
+
     @Override
     public void onUpdate(ItemStack aStack, World aWorld, Entity aPlayer, int aTimer, boolean aIsInHand) {
         super.onUpdate(aStack, aWorld, aPlayer, aTimer, aIsInHand);