NAEDOCYTE BREEDA

src/main/java/com/hbm/blocks/ModBlocks.java

@@ -1019,6 +1019,7 @@ public class ModBlocks {
 	public static Block machine_assembly_machine;
 	@Deprecated public static Block machine_assemfac;
 	public static Block machine_assembly_factory;
+	public static Block machine_precass;
 	public static Block machine_arc_welder;
 	public static Block machine_soldering_station;
 	public static Block machine_arc_furnace;
@@ -2258,6 +2259,7 @@ public class ModBlocks {
 		machine_assembly_machine = new MachineAssemblyMachine(Material.iron).setBlockName("machine_assembly_machine").setHardness(5.0F).setResistance(30.0F).setCreativeTab(MainRegistry.machineTab).setBlockTextureName(RefStrings.MODID + ":block_steel");
 		machine_assemfac = new MachineAssemfac(Material.iron).setBlockName("machine_assemfac").setHardness(5.0F).setResistance(30.0F).setCreativeTab(null).setBlockTextureName(RefStrings.MODID + ":block_steel");
 		machine_assembly_factory = new MachineAssemblyFactory(Material.iron).setBlockName("machine_assembly_factory").setHardness(5.0F).setResistance(30.0F).setCreativeTab(MainRegistry.machineTab).setBlockTextureName(RefStrings.MODID + ":block_steel");
+		machine_precass = new MachinePrecAss(Material.iron).setBlockName("machine_precass").setHardness(5.0F).setResistance(30.0F).setCreativeTab(null /* the world isn't ready for your beauty yet */).setBlockTextureName(RefStrings.MODID + ":block_steel");
 		machine_arc_welder = new MachineArcWelder(Material.iron).setBlockName("machine_arc_welder").setHardness(5.0F).setResistance(30.0F).setCreativeTab(MainRegistry.machineTab).setBlockTextureName(RefStrings.MODID + ":block_steel");
 		machine_soldering_station = new MachineSolderingStation(Material.iron).setBlockName("machine_soldering_station").setHardness(5.0F).setResistance(30.0F).setCreativeTab(MainRegistry.machineTab).setBlockTextureName(RefStrings.MODID + ":block_steel");
 		machine_chemplant = new MachineChemplant(Material.iron).setBlockName("machine_chemplant").setHardness(5.0F).setResistance(30.0F).setCreativeTab(null).setBlockTextureName(RefStrings.MODID + ":block_steel");
@@ -3321,6 +3323,7 @@ public class ModBlocks {
 		register(machine_assembly_machine);
 		GameRegistry.registerBlock(machine_assemfac, machine_assemfac.getUnlocalizedName());
 		register(machine_assembly_factory);
+		register(machine_precass);
 		GameRegistry.registerBlock(machine_chemplant, machine_chemplant.getUnlocalizedName());
 		register(machine_chemical_plant);
 		register(machine_chemfac);

src/main/java/com/hbm/blocks/machine/MachineAssembler.java

@@ -11,6 +11,7 @@ import net.minecraft.util.AxisAlignedBB;
 import net.minecraft.world.World;
 import net.minecraftforge.common.util.ForgeDirection;
 
+@Deprecated
 public class MachineAssembler extends BlockDummyable {
 
 	public MachineAssembler(Material p_i45386_1_) {

src/main/java/com/hbm/blocks/machine/MachineAssemfac.java

@@ -10,6 +10,7 @@ import net.minecraft.tileentity.TileEntity;
 import net.minecraft.world.World;
 import net.minecraftforge.common.util.ForgeDirection;
 
+@Deprecated
 public class MachineAssemfac extends BlockDummyable {
 
 	public MachineAssemfac(Material mat) {

src/main/java/com/hbm/blocks/machine/MachinePrecAss.java

@@ -0,0 +1,20 @@
+package com.hbm.blocks.machine;
+
+import com.hbm.tileentity.machine.TileEntityMachinePrecAss;
+
+import net.minecraft.block.material.Material;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.World;
+
+public class MachinePrecAss extends MachineAssemblyMachine {
+
+	public MachinePrecAss(Material mat) {
+		super(mat);
+	}
+
+	@Override
+	public TileEntity createNewTileEntity(World world, int meta) {
+		if(meta >= 12) return new TileEntityMachinePrecAss();
+		return super.createNewTileEntity(world, meta);
+	}
+}

src/main/java/com/hbm/inventory/container/ContainerFusionBreeder.java

@@ -0,0 +1,70 @@
+package com.hbm.inventory.container;
+
+import com.hbm.inventory.SlotCraftingOutput;
+import com.hbm.inventory.SlotNonRetarded;
+import com.hbm.items.machine.IItemFluidIdentifier;
+import com.hbm.tileentity.machine.fusion.TileEntityFusionBreeder;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.inventory.Container;
+import net.minecraft.inventory.Slot;
+import net.minecraft.item.ItemStack;
+
+public class ContainerFusionBreeder extends Container {
+	
+	protected TileEntityFusionBreeder breeder;
+	
+	public ContainerFusionBreeder(InventoryPlayer invPlayer, TileEntityFusionBreeder tedf) {
+		this.breeder = tedf;
+
+		this.addSlotToContainer(new SlotNonRetarded(breeder, 0, 26, 72));
+		this.addSlotToContainer(new SlotNonRetarded(breeder, 1, 48, 45));
+		this.addSlotToContainer(new SlotCraftingOutput(invPlayer.player, breeder, 2, 112, 45));
+		
+		for(int i = 0; i < 3; i++) {
+			for(int j = 0; j < 9; j++) {
+				this.addSlotToContainer(new Slot(invPlayer, j + i * 9 + 9, 8 + j * 18, 118 + i * 18));
+			}
+		}
+
+		for(int i = 0; i < 9; i++) {
+			this.addSlotToContainer(new Slot(invPlayer, i, 8 + i * 18, 176));
+		}
+	}
+	
+	@Override
+	public ItemStack transferStackInSlot(EntityPlayer player, int index) {
+		ItemStack copy = null;
+		Slot slot = (Slot) this.inventorySlots.get(index);
+
+		if(slot != null && slot.getHasStack()) {
+			ItemStack stack = slot.getStack();
+			copy = stack.copy();
+
+			if(index <= 2) {
+				if(!this.mergeItemStack(stack, 3, this.inventorySlots.size(), true)) return null;
+			} else {
+				
+				if(copy.getItem() instanceof IItemFluidIdentifier) {
+					if(!this.mergeItemStack(stack, 0, 1, false)) return null;
+				} else {
+					if(!this.mergeItemStack(stack, 1, 2, false)) return null;
+				}
+			}
+
+			if(stack.stackSize == 0) {
+				slot.putStack((ItemStack) null);
+			} else {
+				slot.onSlotChanged();
+			}
+		}
+
+		return copy;
+	}
+	
+	@Override
+	public boolean canInteractWith(EntityPlayer player) {
+		return breeder.isUseableByPlayer(player);
+	}
+}

src/main/java/com/hbm/inventory/gui/GUIFusionBreeder.java

@@ -0,0 +1,57 @@
+package com.hbm.inventory.gui;
+
+import com.hbm.inventory.container.ContainerFusionBreeder;
+import com.hbm.lib.RefStrings;
+import com.hbm.render.util.GaugeUtil;
+import com.hbm.tileentity.machine.fusion.TileEntityFusionBreeder;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.resources.I18n;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.util.ResourceLocation;
+
+public class GUIFusionBreeder extends GuiInfoContainer {
+
+	private static ResourceLocation texture = new ResourceLocation(RefStrings.MODID + ":textures/gui/reactors/gui_fusion_breeder.png");
+	public TileEntityFusionBreeder breeder;
+	
+	public GUIFusionBreeder(InventoryPlayer invPlayer, TileEntityFusionBreeder breeder) {
+		super(new ContainerFusionBreeder(invPlayer, breeder));
+		this.breeder = breeder;
+		
+		this.xSize = 176;
+		this.ySize = 200;
+	}
+
+	@Override
+	public void drawScreen(int mouseX, int mouseY, float interp) {
+		super.drawScreen(mouseX, mouseY, interp);
+
+		breeder.tanks[0].renderTankInfo(this, mouseX, mouseY, guiLeft + 26, guiTop + 18, 16, 52);
+		breeder.tanks[1].renderTankInfo(this, mouseX, mouseY, guiLeft + 134, guiTop + 18, 16, 52);
+	}
+
+	@Override
+	protected void drawGuiContainerForegroundLayer(int i, int j) {
+		String name = this.breeder.hasCustomInventoryName() ? this.breeder.getInventoryName() : I18n.format(this.breeder.getInventoryName());
+		this.fontRendererObj.drawString(name, this.xSize / 2 - this.fontRendererObj.getStringWidth(name) / 2, 6, 4210752);
+		this.fontRendererObj.drawString(I18n.format("container.inventory"), 35, this.ySize - 93, 4210752);
+	}
+
+	@Override
+	protected void drawGuiContainerBackgroundLayer(float interp, int x, int y) {
+		Minecraft.getMinecraft().getTextureManager().bindTexture(texture);
+		drawTexturedModalRect(guiLeft, guiTop, 0, 0, xSize, ySize);
+		
+		int p = (int) Math.ceil(breeder.progress * 42 / breeder.capacity);
+		if(p > 0) drawTexturedModalRect(guiLeft + 67, guiTop + 48, 176, 0, p, 10);
+		
+		double gauge = 1D - Math.pow(Math.E, -breeder.neutronEnergy * 10 / breeder.capacity);
+		
+		// input flux
+		GaugeUtil.drawSmoothGauge(guiLeft + 88, guiTop + 32, this.zLevel, gauge, 5, 2, 1, 0xA00000);
+
+		breeder.tanks[0].renderTank(guiLeft + 26, guiTop + 70, this.zLevel, 16, 52);
+		breeder.tanks[1].renderTank(guiLeft + 134, guiTop + 70, this.zLevel, 16, 52);
+	}
+}

src/main/java/com/hbm/inventory/gui/GUIFusionKlystron.java

@@ -64,7 +64,8 @@ public class GUIFusionKlystron extends GuiInfoContainer {
 		
 		this.field.mouseClicked(i, j, button);
 	}
-	
+
+	@Override
 	protected void drawGuiContainerForegroundLayer(int i, int j) {
 		String name = this.klystron.hasCustomInventoryName() ? this.klystron.getInventoryName() : I18n.format(this.klystron.getInventoryName());
 		this.fontRendererObj.drawString(name, 115 - this.fontRendererObj.getStringWidth(name) / 2, 6, 4210752);
@@ -75,6 +76,7 @@ public class GUIFusionKlystron extends GuiInfoContainer {
 		this.fontRendererObj.drawString(result, 183 - this.fontRendererObj.getStringWidth(result), 40, 0x00FF00);
 	}
 
+	@Override
 	protected void drawGuiContainerBackgroundLayer(float interp, int x, int y) {
 		Minecraft.getMinecraft().getTextureManager().bindTexture(texture);
 		drawTexturedModalRect(guiLeft, guiTop, 0, 0, xSize, ySize);

src/main/java/com/hbm/main/ClientProxy.java

@@ -268,6 +268,7 @@ public class ClientProxy extends ServerProxy {
 		ClientRegistry.bindTileEntitySpecialRenderer(TileEntityMachineAssemblyMachine.class, new RenderAssemblyMachine());
 		ClientRegistry.bindTileEntitySpecialRenderer(TileEntityMachineAssemfac.class, new RenderAssemfac());
 		ClientRegistry.bindTileEntitySpecialRenderer(TileEntityMachineAssemblyFactory.class, new RenderAssemblyFactory());
+		ClientRegistry.bindTileEntitySpecialRenderer(TileEntityMachinePrecAss.class, new RenderPrecAss());
 		ClientRegistry.bindTileEntitySpecialRenderer(TileEntityMachineChemplant.class, new RenderChemplant());
 		ClientRegistry.bindTileEntitySpecialRenderer(TileEntityMachineChemicalPlant.class, new RenderChemicalPlant());
 		ClientRegistry.bindTileEntitySpecialRenderer(TileEntityMachineChemfac.class, new RenderChemfac());

src/main/java/com/hbm/main/ResourceManager.java

@@ -585,6 +585,7 @@ public class ResourceManager {
 	public static final ResourceLocation assemfac_tex = new ResourceLocation(RefStrings.MODID, "textures/models/machines/assemfac.png");
 	public static final ResourceLocation assembly_factory_tex = new ResourceLocation(RefStrings.MODID, "textures/models/machines/assembly_factory.png");
 	public static final ResourceLocation assembly_factory_sparks_tex = new ResourceLocation(RefStrings.MODID, "textures/models/machines/assembly_factory_sparks.png");
+	public static final ResourceLocation precass_tex = new ResourceLocation(RefStrings.MODID, "textures/models/machines/precass.png");
 
 	//Chemplant
 	public static final ResourceLocation chemplant_body_tex = new ResourceLocation(RefStrings.MODID, "textures/models/chemplant_base_new.png");

src/main/java/com/hbm/module/machine/ModuleMachinePrecAss.java

@@ -0,0 +1,39 @@
+package com.hbm.module.machine;
+
+import com.hbm.inventory.fluid.tank.FluidTank;
+import com.hbm.inventory.recipes.AssemblyMachineRecipes;
+import com.hbm.inventory.recipes.loader.GenericRecipe;
+import com.hbm.inventory.recipes.loader.GenericRecipes;
+import com.hbm.util.BobMathUtil;
+
+import api.hbm.energymk2.IEnergyHandlerMK2;
+import net.minecraft.item.ItemStack;
+
+public class ModuleMachinePrecAss extends ModuleMachineBase {
+
+	public ModuleMachinePrecAss(int index, IEnergyHandlerMK2 battery, ItemStack[] slots) {
+		super(index, battery, slots);
+		this.inputSlots = new int[9];
+		this.outputSlots = new int[9];
+		this.inputTanks = new FluidTank[1];
+		this.outputTanks = new FluidTank[1];
+	}
+
+	@Override
+	public GenericRecipes getRecipeSet() {
+		return AssemblyMachineRecipes.INSTANCE;
+	}
+	
+	@Override
+	public void setupTanks(GenericRecipe recipe) {
+		super.setupTanks(recipe);
+		if(recipe == null) return;
+		for(int i = 0; i < inputTanks.length; i++) if(recipe.inputFluid != null && recipe.inputFluid.length > i) inputTanks[i].changeTankSize(BobMathUtil.max(inputTanks[i].getFill(), recipe.inputFluid[i].fill * 2, 4_000));
+		for(int i = 0; i < outputTanks.length; i++) if(recipe.outputFluid != null && recipe.outputFluid.length > i) outputTanks[i].changeTankSize(BobMathUtil.max(outputTanks[i].getFill(), recipe.outputFluid[i].fill * 2, 4_000));
+	}
+
+	public ModuleMachinePrecAss itemInput(int from) { for(int i = 0; i < inputSlots.length; i++) inputSlots[i] = from + i; return this; }
+	public ModuleMachinePrecAss itemOutput(int from) { for(int i = 0; i < outputSlots.length; i++) outputSlots[i] = from + i; return this; }
+	public ModuleMachinePrecAss fluidInput(FluidTank a) { inputTanks[0] = a; return this; }
+	public ModuleMachinePrecAss fluidOutput(FluidTank a) { outputTanks[0] = a; return this; }
+}

src/main/java/com/hbm/render/tileentity/RenderAssembler.java

@@ -16,6 +16,7 @@ import net.minecraft.item.ItemBlock;
 import net.minecraft.item.ItemStack;
 import net.minecraft.tileentity.TileEntity;
 
+@Deprecated
 public class RenderAssembler extends TileEntitySpecialRenderer {
 	
 	private RenderItem itemRenderer;

src/main/java/com/hbm/render/tileentity/RenderAssemfac.java

@@ -10,6 +10,7 @@ import com.hbm.tileentity.machine.TileEntityMachineAssemfac.AssemblerArm;
 import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
 import net.minecraft.tileentity.TileEntity;
 
+@Deprecated
 public class RenderAssemfac extends TileEntitySpecialRenderer {
 
 	@Override

src/main/java/com/hbm/render/tileentity/RenderChemfac.java

@@ -9,6 +9,7 @@ import com.hbm.tileentity.machine.TileEntityMachineChemfac;
 import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
 import net.minecraft.tileentity.TileEntity;
 
+@Deprecated
 public class RenderChemfac extends TileEntitySpecialRenderer {
 
 	@Override

src/main/java/com/hbm/render/tileentity/RenderPrecAss.java

@@ -0,0 +1,150 @@
+package com.hbm.render.tileentity;
+
+import org.lwjgl.opengl.GL11;
+
+import com.hbm.blocks.BlockDummyable;
+import com.hbm.blocks.ModBlocks;
+import com.hbm.main.ResourceManager;
+import com.hbm.render.item.ItemRenderBase;
+import com.hbm.tileentity.machine.TileEntityMachinePrecAss;
+
+import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.client.IItemRenderer;
+
+public class RenderPrecAss extends TileEntitySpecialRenderer implements IItemRendererProvider {
+	
+	public static EntityItem dummy;
+
+	@Override
+	public void renderTileEntityAt(TileEntity tileEntity, double x, double y, double z, float interp) {
+		GL11.glPushMatrix();
+		GL11.glTranslated(x + 0.5, y, z + 0.5);
+		GL11.glRotated(90, 0, 1, 0);
+		GL11.glShadeModel(GL11.GL_SMOOTH);
+
+		switch(tileEntity.getBlockMetadata() - BlockDummyable.offset) {
+		case 2: GL11.glRotatef(0, 0F, 1F, 0F); break;
+		case 4: GL11.glRotatef(90, 0F, 1F, 0F); break;
+		case 3: GL11.glRotatef(180, 0F, 1F, 0F); break;
+		case 5: GL11.glRotatef(270, 0F, 1F, 0F); break;
+		}
+		
+		TileEntityMachinePrecAss assembler = (TileEntityMachinePrecAss) tileEntity;
+		
+		bindTexture(ResourceManager.precass_tex);
+		ResourceManager.assembly_machine.renderPart("Base");
+		//if(assembler.frame) ResourceManager.assembly_machine.renderPart("Frame");
+		
+		GL11.glPushMatrix();
+
+		//double spin = BobMathUtil.interp(assembler.prevRing, assembler.ring, interp);
+		double[] arm1 = new double[] {45, -15, -5, -0.75};
+		
+		// arm1 = arm2 = new double[] {60, -15, 15, -0.25}; // heart
+		
+		//GL11.glRotated(spin, 0, 1, 0);
+		ResourceManager.assembly_machine.renderPart("Ring");
+		ResourceManager.assembly_machine.renderPart("Ring2");
+
+		for(int i = 0; i < 4; i++) {
+			renderArm(arm1);
+			GL11.glRotated(90, 0, 1, 0);
+		}
+		
+		GL11.glPopMatrix();
+		
+		GL11.glShadeModel(GL11.GL_FLAT);
+		
+		/*GenericRecipe recipe = AssemblyMachineRecipes.INSTANCE.recipeNameMap.get(assembler.assemblerModule.recipe);
+		if(recipe != null && MainRegistry.proxy.me().getDistanceSq(tileEntity.xCoord + 0.5, tileEntity.yCoord + 1, tileEntity.zCoord + 0.5) < 35 * 35) {
+
+			GL11.glRotated(90, 0, 1, 0);
+			GL11.glTranslated(0, 1.0625, 0);
+			
+			ItemStack stack = recipe.getIcon();
+			stack.stackSize = 1;
+
+			if(stack.getItemSpriteNumber() == 0 && stack.getItem() instanceof ItemBlock) {
+				if(RenderBlocks.renderItemIn3d(Block.getBlockFromItem(stack.getItem()).getRenderType())) {
+					GL11.glTranslated(0, -0.0625, 0);
+				} else {
+					GL11.glTranslated(0, -0.125, 0);
+					GL11.glScaled(0.5, 0.5, 0.5);
+				}
+			} else {
+				GL11.glRotated(-90, 1, 0, 0);
+				GL11.glTranslated(0, -0.25, 0);
+			}
+			
+			GL11.glScaled(1.25, 1.25, 1.25);
+
+			if(dummy == null || dummy.worldObj != tileEntity.getWorldObj()) dummy = new EntityItem(tileEntity.getWorldObj(), 0, 0, 0, stack);
+			dummy.setEntityItemStack(stack);
+			dummy.hoverStart = 0.0F;
+
+			RenderItem.renderInFrame = true;
+			RenderManager.instance.renderEntityWithPosYaw(dummy, 0.0D, 0.0D, 0.0D, 0.0F, 0.0F);
+			RenderItem.renderInFrame = false;
+		}*/
+		
+		GL11.glPopMatrix();
+	}
+	
+	public static void renderArm(double[] arm) {
+
+		GL11.glPushMatrix(); {
+			GL11.glTranslated(0, 1.625, 0.9375);
+			GL11.glRotated(arm[0], 1, 0, 0);
+			GL11.glTranslated(0, -1.625, -0.9375);
+			ResourceManager.assembly_machine.renderPart("ArmLower1");
+	
+			GL11.glTranslated(0, 2.375, 0.9375);
+			GL11.glRotated(arm[1], 1, 0, 0);
+			GL11.glTranslated(0, -2.375, -0.9375);
+			ResourceManager.assembly_machine.renderPart("ArmUpper1");
+	
+			GL11.glTranslated(0, 2.375, 0.4375);
+			GL11.glRotated(arm[2], 1, 0, 0);
+			GL11.glTranslated(0, -2.375, -0.4375);
+			ResourceManager.assembly_machine.renderPart("Head1");
+			GL11.glTranslated(0, arm[3], 0);
+			ResourceManager.assembly_machine.renderPart("Spike1");
+		} GL11.glPopMatrix();
+	}
+
+	@Override
+	public Item getItemForRenderer() {
+		return Item.getItemFromBlock(ModBlocks.machine_precass);
+	}
+
+	@Override
+	public IItemRenderer getRenderer() {
+		
+		return new ItemRenderBase() {
+			
+			public void renderInventory() {
+				GL11.glTranslated(0, -2.75, 0);
+				GL11.glScaled(4.5, 4.5, 4.5);
+			}
+			public void renderCommonWithStack(ItemStack item) {
+				GL11.glRotated(90, 0, 1, 0);
+				GL11.glScaled(0.75, 0.75, 0.75);
+				GL11.glShadeModel(GL11.GL_SMOOTH);
+				bindTexture(ResourceManager.precass_tex);
+				ResourceManager.assembly_machine.renderPart("Base");
+				ResourceManager.assembly_machine.renderPart("Frame");
+				ResourceManager.assembly_machine.renderPart("Ring");
+				ResourceManager.assembly_machine.renderPart("Ring2");
+				double[] arm = new double[] {45, -15, -5, -0.75};
+				for(int i = 0; i < 4; i++) {
+					renderArm(arm);
+					GL11.glRotated(90, 0, 1, 0);
+				}
+				GL11.glShadeModel(GL11.GL_FLAT);
+			}};
+	}
+}

src/main/java/com/hbm/tileentity/TileMappings.java

@@ -355,6 +355,7 @@ public class TileMappings {
 		put(TileEntityMachineAssemblyMachine.class, "tileentity_assemblymachine");
 		put(TileEntityMachineAssemfac.class, "tileentity_assemfac");
 		put(TileEntityMachineAssemblyFactory.class, "tileentity_assemblyfactory");
+		put(TileEntityMachinePrecAss.class, "tileentity_precass");
 		put(TileEntityMachineChemplant.class, "tileentity_chemical_plant");
 		put(TileEntityMachineChemicalPlant.class, "tileentity_chemicalplant");
 		put(TileEntityMachineChemfac.class, "tileentity_chemfac");

src/main/java/com/hbm/tileentity/machine/TileEntityMachinePrecAss.java

@@ -0,0 +1,346 @@
+package com.hbm.tileentity.machine;
+
+import java.util.HashMap;
+import java.util.List;
+
+import com.hbm.blocks.ModBlocks;
+import com.hbm.interfaces.IControlReceiver;
+import com.hbm.inventory.UpgradeManagerNT;
+import com.hbm.inventory.fluid.Fluids;
+import com.hbm.inventory.fluid.tank.FluidTank;
+import com.hbm.inventory.recipes.AssemblyMachineRecipes;
+import com.hbm.inventory.recipes.loader.GenericRecipe;
+import com.hbm.items.ModItems;
+import com.hbm.items.machine.ItemMachineUpgrade;
+import com.hbm.items.machine.ItemMachineUpgrade.UpgradeType;
+import com.hbm.lib.Library;
+import com.hbm.main.MainRegistry;
+import com.hbm.module.machine.ModuleMachinePrecAss;
+import com.hbm.sound.AudioWrapper;
+import com.hbm.tileentity.IUpgradeInfoProvider;
+import com.hbm.tileentity.TileEntityMachineBase;
+import com.hbm.util.BobMathUtil;
+import com.hbm.util.fauxpointtwelve.DirPos;
+import com.hbm.util.i18n.I18nUtil;
+
+import api.hbm.energymk2.IEnergyReceiverMK2;
+import api.hbm.fluidmk2.IFluidStandardTransceiverMK2;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import io.netty.buffer.ByteBuf;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.util.EnumChatFormatting;
+
+// horribly copy-pasted crap device
+public class TileEntityMachinePrecAss extends TileEntityMachineBase implements IEnergyReceiverMK2, IFluidStandardTransceiverMK2, IUpgradeInfoProvider, IControlReceiver/*, IGUIProvider*/ {
+
+	public FluidTank inputTank;
+	public FluidTank outputTank;
+	
+	public long power;
+	public long maxPower = 100_000;
+	public boolean didProcess = false;
+	
+	public boolean frame = false;
+	private AudioWrapper audio;
+
+	public ModuleMachinePrecAss assemblerModule;
+	
+	public double prevRing;
+	public double ring;
+	public double ringSpeed;
+	public double ringTarget;
+	public int ringDelay;
+
+	public UpgradeManagerNT upgradeManager = new UpgradeManagerNT(this);
+	
+	public TileEntityMachinePrecAss() {
+		super(22);
+		this.inputTank = new FluidTank(Fluids.NONE, 4_000);
+		this.outputTank = new FluidTank(Fluids.NONE, 4_000);
+		
+		this.assemblerModule = new ModuleMachinePrecAss(0, this, slots)
+				.itemInput(4).itemOutput(13)
+				.fluidInput(inputTank).fluidOutput(outputTank);
+	}
+
+	@Override
+	public String getName() {
+		return "container.machinePrecAss";
+	}
+
+	@Override
+	public void updateEntity() {
+		
+		if(maxPower <= 0) this.maxPower = 1_000_000;
+		
+		if(!worldObj.isRemote) {
+			
+			GenericRecipe recipe = AssemblyMachineRecipes.INSTANCE.recipeNameMap.get(assemblerModule.recipe);
+			if(recipe != null) {
+				this.maxPower = recipe.power * 100;
+			}
+			this.maxPower = BobMathUtil.max(this.power, this.maxPower, 100_000);
+			
+			this.power = Library.chargeTEFromItems(slots, 0, power, maxPower);
+			upgradeManager.checkSlots(slots, 2, 3);
+			
+			for(DirPos pos : getConPos()) {
+				this.trySubscribe(worldObj, pos);
+				if(inputTank.getTankType() != Fluids.NONE) this.trySubscribe(inputTank.getTankType(), worldObj, pos);
+				if(outputTank.getFill() > 0) this.tryProvide(outputTank, worldObj, pos);
+			}
+
+			double speed = 1D;
+			double pow = 1D;
+
+			speed += Math.min(upgradeManager.getLevel(UpgradeType.SPEED), 3) / 3D;
+			speed += Math.min(upgradeManager.getLevel(UpgradeType.OVERDRIVE), 3);
+
+			pow -= Math.min(upgradeManager.getLevel(UpgradeType.POWER), 3) * 0.25D;
+			pow += Math.min(upgradeManager.getLevel(UpgradeType.SPEED), 3) * 1D;
+			pow += Math.min(upgradeManager.getLevel(UpgradeType.OVERDRIVE), 3) * 10D / 3D;
+			
+			this.assemblerModule.update(speed, pow, true, slots[1]);
+			this.didProcess = this.assemblerModule.didProcess;
+			if(this.assemblerModule.markDirty) this.markDirty();
+			
+			this.networkPackNT(100);
+			
+		} else {
+			
+			if(worldObj.getTotalWorldTime() % 20 == 0) {
+				frame = !worldObj.getBlock(xCoord, yCoord + 3, zCoord).isAir(worldObj, xCoord, yCoord + 3, zCoord);
+			}
+			
+			if(this.didProcess && MainRegistry.proxy.me().getDistance(xCoord , yCoord, zCoord) < 50) {
+				if(audio == null) {
+					audio = createAudioLoop();
+					audio.startSound();
+				} else if(!audio.isPlaying()) {
+					audio = rebootAudio(audio);
+				}
+				audio.keepAlive();
+				audio.updatePitch(0.75F);
+				audio.updateVolume(this.getVolume(0.5F));
+				
+			} else {
+				if(audio != null) {
+					audio.stopSound();
+					audio = null;
+				}
+			}
+
+			/*for(AssemblerArm arm : arms) {
+				arm.updateInterp();
+				if(didProcess) {
+					arm.updateArm();
+				} else{
+					arm.returnToNullPos();
+				}
+				
+				if(!this.muffled && arm.prevAngles[3] != arm.angles[3] && arm.angles[3] == -0.75) {
+					MainRegistry.proxy.playSoundClient(xCoord, yCoord, zCoord, "hbm:block.assemblerStrike", this.getVolume(0.5F), 1F);
+				}
+			}*/
+			
+			this.prevRing = this.ring;
+			
+			if(didProcess) {
+				if(this.ring != this.ringTarget) {
+					double ringDelta = Math.abs(this.ringTarget - this.ring);
+					if(ringDelta <= this.ringSpeed) this.ring = this.ringTarget;
+					if(this.ringTarget > this.ring) this.ring += this.ringSpeed;
+					if(this.ringTarget < this.ring) this.ring -= this.ringSpeed;
+					if(this.ringTarget == this.ring) {
+						if(ringTarget >= 360) {
+							this.ringTarget -= 360D;
+							this.ring -= 360D;
+							this.prevRing -= 360D;
+						}
+						if(ringTarget <= -360) {
+							this.ringTarget += 360D;
+							this.ring += 360D;
+							this.prevRing += 360D;
+						}
+						this.ringDelay = 20 + worldObj.rand.nextInt(21);
+					}
+				} else {
+					if(this.ringDelay > 0) this.ringDelay--;
+					if(this.ringDelay <= 0) {
+						this.ringTarget += (worldObj.rand.nextDouble() * 2 - 1) * 135;
+						this.ringSpeed = 10D + worldObj.rand.nextDouble() * 5D;
+						if(!this.muffled) MainRegistry.proxy.playSoundClient(xCoord, yCoord, zCoord, "hbm:block.assemblerStart", this.getVolume(0.25F), 1.25F + worldObj.rand.nextFloat() * 0.25F);
+					}
+				}
+			}
+		}
+	}
+
+	@Override public AudioWrapper createAudioLoop() {
+		return MainRegistry.proxy.getLoopedSound("hbm:block.motor", xCoord, yCoord, zCoord, 0.5F, 15F, 0.75F, 20);
+	}
+
+	@Override public void onChunkUnload() {
+		if(audio != null) { audio.stopSound(); audio = null; }
+	}
+
+	@Override public void invalidate() {
+		super.invalidate();
+		if(audio != null) { audio.stopSound(); audio = null; }
+	}
+	
+	public DirPos[] getConPos() {
+		return new DirPos[] {
+				new DirPos(xCoord + 2, yCoord, zCoord - 1, Library.POS_X),
+				new DirPos(xCoord + 2, yCoord, zCoord + 0, Library.POS_X),
+				new DirPos(xCoord + 2, yCoord, zCoord + 1, Library.POS_X),
+				new DirPos(xCoord - 2, yCoord, zCoord - 1, Library.NEG_X),
+				new DirPos(xCoord - 2, yCoord, zCoord + 0, Library.NEG_X),
+				new DirPos(xCoord - 2, yCoord, zCoord + 1, Library.NEG_X),
+				new DirPos(xCoord - 1, yCoord, zCoord + 2, Library.POS_Z),
+				new DirPos(xCoord + 0, yCoord, zCoord + 2, Library.POS_Z),
+				new DirPos(xCoord + 1, yCoord, zCoord + 2, Library.POS_Z),
+				new DirPos(xCoord - 1, yCoord, zCoord - 2, Library.NEG_Z),
+				new DirPos(xCoord + 0, yCoord, zCoord - 2, Library.NEG_Z),
+				new DirPos(xCoord + 1, yCoord, zCoord - 2, Library.NEG_Z),
+		};
+	}
+
+	@Override
+	public void serialize(ByteBuf buf) {
+		super.serialize(buf);
+		this.inputTank.serialize(buf);
+		this.outputTank.serialize(buf);
+		buf.writeLong(power);
+		buf.writeLong(maxPower);
+		buf.writeBoolean(didProcess);
+		this.assemblerModule.serialize(buf);
+	}
+
+	@Override
+	public void deserialize(ByteBuf buf) {
+		super.deserialize(buf);
+		boolean wasProcessing = this.didProcess;
+		this.inputTank.deserialize(buf);
+		this.outputTank.deserialize(buf);
+		this.power = buf.readLong();
+		this.maxPower = buf.readLong();
+		this.didProcess = buf.readBoolean();
+		this.assemblerModule.deserialize(buf);
+		
+		if(wasProcessing && !didProcess) {
+			MainRegistry.proxy.playSoundClient(xCoord, yCoord, zCoord, "hbm:block.assemblerStop", this.getVolume(0.25F), 1.5F);
+		}
+	}
+	
+	@Override
+	public void readFromNBT(NBTTagCompound nbt) {
+		super.readFromNBT(nbt);
+		this.inputTank.readFromNBT(nbt, "i");
+		this.outputTank.readFromNBT(nbt, "o");
+		this.power = nbt.getLong("power");
+		this.maxPower = nbt.getLong("maxPower");
+		this.assemblerModule.readFromNBT(nbt);
+	}
+	
+	@Override
+	public void writeToNBT(NBTTagCompound nbt) {
+		super.writeToNBT(nbt);
+		this.inputTank.writeToNBT(nbt, "i");
+		this.outputTank.writeToNBT(nbt, "o");
+		nbt.setLong("power", power);
+		nbt.setLong("maxPower", maxPower);
+		this.assemblerModule.writeToNBT(nbt);
+	}
+
+	@Override
+	public boolean isItemValidForSlot(int slot, ItemStack stack) {
+		if(slot == 0) return true; // battery
+		if(slot == 1 && stack.getItem() == ModItems.blueprints) return true;
+		if(slot >= 2 && slot <= 3 && stack.getItem() instanceof ItemMachineUpgrade) return true; // upgrades
+		if(this.assemblerModule.isItemValid(slot, stack)) return true; // recipe input crap
+		return false;
+	}
+
+	@Override
+	public boolean canExtractItem(int i, ItemStack itemStack, int j) {
+		return i >= 13 || this.assemblerModule.isSlotClogged(i);
+	}
+
+	@Override
+	public int[] getAccessibleSlotsFromSide(int side) {
+		return new int[] {4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21};
+	}
+
+	@Override public long getPower() { return power; }
+	@Override public void setPower(long power) { this.power = power; }
+	@Override public long getMaxPower() { return maxPower; }
+
+	@Override public FluidTank[] getReceivingTanks() { return new FluidTank[] {inputTank}; }
+	@Override public FluidTank[] getSendingTanks() { return new FluidTank[] {outputTank}; }
+	@Override public FluidTank[] getAllTanks() { return new FluidTank[] {inputTank, outputTank}; }
+
+	//@Override public Container provideContainer(int ID, EntityPlayer player, World world, int x, int y, int z) { return new ContainerMachineAssemblyMachine(player.inventory, this); }
+	//@Override @SideOnly(Side.CLIENT) public Object provideGUI(int ID, EntityPlayer player, World world, int x, int y, int z) { return new GUIMachineAssemblyMachine(player.inventory, this); }
+
+	@Override public boolean hasPermission(EntityPlayer player) { return this.isUseableByPlayer(player); }
+
+	@Override
+	public void receiveControl(NBTTagCompound data) {
+		if(data.hasKey("index") && data.hasKey("selection")) {
+			int index = data.getInteger("index");
+			String selection = data.getString("selection");
+			if(index == 0) {
+				this.assemblerModule.recipe = selection;
+				this.markChanged();
+			}
+		}
+	}
+	
+	AxisAlignedBB bb = null;
+	
+	@Override
+	public AxisAlignedBB getRenderBoundingBox() {
+		if(bb == null) bb = AxisAlignedBB.getBoundingBox(xCoord - 1, yCoord, zCoord - 1, xCoord + 2, yCoord + 3, zCoord + 2);
+		return bb;
+	}
+	
+	@Override
+	@SideOnly(Side.CLIENT)
+	public double getMaxRenderDistanceSquared() {
+		return 65536.0D;
+	}
+	
+	@Override
+	public boolean canProvideInfo(UpgradeType type, int level, boolean extendedInfo) {
+		return type == UpgradeType.SPEED || type == UpgradeType.POWER || type == UpgradeType.OVERDRIVE;
+	}
+
+	@Override
+	public void provideInfo(UpgradeType type, int level, List<String> info, boolean extendedInfo) {
+		info.add(IUpgradeInfoProvider.getStandardLabel(ModBlocks.machine_assembly_machine));
+		if(type == UpgradeType.SPEED) {
+			info.add(EnumChatFormatting.GREEN + I18nUtil.resolveKey(KEY_SPEED, "+" + (level * 100 / 3) + "%"));
+			info.add(EnumChatFormatting.RED + I18nUtil.resolveKey(KEY_CONSUMPTION, "+" + (level * 50) + "%"));
+		}
+		if(type == UpgradeType.POWER) {
+			info.add(EnumChatFormatting.GREEN + I18nUtil.resolveKey(KEY_CONSUMPTION, "-" + (level * 25) + "%"));
+		}
+		if(type == UpgradeType.OVERDRIVE) {
+			info.add((BobMathUtil.getBlink() ? EnumChatFormatting.RED : EnumChatFormatting.DARK_GRAY) + "YES");
+		}
+	}
+
+	@Override
+	public HashMap<UpgradeType, Integer> getValidUpgrades() {
+		HashMap<UpgradeType, Integer> upgrades = new HashMap<>();
+		upgrades.put(UpgradeType.SPEED, 3);
+		upgrades.put(UpgradeType.POWER, 3);
+		upgrades.put(UpgradeType.OVERDRIVE, 3);
+		return upgrades;
+	}
+}

src/main/java/com/hbm/tileentity/machine/fusion/IFusionPowerReceiver.java

@@ -2,6 +2,12 @@ package com.hbm.tileentity.machine.fusion;
 
 public interface IFusionPowerReceiver {
 
+	/**
+	 * Returns true if this receives output fusion power which it shares with all other connected devices,
+	 * or false if it only uses neutron power which is not shared.
+	 */
+	public boolean receivesFusionPower();
+	
 	/**
 	 * fusionPower is the per-port output adjusted for the amount of connected receivers (i.e. when boilers share output energy)
 	 * neutronPower is a fixed value provided by the recipe

src/main/java/com/hbm/tileentity/machine/fusion/TileEntityFusionBreeder.java

@@ -1,12 +1,18 @@
 package com.hbm.tileentity.machine.fusion;
 
+import com.hbm.inventory.FluidStack;
+import com.hbm.inventory.container.ContainerFusionBreeder;
 import com.hbm.inventory.fluid.Fluids;
 import com.hbm.inventory.fluid.tank.FluidTank;
+import com.hbm.inventory.gui.GUIFusionBreeder;
+import com.hbm.inventory.recipes.OutgasserRecipes;
+import com.hbm.items.machine.IItemFluidIdentifier;
 import com.hbm.tileentity.IGUIProvider;
 import com.hbm.tileentity.TileEntityMachineBase;
 import com.hbm.uninos.GenNode;
 import com.hbm.uninos.UniNodespace;
 import com.hbm.uninos.networkproviders.PlasmaNetworkProvider;
+import com.hbm.util.Tuple.Pair;
 import com.hbm.util.fauxpointtwelve.BlockPos;
 import com.hbm.util.fauxpointtwelve.DirPos;
 
@@ -16,20 +22,25 @@ import cpw.mods.fml.relauncher.SideOnly;
 import io.netty.buffer.ByteBuf;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.inventory.Container;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.util.AxisAlignedBB;
 import net.minecraft.world.World;
 import net.minecraftforge.common.util.ForgeDirection;
 
-public class TileEntityFusionBreeder extends TileEntityMachineBase implements IFluidStandardTransceiverMK2, IGUIProvider {
+public class TileEntityFusionBreeder extends TileEntityMachineBase implements IFluidStandardTransceiverMK2, IFusionPowerReceiver, IGUIProvider {
 
 	protected GenNode plasmaNode;
 	
 	public FluidTank[] tanks;
-	
+
+	public double neutronEnergy;
+	public double neutronEnergySync;
+	public double progress;
 	public static final double capacity = 10_000D;
 
 	public TileEntityFusionBreeder() {
-		super(2);
+		super(3);
 		
 		tanks = new FluidTank[2];
 		tanks[0] = new FluidTank(Fluids.NONE, 16_000);
@@ -45,6 +56,14 @@ public class TileEntityFusionBreeder extends TileEntityMachineBase implements IF
 	public void updateEntity() {
 		
 		if(!worldObj.isRemote) {
+
+			if(!canProcessSolid()) {
+				this.progress = 0;
+			}
+			
+			// because tile updates may happen in any order and the value that needs
+			// to be synced needs to persist until the next tick due to the batched packets
+			this.neutronEnergySync = this.neutronEnergy;
 			
 			for(DirPos pos : getConPos()) {
 				if(tanks[0].getTankType() != Fluids.NONE) this.trySubscribe(tanks[0].getTankType(), worldObj, pos);
@@ -65,8 +84,72 @@ public class TileEntityFusionBreeder extends TileEntityMachineBase implements IF
 			}
 			
 			if(plasmaNode != null && plasmaNode.hasValidNet()) plasmaNode.net.addReceiver(this);
+			
+			this.networkPackNT(25);
+			
+			this.neutronEnergy = 0;
 		}
 	}
+
+	public boolean canProcessSolid() {
+		if(slots[1] == null) return false;
+
+		Pair<ItemStack, FluidStack> output = OutgasserRecipes.getOutput(slots[1]);
+		if(output == null) return false;
+
+		FluidStack fluid = output.getValue();
+
+		if(fluid != null) {
+			if(tanks[1].getTankType() != fluid.type && tanks[1].getFill() > 0) return false;
+			tanks[1].setTankType(fluid.type);
+			if(tanks[1].getFill() + fluid.fill > tanks[1].getMaxFill()) return false;
+		}
+
+		ItemStack out = output.getKey();
+		if(slots[2] == null || out == null) return true;
+
+		return slots[2].getItem() == out.getItem() && slots[2].getItemDamage() == out.getItemDamage() && slots[2].stackSize + out.stackSize <= slots[2].getMaxStackSize();
+	}
+
+	private void processSolid() {
+
+		Pair<ItemStack, FluidStack> output = OutgasserRecipes.getOutput(slots[1]);
+		this.decrStackSize(1, 1);
+		this.progress = 0;
+
+		if(output.getValue() != null) {
+			tanks[1].setFill(tanks[1].getFill() + output.getValue().fill);
+		}
+
+		ItemStack out = output.getKey();
+
+		if(out != null) {
+			if(slots[2] == null) {
+				slots[2] = out.copy();
+			} else {
+				slots[2].stackSize += out.stackSize;
+			}
+		}
+	}
+	
+	public void doProgress() {
+
+		if(canProcessSolid()) {
+			this.progress += this.neutronEnergy;
+			if(progress > capacity) {
+				processSolid();
+				progress = 0;
+				this.markDirty();
+			}
+		}
+	}
+
+	@Override
+	public boolean isItemValidForSlot(int slot, ItemStack stack) {
+		if(slot == 0) return stack.getItem() instanceof IItemFluidIdentifier; // fluid ID
+		if(slot == 1) return OutgasserRecipes.getOutput(stack) != null; // input
+		return false;
+	}
 	
 	public DirPos[] getConPos() {
 		ForgeDirection dir = ForgeDirection.getOrientation(this.getBlockMetadata() - 10);
@@ -93,6 +176,9 @@ public class TileEntityFusionBreeder extends TileEntityMachineBase implements IF
 	@Override
 	public void serialize(ByteBuf buf) {
 		super.serialize(buf);
+		buf.writeDouble(neutronEnergySync);
+		buf.writeDouble(progress);
+		
 		this.tanks[0].serialize(buf);
 		this.tanks[1].serialize(buf);
 	}
@@ -100,22 +186,46 @@ public class TileEntityFusionBreeder extends TileEntityMachineBase implements IF
 	@Override
 	public void deserialize(ByteBuf buf) {
 		super.deserialize(buf);
+		this.neutronEnergy = buf.readDouble();
+		this.progress = buf.readDouble();
+		
 		this.tanks[0].deserialize(buf);
 		this.tanks[1].deserialize(buf);
 	}
 
+	@Override
+	public void readFromNBT(NBTTagCompound nbt) {
+		super.readFromNBT(nbt);
+
+		this.progress = nbt.getDouble("progress");
+		this.tanks[0].readFromNBT(nbt, "t0");
+		this.tanks[1].readFromNBT(nbt, "t1");
+	}
+
+	@Override
+	public void writeToNBT(NBTTagCompound nbt) {
+		super.writeToNBT(nbt);
+
+		nbt.setDouble("progress", this.progress);
+		this.tanks[0].writeToNBT(nbt, "t0");
+		this.tanks[1].writeToNBT(nbt, "t1");
+	}
+
+	@Override public boolean receivesFusionPower() { return false; }
+	@Override public void receiveFusionPower(long fusionPower, double neutronPower) { this.neutronEnergy = neutronPower; doProgress(); }
+
 	@Override public FluidTank[] getReceivingTanks() { return new FluidTank[] {tanks[0]}; }
 	@Override public FluidTank[] getSendingTanks() { return new FluidTank[] {tanks[1]}; }
 	@Override public FluidTank[] getAllTanks() { return tanks; }
 
 	@Override
 	public Container provideContainer(int ID, EntityPlayer player, World world, int x, int y, int z) {
-		return null;
+		return new ContainerFusionBreeder(player.inventory, this);
 	}
 
 	@Override
 	public Object provideGUI(int ID, EntityPlayer player, World world, int x, int y, int z) {
-		return null;
+		return new GUIFusionBreeder(player.inventory, this);
 	}
 
 	AxisAlignedBB bb = null;

src/main/java/com/hbm/tileentity/machine/fusion/TileEntityFusionTorus.java

@@ -12,6 +12,7 @@ import com.hbm.items.ModItems;
 import com.hbm.lib.Library;
 import com.hbm.module.machine.ModuleMachineFusion;
 import com.hbm.tileentity.IGUIProvider;
+import com.hbm.tileentity.TileEntityLoadedBase;
 import com.hbm.tileentity.machine.albion.TileEntityCooledBase;
 import com.hbm.uninos.GenNode;
 import com.hbm.uninos.INetworkProvider;
@@ -122,7 +123,9 @@ public class TileEntityFusionTorus extends TileEntityCooledBase implements IGUIP
 
 			this.power = Library.chargeTEFromItems(slots, 0, power, this.getMaxPower());
 			
+			// keeping track of PLASMA receivers because those need to share the combined output
 			int receiverCount = 0;
+			// collectors for determining the speed of the bonus bar
 			int collectors = 0;
 			
 			for(int i = 0; i < 4; i++) {
@@ -134,8 +137,10 @@ public class TileEntityFusionTorus extends TileEntityCooledBase implements IGUIP
 					
 					for(Object o : plasmaNodes[i].net.receiverEntries.entrySet()) {
 						Entry<Object, Long> entry = (Entry<Object, Long>) o;
-						if(entry.getKey() instanceof IFusionPowerReceiver) receiverCount++;
-						if(entry.getKey() instanceof TileEntityFusionCollector) collectors++;
+						Object thing = entry.getKey();
+						if(thing instanceof TileEntityLoadedBase && !((TileEntityLoadedBase) thing).isLoaded()) continue;
+						if(thing instanceof IFusionPowerReceiver && ((IFusionPowerReceiver) thing).receivesFusionPower()) receiverCount++;
+						if(thing instanceof TileEntityFusionCollector) collectors++;
 						break;
 					}
 				}