Update build.gradle

Merge branch 'master' of https://github.com/turbodiesel4598/NuclearCraft
2025-11-09 18:24:40 +01:00 · 2020-07-21 22:41:11 +01:00 · 2020-07-21 20:39:47 +01:00 · 2020-07-21 20:24:33 +01:00 · 2020-07-21 20:24:23 +01:00
62 changed files with 1434 additions and 325 deletions
--- a/.gitignore
+++ b/.gitignore
@ -20,6 +20,9 @@ build
 # forge
 forge-1.12.2-14.23.5.2847-mdk.zip

+# contenttweaker
+src/main/resources/assets/base/
+
 # other
 eclipse
 run
--- a/build.gradle
+++ b/build.gradle
@ -19,22 +19,18 @@ repositories {
 		url = "https://minecraft.curseforge.com/api/maven/"
 	}
 	maven {
-		// JEI & TiC
 		name = "progwml6"
 		url = "http://dvs1.progwml6.com/files/maven/"
 	}
 	maven {
-		// CraftTweaker & Patchouli
 		name = "blamejared"
 		url = "http://maven.blamejared.com/"
 	}
 	maven {
-		// IC2
 		name = "ic2"
 		url = "http://maven.ic2.player.to/"
 	}
 	maven {
-		// OpenComputers
 		name = "cil"
 		url = "http://maven.cil.li/"
 	}
@ -47,22 +43,18 @@ repositories {
 		url = "http://chickenbones.net/maven/"
 	}
 	maven {
-		// CyclopsMC
 		name = "CyclopsMC"
 		url = "https://oss.jfrog.org/artifactory/simple/libs-release/"
 	}
 	maven {
-		// tterrag
 		name 'tterrag Maven'
 		url "https://maven.tterrag.com/"
 	}
 	maven {
-		// General
 		name = "mcmoddev"
 		url = "https://maven.mcmoddev.com"
 	}
 	maven {
-		// Fallbacks
 		name = "ModMaven"
 		url = "https://modmaven.k-4u.nl"
 	}
@ -97,6 +89,8 @@ dependencies {
 	deobfCompile "cofh:RedstoneFlux:1.12-+:universal"
 	deobfCompile "net.industrial-craft:industrialcraft-2:${ic2_version}:api"
 	deobfCompile "CraftTweaker2:CraftTweaker2-MC1120-Main:${crafttweaker_version}"
+	deobfCompile "base:base:${b_a_s_e_version}"
+	deobfCompile "contenttweaker:ContentTweaker:${contenttweaker_version}"
 	deobfCompile "slimeknights.mantle:Mantle:${mantle_version}"
 	deobfCompile "slimeknights:TConstruct:${tic_version}"
 	deobfCompile "constructs-armory:conarm:${conarm_version}"
@ -117,6 +111,7 @@ dependencies {

 processResources {
 	exclude '**/Thumbs.db'
+	exclude '**/assets/base/**'
 	
 	inputs.property "version", project.version
 	inputs.property "mcversion", project.minecraft.version
--- a/changelog.txt
+++ b/changelog.txt
@ -1,9 +1,14 @@
 v2o.3.4

+ Added CT methods to add custom fission reactor and turbine multiblock components
+ Added and improved CT methods for getting and setting radiation levels
+
 * Fixed player radiation stats being lost on leaving The End
 * RadAway and Rad-X is no longer consumed in creative mode
+* Previously installed radiation shielding is recovered from blocks on installing a better one

 * Turbine rotor will not render if the casing is entirely opaque
+ Added more accurate selection bounding boxes to blades and stators [thanks to dizzyd!]

 + Added ore dict interchangeability between NC and HarvestCraft chocolate and cocoa powder

@ -14,7 +19,7 @@ v2o.3.4
 * Fixed localisation of speed and energy upgrade tooltips

 * Increased plasma fluid temperature
-* Other minor changes
+* Other minor changes and refactors

 v2o.3.3

--- a/craftTweaker.txt
+++ b/craftTweaker.txt
@ -352,7 +352,7 @@ mods.nuclearcraft.FissionHeating.removeRecipeWithInput(ILiquidStack fluidInput);
 mods.nuclearcraft.FissionHeating.removeRecipeWithOutput(ILiquidStack fluidOutput);


-Molten Salt Fission (KINDA BROKEN!):
+Molten Salt Fission:
 ------------------------------------

 mods.nuclearcraft.SaltFission.addRecipe(ILiquidStack fluidInput, ILiquidStack fluidOutput, double time, int heat, double efficiency, int criticality, boolean selfPriming, double radiation);
@ -454,7 +454,16 @@ IEntityLivingBase::getRadiationLevel();
 Miscellaneous:
 --------------

-mods.nuclearcraft.Radiation.getRadiationLevel(IIngredient itemInput);
+Note: `setMaterialRadiationLevel(...)` can accept Unix-style wildcards.
+
+mods.nuclearcraft.Radiation.getRadiationLevel(IIngredient ingredient);
+
+mods.nuclearcraft.Radiation.addToRadiationBlacklist(IIngredient ingredient);
+
+mods.nuclearcraft.Radiation.setRadiationLevel(IIngredient ingredient, double radiation);
+mods.nuclearcraft.Radiation.setMaterialRadiationLevel(String oreSuffix, double radiation);
+
+mods.nuclearcraft.Radiation.setFoodRadiationStats(IItemStack food, double radiation, double resistance);

 mods.nuclearcraft.Radiation.setRadiationImmunityGameStages(boolean defaultImmunity, String... stageNames);

@ -490,6 +499,21 @@ Recipe::getItemIngredient(int index);
 Recipe::getFluidIngredient(int index);
 Recipe::getItemProduct(int index);
 Recipe::getFluidProduct(int index);
-
+___________________________________________________________________________________________________________________________
+---------------------------------------------------------------------------------------------------------------------------
+
+ Registration Methods
+#====================#
+
+Note A: These methods must use the `preinit` loader!
+
+Note B: If ContentTweaker is installed, assets can be located in its generated resources directory rather than a resource pack!
+
+mods.nuclearcraft.Registration.registerFissionSink(String sinkID, int coolingRate, String placementRule);
+mods.nuclearcraft.Registration.registerFissionHeater(String heaterID, String fluidInput, int inputAmount, String fluidOutput, int outputAmount, int coolingRate, String placementRule);
+
+mods.nuclearcraft.Registration.registerTurbineCoil(String coilID, double conductivity, String placementRule);
+mods.nuclearcraft.Registration.registerTurbineBlade(String bladeID, double efficiency, double expansionCoefficient);
+mods.nuclearcraft.Registration.registerTurbineStator(String statorID, double expansionCoefficient);
 ___________________________________________________________________________________________________________________________
 ---------------------------------------------------------------------------------------------------------------------------
--- a/gradle.properties
+++ b/gradle.properties
@ -22,5 +22,7 @@ gregtech_version=1.12.2:1.9.0.481
 mekanism_version=1.12.2:9.8.3.390
 projecte_version=1.12.2:PE1.4.1
 hwyla_version=1.8.26:B41_1.12.2
+b_a_s_e_version=1.12.2:3.13.0
+contenttweaker_version=1.12.2:4.9.1

 org.gradle.jvmargs=-Xmx4G
--- a/src/main/java/nc/Global.java
+++ b/src/main/java/nc/Global.java
@ -3,7 +3,6 @@ package nc;
 public class Global {
 	
 	public static final String MOD_ID = "nuclearcraft";
-	public static final String MOD_SHORT_ID = "nc";
 	public static final String MOD_NAME = "NuclearCraft";
 	public static final String VERSION = "@VERSION@";
 	public static final String DEPENDENCIES = "after:tconstruct;after:conarm;after:openterraingenerator;after:alchemistry;after:harvestcraft";
--- a/src/main/java/nc/ModCheck.java
+++ b/src/main/java/nc/ModCheck.java
@ -25,6 +25,7 @@ public class ModCheck {
 	private static boolean gameStagesLoaded = false;
 	private static boolean cubicChunksLoaded = false;
 	private static boolean hwylaLoaded = false;
+	private static boolean patchouliLoaded = false;
 	
 	public static void init() {
 		if (initialized) {
@ -50,6 +51,7 @@ public class ModCheck {
 		gameStagesLoaded = Loader.isModLoaded("gamestages");
 		cubicChunksLoaded = Loader.isModLoaded("cubicchunks");
 		hwylaLoaded = Loader.isModLoaded("waila");
+		patchouliLoaded = Loader.isModLoaded("patchouli");
 		
 		initialized = true;
 	}
@ -129,4 +131,8 @@ public class ModCheck {
 	public static boolean hwylaLoaded() {
 		return hwylaLoaded;
 	}
+	
+	public static boolean patchouliLoaded() {
+		return patchouliLoaded;
+	}
 }
--- a/src/main/java/nc/capability/radiation/entity/EntityRads.java
+++ b/src/main/java/nc/capability/radiation/entity/EntityRads.java
@ -14,6 +14,7 @@ public class EntityRads extends PlayerRads {
 	public EntityRads(EntityLivingBase entity) {
 		super();
 		this.entity = entity;
+		giveGuidebook = false;
 	}
 	
 	@Override
--- a/src/main/java/nc/capability/radiation/entity/IEntityRads.java
+++ b/src/main/java/nc/capability/radiation/entity/IEntityRads.java
@ -123,4 +123,8 @@ public interface IEntityRads extends IRadiation, ICapability<IEntityRads> {
 	public boolean getShouldWarn();
 	
 	public void setShouldWarn(boolean shouldWarn);
+	
+	public boolean getGiveGuidebook();
+	
+	public void setGiveGuidebook(boolean giveGuidebook);
 }
--- a/src/main/java/nc/capability/radiation/entity/PlayerRads.java
+++ b/src/main/java/nc/capability/radiation/entity/PlayerRads.java
@ -9,23 +9,24 @@ import net.minecraft.util.math.MathHelper;
 public class PlayerRads implements IEntityRads {
 	
 	protected double maxRads = 0D;
-	private double totalRads = 0D;
-	private double radiationLevel = 0D;
-	private double internalRadiationResistance = 0D, externalRadiationResistance = 0D;
-	private boolean radXUsed = false;
-	private boolean radXWoreOff = false;
-	private double radawayBuffer = 0D, radawayBufferSlow = 0D;
-	private double poisonBuffer = 0D;
-	private boolean consumed = false;
-	private double radawayCooldown = 0D;
-	private double recentRadawayAddition = 0D;
-	private double radXCooldown = 0D;
-	private double recentRadXAddition = 0D;
-	private int messageCooldownTime = 0;
-	private double recentPoisonAddition = 0D;
-	private double radiationImmunityTime = 0D;
-	private boolean radiationImmunityStage = false;
-	private boolean shouldWarn = false;
+	protected double totalRads = 0D;
+	protected double radiationLevel = 0D;
+	protected double internalRadiationResistance = 0D, externalRadiationResistance = 0D;
+	protected boolean radXUsed = false;
+	protected boolean radXWoreOff = false;
+	protected double radawayBuffer = 0D, radawayBufferSlow = 0D;
+	protected double poisonBuffer = 0D;
+	protected boolean consumed = false;
+	protected double radawayCooldown = 0D;
+	protected double recentRadawayAddition = 0D;
+	protected double radXCooldown = 0D;
+	protected double recentRadXAddition = 0D;
+	protected int messageCooldownTime = 0;
+	protected double recentPoisonAddition = 0D;
+	protected double radiationImmunityTime = 0D;
+	protected boolean radiationImmunityStage = false;
+	protected boolean shouldWarn = false;
+	protected boolean giveGuidebook = true;
 	
 	public PlayerRads() {
 		maxRads = max_player_rads;
@ -52,6 +53,7 @@ public class PlayerRads implements IEntityRads {
 		nbt.setDouble("radiationImmunityTime", radiationImmunityTime);
 		nbt.setBoolean("radiationImmunityStage", radiationImmunityStage);
 		nbt.setBoolean("shouldWarn", shouldWarn);
+		nbt.setBoolean("giveGuidebook", giveGuidebook);
 		return nbt;
 	}
 	
@ -76,6 +78,9 @@ public class PlayerRads implements IEntityRads {
 		radiationImmunityTime = nbt.getDouble("radiationImmunityTime");
 		radiationImmunityStage = nbt.getBoolean("radiationImmunityStage");
 		shouldWarn = nbt.getBoolean("shouldWarn");
+		if (nbt.hasKey("giveGuidebook")) {
+			giveGuidebook = nbt.getBoolean("giveGuidebook");
+		}
 	}
 	
 	@Override
@ -294,4 +299,14 @@ public class PlayerRads implements IEntityRads {
 	public void setShouldWarn(boolean shouldWarn) {
 		this.shouldWarn = shouldWarn;
 	}
+	
+	@Override
+	public boolean getGiveGuidebook() {
+		return giveGuidebook;
+	}
+	
+	@Override
+	public void setGiveGuidebook(boolean giveGuidebook) {
+		this.giveGuidebook = giveGuidebook;
+	}
 }
--- a/src/main/java/nc/config/NCConfig.java
+++ b/src/main/java/nc/config/NCConfig.java
@ -338,6 +338,7 @@ public class NCConfig {
 	public static boolean register_cofh_fluids;
 	public static boolean register_projecte_emc;
 	
+	public static boolean give_guidebook;
 	public static boolean single_creative_tab;
 	public static boolean ctrl_info;
 	public static boolean jei_chance_items_include_null;
@ -968,6 +969,8 @@ public class NCConfig {
 		Property propertyRegisterProjectEEMC = config.get(CATEGORY_REGISTRATION, "register_projecte_emc", true, Lang.localise("gui.nc.config.register_projecte_emc.comment"));
 		propertyRegisterProjectEEMC.setLanguageKey("gui.nc.config.register_projecte_emc");
 		
+		Property propertyGiveGuidebook = config.get(CATEGORY_MISC, "give_guidebook", true, Lang.localise("gui.nc.config.give_guidebook.comment"));
+		propertyGiveGuidebook.setLanguageKey("gui.nc.config.give_guidebook");
 		Property propertySingleCreativeTab = config.get(CATEGORY_MISC, "single_creative_tab", false, Lang.localise("gui.nc.config.single_creative_tab.comment"));
 		propertySingleCreativeTab.setLanguageKey("gui.nc.config.single_creative_tab");
 		Property propertyCtrlInfo = config.get(CATEGORY_MISC, "ctrl_info", false, Lang.localise("gui.nc.config.ctrl_info.comment"));
@ -1315,6 +1318,7 @@ public class NCConfig {
 		config.setCategoryPropertyOrder(CATEGORY_REGISTRATION, propertyOrderRegistration);
 		
 		List<String> propertyOrderMisc = new ArrayList<>();
+		propertyOrderMisc.add(propertyGiveGuidebook.getName());
 		propertyOrderMisc.add(propertySingleCreativeTab.getName());
 		propertyOrderMisc.add(propertyCtrlInfo.getName());
 		propertyOrderMisc.add(propertyJEIChanceItemsIncludeNull.getName());
@ -1636,6 +1640,7 @@ public class NCConfig {
 			register_cofh_fluids = propertyRegisterCoFHFluids.getBoolean();
 			register_projecte_emc = propertyRegisterProjectEEMC.getBoolean();
 			
+			give_guidebook = propertyGiveGuidebook.getBoolean();
 			single_creative_tab = propertySingleCreativeTab.getBoolean();
 			ctrl_info = propertyCtrlInfo.getBoolean();
 			jei_chance_items_include_null = propertyJEIChanceItemsIncludeNull.getBoolean();
@ -1954,6 +1959,7 @@ public class NCConfig {
 		propertyRegisterCoFHFluids.set(register_cofh_fluids);
 		propertyRegisterProjectEEMC.set(register_projecte_emc);
 		
+		propertyGiveGuidebook.set(give_guidebook);
 		propertySingleCreativeTab.set(single_creative_tab);
 		propertyCtrlInfo.set(ctrl_info);
 		propertyJEIChanceItemsIncludeNull.set(jei_chance_items_include_null);
--- a/src/main/java/nc/handler/PlayerRespawnHandler.java
+++ b/src/main/java/nc/handler/PlayerRespawnHandler.java
@ -2,10 +2,15 @@ package nc.handler;

 import static nc.config.NCConfig.*;

+import nc.ModCheck;
 import nc.capability.radiation.entity.IEntityRads;
+import nc.config.NCConfig;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraftforge.event.entity.player.PlayerEvent;
 import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import net.minecraftforge.fml.common.gameevent.PlayerEvent.PlayerLoggedInEvent;
+import net.minecraftforge.items.ItemHandlerHelper;
+import vazkii.patchouli.common.item.ItemModBook;

 public class PlayerRespawnHandler {
 	
@ -39,6 +44,8 @@ public class PlayerRespawnHandler {
 					newRads.setTotalRads(oldRads.getTotalRads() * radiation_death_persist_fraction % oldRads.getMaxRads(), false);
 					newRads.setRadiationImmunityTime(oldRads.getTotalRads() * radiation_death_immunity_time * 20D / oldRads.getMaxRads());
 				}
+				
+				newRads.setGiveGuidebook(oldRads.getGiveGuidebook());
 			}
 			else {
 				newRads.setConsumedMedicine(oldRads.getConsumedMedicine());
@ -58,6 +65,27 @@ public class PlayerRespawnHandler {
 				newRads.setRecentRadXAddition(oldRads.getRecentRadXAddition());
 				newRads.setShouldWarn(oldRads.getShouldWarn());
 				newRads.setTotalRads(oldRads.getTotalRads(), false);
+				newRads.setGiveGuidebook(oldRads.getGiveGuidebook());
+			}
+		}
+	}
+	
+	@SubscribeEvent
+	public void onPlayerLoggedIn(PlayerLoggedInEvent event) {
+		EntityPlayer player = event.player;
+		if (!player.hasCapability(IEntityRads.CAPABILITY_ENTITY_RADS, null)) {
+			return;
+		}
+		
+		IEntityRads playerRads = player.getCapability(IEntityRads.CAPABILITY_ENTITY_RADS, null);
+		if (playerRads == null) {
+			return;
+		}
+		
+		if (NCConfig.give_guidebook && ModCheck.patchouliLoaded() && playerRads.getGiveGuidebook()) {
+			boolean success = player.inventory.addItemStackToInventory(ItemModBook.forBook("nuclearcraft:guide"));
+			if (success) {
+				playerRads.setGiveGuidebook(false);
 			}
 		}
 	}
--- a/src/main/java/nc/handler/RenderHandler.java
+++ b/src/main/java/nc/handler/RenderHandler.java
@ -37,7 +37,7 @@ public class RenderHandler {
 		NCTools.registerRenders();
 		NCArmor.registerRenders();
 		
-		MinecraftForge.EVENT_BUS.register(new TextureStichHandler());
+		// MinecraftForge.EVENT_BUS.register(new TextureStichHandler());
 		
 		ClientRegistry.bindTileEntitySpecialRenderer(TileTurbineController.class, new RenderTurbineRotor());
 		ClientRegistry.bindTileEntitySpecialRenderer(TileQuantumComputerQubit.class, new RenderQuantumComputerQubit());
--- a/src/main/java/nc/init/NCBlocks.java
+++ b/src/main/java/nc/init/NCBlocks.java
@ -389,8 +389,7 @@ public class NCBlocks {
 			quantum_computer_gate_swap = withName(new BlockQuantumComputerGate.Swap(), "quantum_computer_gate_swap");
 			
 			quantum_computer_connector = withName(new BlockQuantumComputerConnector(), "quantum_computer_connector");
-			// quantum_computer_port = withName(new BlockQuantumComputerPort(),
-			// "quantum_computer_port");
+			// quantum_computer_port = withName(new BlockQuantumComputerPort(), "quantum_computer_port");
 		}
 	}
 	
--- a/src/main/java/nc/init/NCTiles.java
+++ b/src/main/java/nc/init/NCTiles.java
@ -2,26 +2,68 @@ package nc.init;

 import nc.Global;
 import nc.enumm.MetaEnums;
+import nc.integration.crafttweaker.CTRegistration;
 import nc.multiblock.battery.tile.TileBattery;
-import nc.multiblock.fission.salt.tile.*;
-import nc.multiblock.fission.solid.tile.*;
-import nc.multiblock.fission.tile.*;
+import nc.multiblock.fission.salt.tile.TileSaltFissionController;
+import nc.multiblock.fission.salt.tile.TileSaltFissionHeater;
+import nc.multiblock.fission.salt.tile.TileSaltFissionVessel;
+import nc.multiblock.fission.solid.tile.TileSolidFissionCell;
+import nc.multiblock.fission.solid.tile.TileSolidFissionController;
+import nc.multiblock.fission.solid.tile.TileSolidFissionSink;
+import nc.multiblock.fission.tile.TileFissionCasing;
+import nc.multiblock.fission.tile.TileFissionComputerPort;
+import nc.multiblock.fission.tile.TileFissionConductor;
+import nc.multiblock.fission.tile.TileFissionGlass;
+import nc.multiblock.fission.tile.TileFissionIrradiator;
+import nc.multiblock.fission.tile.TileFissionMonitor;
+import nc.multiblock.fission.tile.TileFissionPowerPort;
+import nc.multiblock.fission.tile.TileFissionShield;
+import nc.multiblock.fission.tile.TileFissionSource;
+import nc.multiblock.fission.tile.TileFissionVent;
 import nc.multiblock.fission.tile.manager.TileFissionShieldManager;
-import nc.multiblock.fission.tile.port.*;
+import nc.multiblock.fission.tile.port.TileFissionCellPort;
+import nc.multiblock.fission.tile.port.TileFissionHeaterPort;
+import nc.multiblock.fission.tile.port.TileFissionIrradiatorPort;
+import nc.multiblock.fission.tile.port.TileFissionVesselPort;
 import nc.multiblock.heatExchanger.HeatExchangerTubeType;
-import nc.multiblock.heatExchanger.tile.*;
+import nc.multiblock.heatExchanger.tile.TileCondenserController;
+import nc.multiblock.heatExchanger.tile.TileCondenserTube;
+import nc.multiblock.heatExchanger.tile.TileHeatExchangerCasing;
+import nc.multiblock.heatExchanger.tile.TileHeatExchangerComputerPort;
+import nc.multiblock.heatExchanger.tile.TileHeatExchangerController;
+import nc.multiblock.heatExchanger.tile.TileHeatExchangerGlass;
+import nc.multiblock.heatExchanger.tile.TileHeatExchangerTube;
+import nc.multiblock.heatExchanger.tile.TileHeatExchangerVent;
 import nc.multiblock.qComputer.QuantumGateEnums;
-import nc.multiblock.qComputer.tile.*;
+import nc.multiblock.qComputer.tile.TileQuantumComputerConnector;
+import nc.multiblock.qComputer.tile.TileQuantumComputerController;
+import nc.multiblock.qComputer.tile.TileQuantumComputerGate;
+import nc.multiblock.qComputer.tile.TileQuantumComputerPort;
+import nc.multiblock.qComputer.tile.TileQuantumComputerQubit;
 import nc.multiblock.rtg.tile.TileRTG;
 import nc.multiblock.turbine.TurbineDynamoCoilType;
 import nc.multiblock.turbine.TurbineRotorBladeUtil.TurbineRotorBladeType;
-import nc.multiblock.turbine.tile.*;
+import nc.multiblock.turbine.tile.TileTurbineCasing;
+import nc.multiblock.turbine.tile.TileTurbineCoilConnector;
+import nc.multiblock.turbine.tile.TileTurbineComputerPort;
+import nc.multiblock.turbine.tile.TileTurbineController;
+import nc.multiblock.turbine.tile.TileTurbineDynamoCoil;
+import nc.multiblock.turbine.tile.TileTurbineGlass;
+import nc.multiblock.turbine.tile.TileTurbineInlet;
+import nc.multiblock.turbine.tile.TileTurbineOutlet;
+import nc.multiblock.turbine.tile.TileTurbineRotorBearing;
+import nc.multiblock.turbine.tile.TileTurbineRotorBlade;
+import nc.multiblock.turbine.tile.TileTurbineRotorShaft;
+import nc.multiblock.turbine.tile.TileTurbineRotorStator;
 import nc.tile.TileBin;
 import nc.tile.dummy.TileMachineInterface;
-import nc.tile.generator.*;
+import nc.tile.generator.TileDecayGenerator;
+import nc.tile.generator.TileSolarPanel;
 import nc.tile.passive.TilePassive;
-import nc.tile.processor.*;
-import nc.tile.radiation.*;
+import nc.tile.processor.TileNuclearFurnace;
+import nc.tile.processor.TileProcessor;
+import nc.tile.radiation.TileGeigerCounter;
+import nc.tile.radiation.TileRadiationScrubber;
 import net.minecraftforge.fml.common.registry.GameRegistry;

 public class NCTiles {
@ -71,6 +113,7 @@ public class NCTiles {
 		GameRegistry.registerTileEntity(TileFissionCellPort.class, Global.MOD_ID + ":fission_cell_port");
 		
 		GameRegistry.registerTileEntity(TileFissionVesselPort.class, Global.MOD_ID + ":fission_vessel_port");
+		GameRegistry.registerTileEntity(TileFissionHeaterPort.class, Global.MOD_ID + ":fission_heater_port");
 		GameRegistry.registerTileEntity(TileFissionHeaterPort.Standard.class, Global.MOD_ID + ":fission_heater_port_" + MetaEnums.CoolantHeaterType.STANDARD.getName());
 		GameRegistry.registerTileEntity(TileFissionHeaterPort.Iron.class, Global.MOD_ID + ":fission_heater_port_" + MetaEnums.CoolantHeaterType.IRON.getName());
 		GameRegistry.registerTileEntity(TileFissionHeaterPort.Redstone.class, Global.MOD_ID + ":fission_heater_port_" + MetaEnums.CoolantHeaterType.REDSTONE.getName());
@ -103,11 +146,13 @@ public class NCTiles {
 		GameRegistry.registerTileEntity(TileFissionHeaterPort.LiquidHelium.class, Global.MOD_ID + ":fission_heater_port_" + MetaEnums.CoolantHeaterType2.LIQUID_HELIUM.getName());
 		GameRegistry.registerTileEntity(TileFissionHeaterPort.Enderium.class, Global.MOD_ID + ":fission_heater_port_" + MetaEnums.CoolantHeaterType2.ENDERIUM.getName());
 		GameRegistry.registerTileEntity(TileFissionHeaterPort.Cryotheum.class, Global.MOD_ID + ":fission_heater_port_" + MetaEnums.CoolantHeaterType2.CRYOTHEUM.getName());
+		GameRegistry.registerTileEntity(CTRegistration.TileHeaterPort.class, Global.MOD_ID + ":fission_heater_port_ct");
 		
 		GameRegistry.registerTileEntity(TileFissionShieldManager.class, Global.MOD_ID + ":fission_shield_manager");
 		
 		GameRegistry.registerTileEntity(TileSolidFissionController.class, Global.MOD_ID + ":solid_fission_controller");
 		GameRegistry.registerTileEntity(TileSolidFissionCell.class, Global.MOD_ID + ":solid_fission_cell");
+		GameRegistry.registerTileEntity(TileSolidFissionSink.class, Global.MOD_ID + ":solid_fission_sink");
 		GameRegistry.registerTileEntity(TileSolidFissionSink.Water.class, Global.MOD_ID + ":solid_fission_sink_" + MetaEnums.HeatSinkType.WATER.getName());
 		GameRegistry.registerTileEntity(TileSolidFissionSink.Iron.class, Global.MOD_ID + ":solid_fission_sink_" + MetaEnums.HeatSinkType.IRON.getName());
 		GameRegistry.registerTileEntity(TileSolidFissionSink.Redstone.class, Global.MOD_ID + ":solid_fission_sink_" + MetaEnums.HeatSinkType.REDSTONE.getName());
@ -140,9 +185,11 @@ public class NCTiles {
 		GameRegistry.registerTileEntity(TileSolidFissionSink.LiquidHelium.class, Global.MOD_ID + ":solid_fission_sink_" + MetaEnums.HeatSinkType2.LIQUID_HELIUM.getName());
 		GameRegistry.registerTileEntity(TileSolidFissionSink.Enderium.class, Global.MOD_ID + ":solid_fission_sink_" + MetaEnums.HeatSinkType2.ENDERIUM.getName());
 		GameRegistry.registerTileEntity(TileSolidFissionSink.Cryotheum.class, Global.MOD_ID + ":solid_fission_sink_" + MetaEnums.HeatSinkType2.CRYOTHEUM.getName());
+		GameRegistry.registerTileEntity(CTRegistration.TileSink.class, Global.MOD_ID + ":solid_fission_sink_ct");
 		
 		GameRegistry.registerTileEntity(TileSaltFissionController.class, Global.MOD_ID + ":salt_fission_controller");
 		GameRegistry.registerTileEntity(TileSaltFissionVessel.class, Global.MOD_ID + ":salt_fission_vessel");
+		GameRegistry.registerTileEntity(TileSaltFissionHeater.class, Global.MOD_ID + ":salt_fission_heater");
 		GameRegistry.registerTileEntity(TileSaltFissionHeater.Standard.class, Global.MOD_ID + ":salt_fission_heater_" + MetaEnums.CoolantHeaterType.STANDARD.getName());
 		GameRegistry.registerTileEntity(TileSaltFissionHeater.Iron.class, Global.MOD_ID + ":salt_fission_heater_" + MetaEnums.CoolantHeaterType.IRON.getName());
 		GameRegistry.registerTileEntity(TileSaltFissionHeater.Redstone.class, Global.MOD_ID + ":salt_fission_heater_" + MetaEnums.CoolantHeaterType.REDSTONE.getName());
@ -175,6 +222,7 @@ public class NCTiles {
 		GameRegistry.registerTileEntity(TileSaltFissionHeater.LiquidHelium.class, Global.MOD_ID + ":salt_fission_heater_" + MetaEnums.CoolantHeaterType2.LIQUID_HELIUM.getName());
 		GameRegistry.registerTileEntity(TileSaltFissionHeater.Enderium.class, Global.MOD_ID + ":salt_fission_heater_" + MetaEnums.CoolantHeaterType2.ENDERIUM.getName());
 		GameRegistry.registerTileEntity(TileSaltFissionHeater.Cryotheum.class, Global.MOD_ID + ":salt_fission_heater_" + MetaEnums.CoolantHeaterType2.CRYOTHEUM.getName());
+		GameRegistry.registerTileEntity(CTRegistration.TileHeater.class, Global.MOD_ID + ":salt_fission_heater_ct");
 		
 		GameRegistry.registerTileEntity(TileHeatExchangerController.class, Global.MOD_ID + ":heat_exchanger_controller");
 		GameRegistry.registerTileEntity(TileHeatExchangerCasing.class, Global.MOD_ID + ":heat_exchanger_casing");
@ -194,17 +242,22 @@ public class NCTiles {
 		GameRegistry.registerTileEntity(TileTurbineCasing.class, Global.MOD_ID + ":turbine_casing");
 		GameRegistry.registerTileEntity(TileTurbineGlass.class, Global.MOD_ID + ":turbine_glass");
 		GameRegistry.registerTileEntity(TileTurbineRotorShaft.class, Global.MOD_ID + ":turbine_rotor_shaft");
+		GameRegistry.registerTileEntity(TileTurbineRotorBlade.class, Global.MOD_ID + ":turbine_rotor_blade");
 		GameRegistry.registerTileEntity(TileTurbineRotorBlade.Steel.class, Global.MOD_ID + ":turbine_rotor_blade_" + TurbineRotorBladeType.STEEL.toString());
 		GameRegistry.registerTileEntity(TileTurbineRotorBlade.Extreme.class, Global.MOD_ID + ":turbine_rotor_blade_" + TurbineRotorBladeType.EXTREME.toString());
 		GameRegistry.registerTileEntity(TileTurbineRotorBlade.SicSicCMC.class, Global.MOD_ID + ":turbine_rotor_blade_" + TurbineRotorBladeType.SIC_SIC_CMC.toString());
+		GameRegistry.registerTileEntity(CTRegistration.TileBlade.class, Global.MOD_ID + ":turbine_rotor_blade_ct");
 		GameRegistry.registerTileEntity(TileTurbineRotorStator.class, Global.MOD_ID + ":turbine_rotor_stator");
+		GameRegistry.registerTileEntity(CTRegistration.TileStator.class, Global.MOD_ID + ":turbine_rotor_stator_ct");
 		GameRegistry.registerTileEntity(TileTurbineRotorBearing.class, Global.MOD_ID + ":turbine_rotor_bearing");
+		GameRegistry.registerTileEntity(TileTurbineDynamoCoil.class, Global.MOD_ID + ":turbine_dynamo_coil");
 		GameRegistry.registerTileEntity(TileTurbineDynamoCoil.Magnesium.class, Global.MOD_ID + ":turbine_dynamo_coil_" + TurbineDynamoCoilType.MAGNESIUM.toString());
 		GameRegistry.registerTileEntity(TileTurbineDynamoCoil.Beryllium.class, Global.MOD_ID + ":turbine_dynamo_coil_" + TurbineDynamoCoilType.BERYLLIUM.toString());
 		GameRegistry.registerTileEntity(TileTurbineDynamoCoil.Aluminum.class, Global.MOD_ID + ":turbine_dynamo_coil_" + TurbineDynamoCoilType.ALUMINUM.toString());
 		GameRegistry.registerTileEntity(TileTurbineDynamoCoil.Gold.class, Global.MOD_ID + ":turbine_dynamo_coil_" + TurbineDynamoCoilType.GOLD.toString());
 		GameRegistry.registerTileEntity(TileTurbineDynamoCoil.Copper.class, Global.MOD_ID + ":turbine_dynamo_coil_" + TurbineDynamoCoilType.COPPER.toString());
 		GameRegistry.registerTileEntity(TileTurbineDynamoCoil.Silver.class, Global.MOD_ID + ":turbine_dynamo_coil_" + TurbineDynamoCoilType.SILVER.toString());
+		GameRegistry.registerTileEntity(CTRegistration.TileCoil.class, Global.MOD_ID + ":turbine_dynamo_coil_ct");
 		GameRegistry.registerTileEntity(TileTurbineCoilConnector.class, Global.MOD_ID + ":turbine_coil_connector");
 		GameRegistry.registerTileEntity(TileTurbineInlet.class, Global.MOD_ID + ":turbine_inlet");
 		GameRegistry.registerTileEntity(TileTurbineOutlet.class, Global.MOD_ID + ":turbine_outlet");
--- a/src/main/java/nc/integration/crafttweaker/CTRegistration.java
+++ b/src/main/java/nc/integration/crafttweaker/CTRegistration.java
@ -0,0 +1,458 @@
+package nc.integration.crafttweaker;
+
+import static nc.config.NCConfig.turbine_mb_per_blade;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import crafttweaker.annotations.ZenRegister;
+import crafttweaker.mc1120.util.CraftTweakerPlatformUtils;
+import nc.Global;
+import nc.NuclearCraft;
+import nc.init.NCBlocks;
+import nc.multiblock.fission.FissionPlacement;
+import nc.multiblock.fission.FissionReactor;
+import nc.multiblock.fission.block.BlockFissionPart;
+import nc.multiblock.fission.block.port.BlockFissionFluidPort;
+import nc.multiblock.fission.salt.tile.TileSaltFissionHeater;
+import nc.multiblock.fission.solid.tile.TileSolidFissionSink;
+import nc.multiblock.fission.tile.port.TileFissionHeaterPort;
+import nc.multiblock.turbine.TurbinePlacement;
+import nc.multiblock.turbine.TurbineRotorBladeUtil;
+import nc.multiblock.turbine.TurbineRotorBladeUtil.IRotorBladeType;
+import nc.multiblock.turbine.TurbineRotorBladeUtil.IRotorStatorType;
+import nc.multiblock.turbine.block.BlockTurbinePart;
+import nc.multiblock.turbine.block.BlockTurbineRotorBlade;
+import nc.multiblock.turbine.block.BlockTurbineRotorStator;
+import nc.multiblock.turbine.tile.TileTurbineDynamoCoil;
+import nc.multiblock.turbine.tile.TileTurbineRotorBlade;
+import nc.multiblock.turbine.tile.TileTurbineRotorStator;
+import nc.recipe.AbstractRecipeHandler;
+import nc.recipe.NCRecipes;
+import nc.util.FluidStackHelper;
+import nc.util.InfoHelper;
+import nc.util.Lang;
+import nc.util.NCMath;
+import nc.util.UnitHelper;
+import net.minecraft.block.Block;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.EnumHand;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.text.TextComponentString;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraft.world.World;
+import net.minecraftforge.fluids.FluidStack;
+import stanhebben.zenscript.annotations.ZenClass;
+import stanhebben.zenscript.annotations.ZenMethod;
+
+@ZenClass("mods.nuclearcraft.Registration")
+@ZenRegister
+public class CTRegistration {
+	
+	public static final List<RegistrationInfo> INFO_LIST = new ArrayList<>();
+	
+	public static class TileSink extends TileSolidFissionSink {
+		
+		public TileSink(String sinkName, int coolingRate, String ruleID) {
+			super(sinkName, coolingRate, ruleID);
+		}
+	}
+	
+	@ZenMethod
+	public static void registerFissionSink(String sinkID, int cooling, String rule) {
+		
+		Block sink = NCBlocks.withName(
+				new BlockFissionPart() {
+					@Override
+					public TileEntity createNewTileEntity(World world, int metadata) {
+						return new TileSink(sinkID, cooling, sinkID + "_sink");
+					}
+					
+					@Override
+					public boolean onBlockActivated(World world, BlockPos pos, IBlockState state, EntityPlayer player, EnumHand hand, EnumFacing facing, float hitX, float hitY, float hitZ) {
+						if (player == null || hand != EnumHand.MAIN_HAND || player.isSneaking()) {
+							return false;
+						}
+						return rightClickOnPart(world, pos, player, hand, facing);
+					}
+				},
+				"solid_fission_sink_" + sinkID);
+		
+		INFO_LIST.add(new FissionSinkRegistrationInfo(sink, sinkID, cooling, rule));
+	}
+	
+	public static class TileHeaterPort extends TileFissionHeaterPort {
+		
+		public TileHeaterPort(String coolantName) {
+			super(coolantName);
+		}
+	}
+	
+	public static class TileHeater extends TileSaltFissionHeater {
+		
+		public TileHeater(String heaterName, String coolantName) {
+			super(heaterName, coolantName);
+		}
+	}
+	
+	@ZenMethod
+	public static void registerFissionHeater(String heaterID, String fluidInput, int inputAmount, String fluidOutput, int outputAmount, int cooling, String rule) {
+		
+		Block port = NCBlocks.withName(
+				new BlockFissionFluidPort(TileHeaterPort.class, 303) {
+					@Override
+					public TileEntity createNewTileEntity(World world, int metadata) {
+						return new TileHeaterPort(fluidInput);
+					}
+				},
+				"fission_heater_port_" + heaterID);
+		
+		Block heater = NCBlocks.withName(
+				new BlockFissionPart() {
+					@Override
+					public TileEntity createNewTileEntity(World world, int metadata) {
+						return new TileHeater(heaterID, fluidInput);
+					}
+					
+					@Override
+					public boolean onBlockActivated(World world, BlockPos pos, IBlockState state, EntityPlayer player, EnumHand hand, EnumFacing facing, float hitX, float hitY, float hitZ) {
+						if (player == null || hand != EnumHand.MAIN_HAND || player.isSneaking()) {
+							return false;
+						}
+						
+						if (!world.isRemote) {
+							TileEntity tile = world.getTileEntity(pos);
+							if (tile instanceof TileSaltFissionHeater) {
+								TileSaltFissionHeater heater = (TileSaltFissionHeater) tile;
+								FissionReactor reactor = heater.getMultiblock();
+								if (reactor != null) {
+									FluidStack fluidStack = FluidStackHelper.getFluid(player.getHeldItem(hand));
+									if (heater.canModifyFilter(0) && heater.getTanks().get(0).isEmpty() && fluidStack != null && !FluidStackHelper.stacksEqual(heater.getFilterTanks().get(0).getFluid(), fluidStack) && heater.getTanks().get(0).canFillFluidType(fluidStack)) {
+										player.sendMessage(new TextComponentString(Lang.localise("message.nuclearcraft.filter") + " " + TextFormatting.BOLD + Lang.localise(fluidStack.getUnlocalizedName())));
+										FluidStack filter = fluidStack.copy();
+										filter.amount = 1000;
+										heater.getFilterTanks().get(0).setFluid(filter);
+										heater.onFilterChanged(0);
+									}
+									else {
+										player.openGui(NuclearCraft.instance, 203, world, pos.getX(), pos.getY(), pos.getZ());
+									}
+									return true;
+								}
+							}
+						}
+						return rightClickOnPart(world, pos, player, hand, facing, true);
+					}
+				},
+				"salt_fission_heater_" + heaterID);
+		
+		INFO_LIST.add(new FissionHeaterPortRegistrationInfo(port, heaterID));
+		INFO_LIST.add(new FissionHeaterRegistrationInfo(heater, heaterID, fluidInput, inputAmount, fluidOutput, outputAmount, cooling, rule));
+	}
+	
+	public static class TileCoil extends TileTurbineDynamoCoil {
+		
+		public TileCoil(String partName, double conductivity, String ruleID) {
+			super(partName, conductivity, ruleID);
+		}
+	}
+	
+	@ZenMethod
+	public static void registerTurbineCoil(String coilID, double conductivity, String rule) {
+		
+		Block coil = NCBlocks.withName(
+				new BlockTurbinePart() {
+					@Override
+					public TileEntity createNewTileEntity(World world, int metadata) {
+						return new TileCoil(coilID, conductivity, coilID + "_coil");
+					}
+					
+					@Override
+					public boolean onBlockActivated(World world, BlockPos pos, IBlockState state, EntityPlayer player, EnumHand hand, EnumFacing facing, float hitX, float hitY, float hitZ) {
+						if (player == null || hand != EnumHand.MAIN_HAND || player.isSneaking()) {
+							return false;
+						}
+						return rightClickOnPart(world, pos, player, hand, facing);
+					}
+				},
+				"turbine_dynamo_coil_" + coilID);
+		
+		INFO_LIST.add(new TurbineCoilRegistrationInfo(coil, coilID, conductivity, rule));
+	}
+	
+	public static class TileBlade extends TileTurbineRotorBlade {
+		
+		final Block bladeBlock;
+		
+		public TileBlade(IRotorBladeType bladeType, Block bladeBlock) {
+			super(bladeType);
+			this.bladeBlock = bladeBlock;
+		}
+		
+		@Override
+		public IBlockState getRenderState() {
+			return bladeBlock.getDefaultState().withProperty(TurbineRotorBladeUtil.DIR, dir);
+		}
+	}
+	
+	@ZenMethod
+	public static void registerTurbineBlade(String bladeID, double efficiency, double expansionCoefficient) {
+		
+		IRotorBladeType bladeType = new IRotorBladeType() {
+			
+			@Override
+			public String getName() {
+				return bladeID;
+			}
+			
+			@Override
+			public double getEfficiency() {
+				return efficiency;
+			}
+			
+			@Override
+			public double getExpansionCoefficient() {
+				return expansionCoefficient;
+			}
+			
+		};
+		
+		Block blade = NCBlocks.withName(
+				new BlockTurbineRotorBlade(null) {
+					@Override
+					public TileEntity createNewTileEntity(World world, int metadata) {
+						return new TileBlade(bladeType, this);
+					}
+				},
+				"turbine_rotor_blade_" + bladeID);
+		
+		INFO_LIST.add(new TurbineBladeRegistrationInfo(blade, efficiency, expansionCoefficient));
+	}
+	
+	public static class TileStator extends TileTurbineRotorStator {
+		
+		final Block bladeBlock;
+		
+		public TileStator(IRotorStatorType statorType, Block bladeBlock) {
+			super(statorType);
+			this.bladeBlock = bladeBlock;
+		}
+		
+		@Override
+		public IRotorBladeType getBladeType() {
+			return statorType;
+		}
+		
+		@Override
+		public IBlockState getRenderState() {
+			return bladeBlock.getDefaultState().withProperty(TurbineRotorBladeUtil.DIR, dir);
+		}
+	}
+	
+	@ZenMethod
+	public static void registerTurbineStator(String statorID, double expansionCoefficient) {
+		
+		IRotorStatorType statorType = new IRotorStatorType() {
+			
+			@Override
+			public String getName() {
+				return statorID;
+			}
+			
+			@Override
+			public double getExpansionCoefficient() {
+				return expansionCoefficient;
+			}
+			
+		};
+		
+		Block stator = NCBlocks.withName(
+				new BlockTurbineRotorStator() {
+					@Override
+					public TileEntity createNewTileEntity(World world, int metadata) {
+						return new TileBlade(statorType, this);
+					}
+				},
+				"turbine_rotor_stator_" + statorID);
+		
+		INFO_LIST.add(new TurbineStatorRegistrationInfo(stator, expansionCoefficient));
+	}
+	
+	// Registration Wrapper
+	
+	public abstract static class RegistrationInfo {
+		public abstract void preInit();
+		
+		public void recipeInit() {}
+		
+		public abstract void init();
+		
+		public abstract void postInit();
+	}
+	
+	public static class BlockRegistrationInfo extends RegistrationInfo {
+		
+		protected final Block block;
+		
+		public BlockRegistrationInfo(Block block) {
+			this.block = block;
+		}
+		
+		@Override
+		public void preInit() {
+			registerBlock();
+			
+			if (CraftTweakerPlatformUtils.isClient()) {
+				registerRender();
+			}
+		}
+		
+		public void registerBlock() {
+			NCBlocks.registerBlock(block);
+		}
+		
+		public void registerRender() {
+			NCBlocks.registerRender(block);
+		}
+		
+		@Override
+		public void init() {}
+		
+		@Override
+		public void postInit() {}
+	}
+	
+	public static class TileBlockRegistrationInfo extends BlockRegistrationInfo {
+		
+		public TileBlockRegistrationInfo(Block block) {
+			super(block);
+		}
+	}
+	
+	public static class FissionSinkRegistrationInfo extends TileBlockRegistrationInfo {
+		
+		protected final String sinkID, rule;
+		protected final int cooling;
+		
+		FissionSinkRegistrationInfo(Block block, String sinkID, int cooling, String rule) {
+			super(block);
+			this.sinkID = sinkID;
+			this.cooling = cooling;
+			this.rule = rule;
+		}
+		
+		@Override
+		public void registerBlock() {
+			NCBlocks.registerBlock(block, TextFormatting.BLUE, new String[] {Lang.localise("tile." + Global.MOD_ID + ".solid_fission_sink.cooling_rate") + " " + cooling + " H/t"}, TextFormatting.AQUA, InfoHelper.NULL_ARRAY);
+		}
+		
+		@Override
+		public void init() {
+			super.init();
+			FissionPlacement.addRule(sinkID + "_sink", rule, block);
+		}
+	}
+	
+	public static class FissionHeaterRegistrationInfo extends TileBlockRegistrationInfo {
+		
+		protected final String heaterID, fluidInput, fluidOutput, rule;
+		protected final int inputAmount, outputAmount, cooling;
+		
+		FissionHeaterRegistrationInfo(Block block, String heaterID, String fluidInput, int inputAmount, String fluidOutput, int outputAmount, int cooling, String rule) {
+			super(block);
+			this.heaterID = heaterID;
+			this.fluidInput = fluidInput;
+			this.inputAmount = inputAmount;
+			this.fluidOutput = fluidOutput;
+			this.outputAmount = outputAmount;
+			this.cooling = cooling;
+			this.rule = rule;
+		}
+		
+		@Override
+		public void registerBlock() {
+			NCBlocks.registerBlock(block, TextFormatting.BLUE, new String[] {Lang.localise("tile." + Global.MOD_ID + ".salt_fission_heater.cooling_rate") + " " + cooling + " H/t"}, TextFormatting.AQUA, InfoHelper.NULL_ARRAY);
+		}
+		
+		@Override
+		public void recipeInit() {
+			NCRecipes.coolant_heater.addRecipe(AbstractRecipeHandler.fluidStack(fluidInput, inputAmount), AbstractRecipeHandler.fluidStack(fluidOutput, outputAmount), cooling, heaterID + "_heater");
+		}
+		
+		@Override
+		public void init() {
+			super.init();
+			FissionPlacement.addRule(heaterID + "_heater", rule, block);
+		}
+	}
+	
+	public static class FissionHeaterPortRegistrationInfo extends TileBlockRegistrationInfo {
+		
+		FissionHeaterPortRegistrationInfo(Block block, String heaterID) {
+			super(block);
+		}
+		
+		@Override
+		public void registerBlock() {
+			NCBlocks.registerBlock(block);
+		}
+	}
+	
+	public static class TurbineCoilRegistrationInfo extends TileBlockRegistrationInfo {
+		
+		protected final String coilID, rule;
+		protected final double conductivity;
+		
+		TurbineCoilRegistrationInfo(Block block, String coilID, double conductivity, String rule) {
+			super(block);
+			this.coilID = coilID;
+			this.conductivity = conductivity;
+			this.rule = rule;
+		}
+		
+		@Override
+		public void registerBlock() {
+			NCBlocks.registerBlock(block, TextFormatting.LIGHT_PURPLE, new String[] {Lang.localise("tile." + Global.MOD_ID + ".turbine_dynamo_coil.conductivity") + " " + NCMath.decimalPlaces(100D * conductivity, 1) + "%"}, TextFormatting.AQUA, InfoHelper.NULL_ARRAY);
+		}
+		
+		@Override
+		public void init() {
+			super.init();
+			TurbinePlacement.addRule(coilID + "_coil", rule, block);
+		}
+	}
+	
+	public static class TurbineBladeRegistrationInfo extends TileBlockRegistrationInfo {
+		
+		protected final double efficiency, expansionCoefficient;
+		
+		TurbineBladeRegistrationInfo(Block block, double efficiency, double expansionCoefficient) {
+			super(block);
+			this.efficiency = efficiency;
+			this.expansionCoefficient = expansionCoefficient;
+		}
+		
+		@Override
+		public void registerBlock() {
+			NCBlocks.registerBlock(block, new TextFormatting[] {TextFormatting.LIGHT_PURPLE, TextFormatting.GRAY}, new String[] {Lang.localise(NCBlocks.fixedLine("turbine_rotor_blade_efficiency"), Math.round(100D * efficiency) + "%"), Lang.localise(NCBlocks.fixedLine("turbine_rotor_blade_expansion"), Math.round(100D * expansionCoefficient) + "%")}, TextFormatting.AQUA, InfoHelper.formattedInfo(NCBlocks.infoLine("turbine_rotor_blade"), UnitHelper.prefix(turbine_mb_per_blade, 5, "B/t", -1)));
+		}
+	}
+	
+	public static class TurbineStatorRegistrationInfo extends TileBlockRegistrationInfo {
+		
+		protected final double expansionCoefficient;
+		
+		TurbineStatorRegistrationInfo(Block block, double expansionCoefficient) {
+			super(block);
+			this.expansionCoefficient = expansionCoefficient;
+		}
+		
+		@Override
+		public void registerBlock() {
+			NCBlocks.registerBlock(block, TextFormatting.GRAY, new String[] {Lang.localise(NCBlocks.fixedLine("turbine_rotor_stator_expansion"), Math.round(100D * expansionCoefficient) + "%")}, TextFormatting.AQUA, InfoHelper.formattedInfo(NCBlocks.infoLine("turbine_rotor_stator")));
+		}
+	}
+}
--- a/src/main/java/nc/integration/crafttweaker/NCCraftTweaker.java
+++ b/src/main/java/nc/integration/crafttweaker/NCCraftTweaker.java
@ -1,23 +1,84 @@
 package nc.integration.crafttweaker;

-import static nc.recipe.NCRecipes.*;
+import static nc.recipe.NCRecipes.alloy_furnace;
+import static nc.recipe.NCRecipes.assembler;
+import static nc.recipe.NCRecipes.centrifuge;
+import static nc.recipe.NCRecipes.chemical_reactor;
+import static nc.recipe.NCRecipes.condenser;
+import static nc.recipe.NCRecipes.crystallizer;
+import static nc.recipe.NCRecipes.decay_generator;
+import static nc.recipe.NCRecipes.decay_hastener;
+import static nc.recipe.NCRecipes.electrolyzer;
+import static nc.recipe.NCRecipes.enricher;
+import static nc.recipe.NCRecipes.extractor;
+import static nc.recipe.NCRecipes.fission_heating;
+import static nc.recipe.NCRecipes.fission_irradiator;
+import static nc.recipe.NCRecipes.fission_moderator;
+import static nc.recipe.NCRecipes.fission_reflector;
+import static nc.recipe.NCRecipes.fuel_reprocessor;
+import static nc.recipe.NCRecipes.fusion;
+import static nc.recipe.NCRecipes.heat_exchanger;
+import static nc.recipe.NCRecipes.infuser;
+import static nc.recipe.NCRecipes.ingot_former;
+import static nc.recipe.NCRecipes.manufactory;
+import static nc.recipe.NCRecipes.melter;
+import static nc.recipe.NCRecipes.pebble_fission;
+import static nc.recipe.NCRecipes.pressurizer;
+import static nc.recipe.NCRecipes.radiation_block_mutation;
+import static nc.recipe.NCRecipes.radiation_block_purification;
+import static nc.recipe.NCRecipes.radiation_scrubber;
+import static nc.recipe.NCRecipes.rock_crusher;
+import static nc.recipe.NCRecipes.salt_fission;
+import static nc.recipe.NCRecipes.salt_mixer;
+import static nc.recipe.NCRecipes.separator;
+import static nc.recipe.NCRecipes.solid_fission;
+import static nc.recipe.NCRecipes.supercooler;
+import static nc.recipe.NCRecipes.turbine;

 import com.google.common.collect.Lists;

 import crafttweaker.CraftTweakerAPI;
 import crafttweaker.annotations.ZenRegister;
 import crafttweaker.api.entity.IEntityLivingBase;
-import crafttweaker.api.item.*;
 import crafttweaker.api.item.IIngredient;
+import crafttweaker.api.item.IItemStack;
+import crafttweaker.api.item.IngredientStack;
+import crafttweaker.api.liquid.ILiquidStack;
 import crafttweaker.api.minecraft.CraftTweakerMC;
 import crafttweaker.api.oredict.IOreDictEntry;
+import crafttweaker.mc1120.util.CraftTweakerPlatformUtils;
+import nc.Global;
+import nc.ModCheck;
 import nc.capability.radiation.entity.IEntityRads;
-import nc.radiation.*;
-import nc.recipe.*;
-import nc.recipe.ingredient.*;
+import nc.enumm.MetaEnums;
+import nc.init.NCBlocks;
+import nc.multiblock.PlacementRule;
+import nc.multiblock.fission.FissionPlacement;
+import nc.multiblock.fission.block.BlockFissionPart;
+import nc.multiblock.fission.solid.tile.TileSolidFissionSink;
+import nc.multiblock.fission.tile.IFissionPart;
+import nc.radiation.RadSources;
+import nc.radiation.RadiationHelper;
+import nc.recipe.IngredientSorption;
+import nc.recipe.ProcessorRecipeHandler;
+import nc.recipe.ingredient.IItemIngredient;
+import nc.recipe.ingredient.OreIngredient;
+import net.minecraft.block.Block;
+import net.minecraft.block.state.IBlockState;
 import net.minecraft.client.util.RecipeItemHelper;
+import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.ItemStack;
-import stanhebben.zenscript.annotations.*;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.EnumHand;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fml.common.registry.GameRegistry;
+import stanhebben.zenscript.annotations.Optional;
+import stanhebben.zenscript.annotations.ZenClass;
+import stanhebben.zenscript.annotations.ZenExpansion;
+import stanhebben.zenscript.annotations.ZenMethod;

 public class NCCraftTweaker {
 	
@ -791,7 +852,6 @@ public class NCCraftTweaker {
 		}
 	}
 	
-	// TODO
 	@ZenClass("mods.nuclearcraft.SaltFission")
 	@ZenRegister
 	public static class SaltFissionMethods {
@ -1046,36 +1106,98 @@ public class NCCraftTweaker {
 			}
 			else if (ingredient instanceof IItemStack) {
 				ItemStack stack = CTHelper.getItemStack((IItemStack) ingredient);
-				if (stack.isEmpty()) {
-					return 0D;
-				}
-				return RadSources.STACK_MAP.get(RecipeItemHelper.pack(stack)) * stack.getCount();
+				return stack.isEmpty() ? 0D : RadSources.STACK_MAP.get(RecipeItemHelper.pack(stack)) * stack.getCount();
 			}
 			else if (ingredient instanceof IOreDictEntry) {
-				String oreName = ((IOreDictEntry) ingredient).getName();
-				int amount = ((IOreDictEntry) ingredient).getAmount();
-				return RadSources.ORE_MAP.getDouble(oreName) * amount;
+				IOreDictEntry ore = (IOreDictEntry) ingredient;
+				return RadSources.ORE_MAP.getDouble(ore.getName()) * ore.getAmount();
 			}
 			else if (ingredient instanceof IngredientStack) {
-				IItemIngredient ing = CTHelper.buildOreIngredientArray(ingredient, true);
-				if (ing instanceof OreIngredient) {
-					String oreName = ((OreIngredient) ing).oreName;
-					int amount = ((OreIngredient) ing).stackSize;
-					return RadSources.ORE_MAP.getDouble(oreName) * amount;
+				IItemIngredient i = CTHelper.buildOreIngredientArray(ingredient, true);
+				if (i instanceof OreIngredient) {
+					OreIngredient ore = (OreIngredient) i;
+					return RadSources.ORE_MAP.getDouble(ore.oreName) * ore.stackSize;
 				}
 				else {
-					ItemStack stack = ing.getStack();
-					if (stack == null || stack.isEmpty()) {
-						return 0D;
-					}
-					return RadSources.STACK_MAP.get(RecipeItemHelper.pack(stack)) * stack.getCount();
+					ItemStack stack = i.getStack();
+					return stack == null || stack.isEmpty() ? 0D : RadSources.STACK_MAP.get(RecipeItemHelper.pack(stack)) * stack.getCount();
 				}
 			}
+			else if (ingredient instanceof ILiquidStack) {
+				FluidStack stack = CTHelper.getFluidStack((ILiquidStack) ingredient);
+				return stack == null ? 0D : RadiationHelper.getRadiationFromFluid(stack, 1D);
+			}
 			else {
 				return 0D;
 			}
 		}
 		
+		@ZenMethod
+		public static void addToRadiationBlacklist(IIngredient ingredient) {
+			if (ingredient == null) {
+				return;
+			}
+			else if (ingredient instanceof IItemStack) {
+				RadSources.RUNNABLES.add(() -> RadSources.addToStackBlacklist(CTHelper.getItemStack((IItemStack) ingredient)));
+			}
+			else if (ingredient instanceof IOreDictEntry) {
+				RadSources.RUNNABLES.add(() -> RadSources.addToOreBlacklist(((IOreDictEntry) ingredient).getName()));
+			}
+			else if (ingredient instanceof IngredientStack) {
+				IItemIngredient i = CTHelper.buildOreIngredientArray(ingredient, true);
+				if (i instanceof OreIngredient) {
+					RadSources.RUNNABLES.add(() -> RadSources.addToOreBlacklist(((OreIngredient) i).oreName));
+				}
+				else if (i.getStack() != null) {
+					RadSources.RUNNABLES.add(() -> RadSources.addToStackBlacklist(i.getStack()));
+				}
+			}
+			else if (ingredient instanceof ILiquidStack) {
+				FluidStack stack = CTHelper.getFluidStack((ILiquidStack) ingredient);
+				if (stack != null && stack.getFluid() != null) {
+					RadSources.RUNNABLES.add(() -> RadSources.addToFluidBlacklist(stack.getFluid().getName()));
+				}
+			}
+		}
+		
+		@ZenMethod
+		public static void setRadiationLevel(IIngredient ingredient, double radiation) {
+			if (ingredient == null) {
+				return;
+			}
+			else if (ingredient instanceof IItemStack) {
+				RadSources.RUNNABLES.add(() -> RadSources.addToStackMap(CTHelper.getItemStack((IItemStack) ingredient), radiation));
+			}
+			else if (ingredient instanceof IOreDictEntry) {
+				RadSources.RUNNABLES.add(() -> RadSources.addToOreMap(((IOreDictEntry) ingredient).getName(), radiation));
+			}
+			else if (ingredient instanceof IngredientStack) {
+				IItemIngredient i = CTHelper.buildOreIngredientArray(ingredient, true);
+				if (i instanceof OreIngredient) {
+					RadSources.RUNNABLES.add(() -> RadSources.addToOreMap(((OreIngredient) i).oreName, radiation));
+				}
+				else if (i.getStack() != null) {
+					RadSources.RUNNABLES.add(() -> RadSources.addToStackMap(i.getStack(), radiation));
+				}
+			}
+			else if (ingredient instanceof ILiquidStack) {
+				FluidStack stack = CTHelper.getFluidStack((ILiquidStack) ingredient);
+				if (stack != null && stack.getFluid() != null) {
+					RadSources.RUNNABLES.add(() -> RadSources.addToFluidMap(stack.getFluid().getName(), radiation));
+				}
+			}
+		}
+		
+		@ZenMethod
+		public static void setMaterialRadiationLevel(String oreSuffix, double radiation) {
+			RadSources.RUNNABLES.add(() -> RadSources.putMaterial(radiation, oreSuffix));
+		}
+		
+		@ZenMethod
+		public static void setFoodRadiationStats(IItemStack food, double radiation, double resistance) {
+			RadSources.RUNNABLES.add(() -> RadSources.addToFoodMaps(CTHelper.getItemStack(food), radiation, resistance));
+		}
+		
 		@ZenMethod
 		public static void setRadiationImmunityGameStages(boolean defaultImmunity, String... stageNames) {
 			nc.radiation.RadiationHandler.default_rad_immunity = defaultImmunity;
--- a/src/main/java/nc/integration/tconstruct/conarm/trait/ArmorTraitMoldable.java
+++ b/src/main/java/nc/integration/tconstruct/conarm/trait/ArmorTraitMoldable.java
@ -1,10 +1,11 @@
 package nc.integration.tconstruct.conarm.trait;

+import c4.conarm.lib.traits.AbstractArmorTraitLeveled;
 import net.minecraft.nbt.NBTTagCompound;
-import slimeknights.tconstruct.library.traits.AbstractTraitLeveled;
-import slimeknights.tconstruct.library.utils.*;
+import slimeknights.tconstruct.library.utils.TagUtil;
+import slimeknights.tconstruct.library.utils.Tags;

-public class ArmorTraitMoldable extends AbstractTraitLeveled {
+public class ArmorTraitMoldable extends AbstractArmorTraitLeveled implements IArmorTraitNC {
 	
 	public ArmorTraitMoldable(int levels) {
 		super("moldable_armor", String.valueOf(levels), 0x62230E, 3, 1);
--- a/src/main/java/nc/integration/tconstruct/conarm/trait/ArmorTraitPoisonous.java
+++ b/src/main/java/nc/integration/tconstruct/conarm/trait/ArmorTraitPoisonous.java
@ -9,7 +9,7 @@ import net.minecraft.potion.PotionEffect;
 import net.minecraft.util.DamageSource;
 import net.minecraftforge.event.entity.living.LivingHurtEvent;

-public class ArmorTraitPoisonous extends AbstractArmorTrait {
+public class ArmorTraitPoisonous extends AbstractArmorTrait implements IArmorTraitNC {
 	
 	public ArmorTraitPoisonous() {
 		super("poisonous", 0xFFFFFF);
--- a/src/main/java/nc/integration/tconstruct/conarm/trait/ArmorTraitUplifting.java
+++ b/src/main/java/nc/integration/tconstruct/conarm/trait/ArmorTraitUplifting.java
@ -10,7 +10,7 @@ import net.minecraft.util.DamageSource;
 import net.minecraft.util.text.TextFormatting;
 import net.minecraftforge.event.entity.living.LivingHurtEvent;

-public class ArmorTraitUplifting extends AbstractArmorTrait {
+public class ArmorTraitUplifting extends AbstractArmorTrait implements IArmorTraitNC {
 	
 	public ArmorTraitUplifting() {
 		super("uplifting", TextFormatting.LIGHT_PURPLE);
--- a/src/main/java/nc/integration/tconstruct/conarm/trait/ArmorTraitWithering.java
+++ b/src/main/java/nc/integration/tconstruct/conarm/trait/ArmorTraitWithering.java
@ -10,7 +10,7 @@ import net.minecraft.util.DamageSource;
 import net.minecraft.util.text.TextFormatting;
 import net.minecraftforge.event.entity.living.LivingHurtEvent;

-public class ArmorTraitWithering extends AbstractArmorTrait {
+public class ArmorTraitWithering extends AbstractArmorTrait implements IArmorTraitNC {
 	
 	public ArmorTraitWithering() {
 		super("withering", TextFormatting.DARK_GRAY);
--- a/src/main/java/nc/integration/tconstruct/conarm/trait/IArmorTraitNC.java
+++ b/src/main/java/nc/integration/tconstruct/conarm/trait/IArmorTraitNC.java
@ -0,0 +1,13 @@
+package nc.integration.tconstruct.conarm.trait;
+
+import c4.conarm.lib.traits.IArmorTrait;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.world.World;
+
+public interface IArmorTraitNC extends IArmorTrait {
+	
+	@Override
+	public default void onAbilityTick(int var1, World var2, EntityPlayer var3) {
+		
+	}
+}
--- a/src/main/java/nc/integration/tconstruct/trait/ITraitNC.java
+++ b/src/main/java/nc/integration/tconstruct/trait/ITraitNC.java
@ -0,0 +1,14 @@
+package nc.integration.tconstruct.trait;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import slimeknights.tconstruct.library.traits.ITrait;
+
+public interface ITraitNC extends ITrait {
+	
+	@Override
+	public default void onUpdate(ItemStack tool, World world, Entity entity, int itemSlot, boolean isSelected) {
+		
+	}
+}
--- a/src/main/java/nc/integration/tconstruct/trait/TraitMoldable.java
+++ b/src/main/java/nc/integration/tconstruct/trait/TraitMoldable.java
@ -4,7 +4,7 @@ import net.minecraft.nbt.NBTTagCompound;
 import slimeknights.tconstruct.library.traits.AbstractTraitLeveled;
 import slimeknights.tconstruct.library.utils.*;

-public class TraitMoldable extends AbstractTraitLeveled {
+public class TraitMoldable extends AbstractTraitLeveled implements ITraitNC {
 	
 	public TraitMoldable(int levels) {
 		super("moldable", String.valueOf(levels), 0x62230E, 3, 1);
--- a/src/main/java/nc/integration/tconstruct/trait/TraitUplifting.java
+++ b/src/main/java/nc/integration/tconstruct/trait/TraitUplifting.java
@ -10,7 +10,7 @@ import net.minecraft.util.text.TextFormatting;
 import net.minecraft.world.World;
 import slimeknights.tconstruct.library.traits.AbstractTrait;

-public class TraitUplifting extends AbstractTrait {
+public class TraitUplifting extends AbstractTrait implements ITraitNC {
 	
 	public TraitUplifting() {
 		super("uplifting", TextFormatting.LIGHT_PURPLE);
--- a/src/main/java/nc/integration/tconstruct/trait/TraitWithering.java
+++ b/src/main/java/nc/integration/tconstruct/trait/TraitWithering.java
@ -7,7 +7,7 @@ import net.minecraft.potion.PotionEffect;
 import net.minecraft.util.text.TextFormatting;
 import slimeknights.tconstruct.library.traits.AbstractTrait;

-public class TraitWithering extends AbstractTrait {
+public class TraitWithering extends AbstractTrait implements ITraitNC {
 	
 	public TraitWithering() {
 		super("withering", TextFormatting.DARK_GRAY);
--- a/src/main/java/nc/item/ItemRadShielding.java
+++ b/src/main/java/nc/item/ItemRadShielding.java
@ -4,7 +4,9 @@ import static nc.config.NCConfig.*;

 import nc.capability.radiation.entity.IEntityRads;
 import nc.capability.radiation.resistance.IRadiationResistance;
+import nc.config.NCConfig;
 import nc.enumm.MetaEnums;
+import nc.init.NCItems;
 import nc.radiation.RadiationHelper;
 import nc.util.*;
 import net.minecraft.entity.player.EntityPlayer;
@ -17,6 +19,7 @@ import net.minecraft.util.text.TextComponentString;
 import net.minecraft.world.World;
 import net.minecraftforge.fluids.capability.CapabilityFluidHandler;
 import net.minecraftforge.items.CapabilityItemHandler;
+import net.minecraftforge.items.ItemHandlerHelper;

 public class ItemRadShielding extends NCItemMeta<MetaEnums.RadShieldingType> {
 	
@ -76,8 +79,18 @@ public class ItemRadShielding extends NCItemMeta<MetaEnums.RadShieldingType> {
 			return actionResult(false, stack);
 		}
 		
+		if (!player.isCreative()) {
+			stack.shrink(1);
+			
+			for (int i = MetaEnums.RadShieldingType.values().length; i > 0; i--) {
+				if (resistance.getShieldingRadResistance() >= NCConfig.radiation_shielding_level[i - 1]) {
+					ItemHandlerHelper.giveItemToPlayer(player, new ItemStack(NCItems.rad_shielding, 1, i - 1));
+					break;
+				}
+			}
+		}
+		
 		resistance.setShieldingRadResistance(newResistance);
-		stack.shrink(1);
 		tile.markDirty();
 		
 		if (!world.isRemote) {
--- a/src/main/java/nc/multiblock/fission/salt/block/BlockSaltFissionHeater.java
+++ b/src/main/java/nc/multiblock/fission/salt/block/BlockSaltFissionHeater.java
@ -26,8 +26,7 @@ public class BlockSaltFissionHeater extends BlockFissionMetaPart<MetaEnums.Coola
 	
 	@Override
 	protected BlockStateContainer createBlockState() {
-		// return new BlockStateContainer(this, TYPE, DOWN, UP, NORTH, SOUTH,
-		// WEST, EAST);
+		// return new BlockStateContainer(this, TYPE, DOWN, UP, NORTH, SOUTH, WEST, EAST);
 		return new BlockStateContainer(this, TYPE);
 	}
 	
@ -70,20 +69,10 @@ public class BlockSaltFissionHeater extends BlockFissionMetaPart<MetaEnums.Coola
 		return new TileSaltFissionHeater.Standard();
 	}
 	
-	/* private static final PropertySidedEnum<SaltFissionHeaterSetting> DOWN = PropertySidedEnum.create("down", SaltFissionHeaterSetting.class, EnumFacing.DOWN); private static final PropertySidedEnum<SaltFissionHeaterSetting> UP = PropertySidedEnum.create("up", SaltFissionHeaterSetting.class, EnumFacing.UP); private static final PropertySidedEnum<SaltFissionHeaterSetting> NORTH = PropertySidedEnum.create("north", SaltFissionHeaterSetting.class, EnumFacing.NORTH); private static final PropertySidedEnum<SaltFissionHeaterSetting> SOUTH = PropertySidedEnum.create("south", SaltFissionHeaterSetting.class, EnumFacing.SOUTH); private static final PropertySidedEnum<SaltFissionHeaterSetting> WEST = PropertySidedEnum.create("west", SaltFissionHeaterSetting.class, EnumFacing.WEST); private static final PropertySidedEnum<SaltFissionHeaterSetting> EAST = PropertySidedEnum.create("east", SaltFissionHeaterSetting.class, EnumFacing.EAST);
-	 * 
-	 * @Override public SaltFissionHeaterSetting getProperty(IBlockAccess world, BlockPos pos, EnumFacing facing) { TileEntity tile = world.getTileEntity(pos); if (tile instanceof TileSaltFissionHeater) { return ((TileSaltFissionHeater) tile).getHeaterSetting(facing); } return SaltFissionHeaterSetting.DISABLED; } */
-	
 	@Override
 	public IBlockState getActualState(IBlockState state, IBlockAccess world, BlockPos pos) {
-		// return state.withProperty(DOWN, getProperty(world, pos,
-		// EnumFacing.DOWN)).withProperty(UP, getProperty(world, pos,
-		// EnumFacing.UP)).withProperty(NORTH, getProperty(world, pos,
-		// EnumFacing.NORTH)).withProperty(SOUTH, getProperty(world, pos,
-		// EnumFacing.SOUTH)).withProperty(WEST, getProperty(world, pos,
-		// EnumFacing.WEST)).withProperty(EAST, getProperty(world, pos,
-		// EnumFacing.EAST));
-		return state;
+		// return state.withProperty(DOWN, getProperty(world, pos, EnumFacing.DOWN)).withProperty(UP, getProperty(world, pos, EnumFacing.UP)).withProperty(NORTH, getProperty(world, pos, EnumFacing.NORTH)).withProperty(SOUTH, getProperty(world, pos, EnumFacing.SOUTH)).withProperty(WEST, getProperty(world, pos, EnumFacing.WEST)).withProperty(EAST, getProperty(world, pos, EnumFacing.EAST));
+		return super.getActualState(state, world, pos);
 	}
 	
 	@Override
@ -118,16 +107,4 @@ public class BlockSaltFissionHeater extends BlockFissionMetaPart<MetaEnums.Coola
 		}
 		return rightClickOnPart(world, pos, player, hand, facing, true);
 	}	
-	
-	/* @Override public boolean onBlockActivated(World world, BlockPos pos, IBlockState state, EntityPlayer player, EnumHand hand, EnumFacing facing, float hitX, float hitY, float hitZ) { if (hand != EnumHand.MAIN_HAND || player == null) return false;
-	 * 
-	 * if (ItemMultitool.isMultitool(player.getHeldItem(hand))) { TileEntity tile = world.getTileEntity(pos); if (tile instanceof TileSaltFissionHeater) { TileSaltFissionHeater heater = (TileSaltFissionHeater) tile; EnumFacing side = player.isSneaking() ? facing.getOpposite() : facing; heater.toggleHeaterSetting(side); if (!world.isRemote) player.sendMessage(getToggleMessage(player, heater, side)); return true; } }
-	 * 
-	 * return super.onBlockActivated(world, pos, state, player, hand, facing, hitX, hitY, hitZ); }
-	 * 
-	 * private static TextComponentString getToggleMessage(EntityPlayer player, TileSaltFissionHeater heater, EnumFacing side) { SaltFissionHeaterSetting setting = heater.getHeaterSetting(side); String message = player.isSneaking() ? "nc.block.fluid_toggle_opposite" : "nc.block.fluid_toggle"; TextFormatting color = setting == SaltFissionHeaterSetting.HOT_COOLANT_OUT ? TextFormatting.RED : (setting == SaltFissionHeaterSetting.COOLANT_SPREAD ? TextFormatting.AQUA : (setting == SaltFissionHeaterSetting.DEFAULT ? TextFormatting.WHITE : TextFormatting.GRAY)); return new TextComponentString(Lang.localise(message) + " " + color + Lang.localise("nc.block.salt_heater_fluid_side." + setting.getName())); }
-	 * 
-	 * @Override public IBlockState getStateForPlacement(World world, BlockPos pos, EnumFacing facing, float hitX, float hitY, float hitZ, int meta, EntityLivingBase placer, EnumHand hand) { placementSide = null; if (placer != null && placer.isSneaking()) placementSide = facing.getOpposite(); return super.getStateForPlacement(world, pos, facing, hitX, hitY, hitZ, meta, placer, hand); }
-	 * 
-	 * @Override public void onBlockPlacedBy(World world, BlockPos pos, IBlockState state, EntityLivingBase placer, ItemStack stack) { if (placementSide == null) return; BlockPos from = pos.offset(placementSide); TileEntity tile = world.getTileEntity(pos), otherTile = world.getTileEntity(from); if (tile instanceof TileSaltFissionHeater && otherTile instanceof TileSaltFissionHeater) { TileSaltFissionHeater heater = (TileSaltFissionHeater) tile; TileSaltFissionHeater other = (TileSaltFissionHeater) otherTile; heater.setFluidConnections(FluidConnection.cloneArray(other. getFluidConnections())); heater.setHeaterSettings(other.getHeaterSettings().clone()); heater.markDirtyAndNotify(); } } */
 }
--- a/src/main/java/nc/multiblock/fission/salt/tile/TileSaltFissionHeater.java
+++ b/src/main/java/nc/multiblock/fission/salt/tile/TileSaltFissionHeater.java
@ -63,9 +63,9 @@ public abstract class TileSaltFissionHeater extends TileFissionPart implements I
 	
 	protected RecipeInfo<ProcessorRecipe> recipeInfo;
 	
-	protected Set<EntityPlayer> playersToUpdate;
+	protected final Set<EntityPlayer> playersToUpdate;
 	
-	public final String heaterName, coolantName;
+	public String heaterName, coolantName;
 	
 	protected FissionCluster cluster = null;
 	protected long heat = 0L;
@ -76,18 +76,25 @@ public abstract class TileSaltFissionHeater extends TileFissionPart implements I
 	protected BlockPos masterPortPos = DEFAULT_NON;
 	protected TileFissionHeaterPort masterPort = null;
 	
-	public TileSaltFissionHeater(String heaterName, String coolantName) {
+	/** Don't use this constructor! */
+	public TileSaltFissionHeater() {
 		super(CuboidalPartPositionType.INTERIOR);
-		this.heaterName = heaterName;
-		this.coolantName = coolantName;
-		tanks = Lists.newArrayList(new Tank(INGOT_BLOCK_VOLUME, Lists.newArrayList(coolantName)), new Tank(INGOT_BLOCK_VOLUME, new ArrayList<>()));
-		filterTanks = Lists.newArrayList(new Tank(1000, Lists.newArrayList(coolantName)), new Tank(1000, new ArrayList<>()));
+		tanks = Lists.newArrayList(new Tank(INGOT_BLOCK_VOLUME, null), new Tank(INGOT_BLOCK_VOLUME, new ArrayList<>()));
+		filterTanks = Lists.newArrayList(new Tank(1000, null), new Tank(1000, new ArrayList<>()));
 		fluidSides = ITileFluid.getDefaultFluidSides(this);
 		gasWrapper = new GasTileWrapper(this);
 		
 		playersToUpdate = new ObjectOpenHashSet<>();
 	}
 	
+	public TileSaltFissionHeater(String heaterName, String coolantName) {
+		this();
+		this.heaterName = heaterName;
+		this.coolantName = coolantName;
+		tanks.get(0).setAllowedFluids(Lists.newArrayList(coolantName));
+		filterTanks.get(0).setAllowedFluids(Lists.newArrayList(coolantName));
+	}
+	
 	protected TileSaltFissionHeater(String heaterName, int coolantID) {
 		this(heaterName, COOLANTS.get(coolantID) + "nak");
 	}
@ -922,6 +929,9 @@ public abstract class TileSaltFissionHeater extends TileFissionPart implements I
 	@Override
 	public NBTTagCompound writeAll(NBTTagCompound nbt) {
 		super.writeAll(nbt);
+		nbt.setString("heaterName", heaterName);
+		nbt.setString("coolantName", coolantName);
+		
 		writeTanks(nbt);
 		writeHeaterSettings(nbt);
 		
@ -940,6 +950,13 @@ public abstract class TileSaltFissionHeater extends TileFissionPart implements I
 	@Override
 	public void readAll(NBTTagCompound nbt) {
 		super.readAll(nbt);
+		if (nbt.hasKey("heaterName")) heaterName = nbt.getString("heaterName");
+		if (nbt.hasKey("coolantName")) {
+			coolantName = nbt.getString("coolantName");
+			tanks.get(0).setAllowedFluids(Lists.newArrayList(coolantName));
+			filterTanks.get(0).setAllowedFluids(Lists.newArrayList(coolantName));
+		}
+		
 		readTanks(nbt);
 		readHeaterSettings(nbt);
 		
--- a/src/main/java/nc/multiblock/fission/solid/tile/TileSolidFissionSink.java
+++ b/src/main/java/nc/multiblock/fission/solid/tile/TileSolidFissionSink.java
@ -14,24 +14,31 @@ import net.minecraft.util.EnumFacing;

 public abstract class TileSolidFissionSink extends TileFissionPart implements IFissionCoolingComponent {
 	
-	public final String sinkName;
-	public final int coolingRate;
+	public String sinkName;
+	public int coolingRate;
 	
-	public final PlacementRule<IFissionPart> placementRule;
+	public String ruleID;
+	public PlacementRule<IFissionPart> placementRule;
 	
 	private FissionCluster cluster = null;
 	private long heat = 0L;
 	public boolean isInValidPosition = false;
 	
-	public TileSolidFissionSink(String sinkName, int coolingRate, PlacementRule<IFissionPart> placementRule) {
+	/** Don't use this constructor! */
+	public TileSolidFissionSink() {
 		super(CuboidalPartPositionType.INTERIOR);
+	}
+	
+	public TileSolidFissionSink(String sinkName, int coolingRate, String ruleID) {
+		this();
 		this.sinkName = sinkName;
 		this.coolingRate = coolingRate;
-		this.placementRule = placementRule;
+		this.ruleID = ruleID;
+		this.placementRule = FissionPlacement.RULE_MAP.get(ruleID);
 	}
 	
 	protected TileSolidFissionSink(String sinkName, int coolingID) {
-		this(sinkName, fission_sink_cooling_rate[coolingID], FissionPlacement.RULE_MAP.get(sinkName + "_sink"));
+		this(sinkName, fission_sink_cooling_rate[coolingID], sinkName + "_sink");
 	}
 	
 	public static class Water extends TileSolidFissionSink {
@ -344,6 +351,10 @@ public abstract class TileSolidFissionSink extends TileFissionPart implements IF
 	@Override
 	public NBTTagCompound writeAll(NBTTagCompound nbt) {
 		super.writeAll(nbt);
+		nbt.setString("sinkName", sinkName);
+		nbt.setInteger("coolingRate", coolingRate);
+		nbt.setString("ruleID", ruleID);
+		
 		nbt.setLong("clusterHeat", heat);
 		return nbt;
 	}
@ -351,6 +362,13 @@ public abstract class TileSolidFissionSink extends TileFissionPart implements IF
 	@Override
 	public void readAll(NBTTagCompound nbt) {
 		super.readAll(nbt);
+		if (nbt.hasKey("sinkName")) sinkName = nbt.getString("sinkName");
+		if (nbt.hasKey("coolingRate")) coolingRate = nbt.getInteger("coolingRate");
+		if (nbt.hasKey("ruleID")) {
+			ruleID = nbt.getString("ruleID");
+			placementRule = FissionPlacement.RULE_MAP.get(ruleID);
+		}
+		
 		heat = nbt.getLong("clusterHeat");
 	}
 }
--- a/src/main/java/nc/multiblock/fission/tile/TileFissionComputerPort.java
+++ b/src/main/java/nc/multiblock/fission/tile/TileFissionComputerPort.java
@ -35,7 +35,7 @@ public class TileFissionComputerPort extends TileFissionPart implements SimpleCo
 	@Override
 	@Optional.Method(modid = "opencomputers")
 	public String getComponentName() {
-		return Global.MOD_SHORT_ID + "_salt_fission_reactor";
+		return "nc_salt_fission_reactor";
 	}
 	
 	@Callback
--- a/src/main/java/nc/multiblock/fission/tile/port/TileFissionHeaterPort.java
+++ b/src/main/java/nc/multiblock/fission/tile/port/TileFissionHeaterPort.java
@ -14,20 +14,28 @@ import nc.multiblock.fission.salt.tile.TileSaltFissionHeater;
 import nc.multiblock.network.FissionHeaterPortUpdatePacket;
 import nc.tile.ITileGui;
 import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.EnumFacing.Axis;

 public class TileFissionHeaterPort extends TileFissionFluidPort<TileFissionHeaterPort, TileSaltFissionHeater> implements ITileGui<FissionHeaterPortUpdatePacket> {
 	
-	protected final String coolantName;
+	protected String coolantName;
 	
-	protected Set<EntityPlayer> playersToUpdate;
+	protected final Set<EntityPlayer> playersToUpdate;
 	
-	public TileFissionHeaterPort(String coolantName) {
-		super(TileFissionHeaterPort.class, INGOT_BLOCK_VOLUME, Lists.newArrayList(coolantName), coolant_heater);
-		this.coolantName = coolantName;
+	/** Don't use this constructor! */
+	public TileFissionHeaterPort() {
+		super(TileFissionHeaterPort.class, INGOT_BLOCK_VOLUME, null, coolant_heater);
 		
 		playersToUpdate = new ObjectOpenHashSet<>();
 	}
 	
+	public TileFissionHeaterPort(String coolantName) {
+		this();
+		this.coolantName = coolantName;
+		tanks.get(0).setAllowedFluids(Lists.newArrayList(coolantName));
+	}
+	
 	protected TileFissionHeaterPort(int coolant) {
 		this(COOLANTS.get(coolant) + "nak");
 	}
@ -306,4 +314,22 @@ public class TileFissionHeaterPort extends TileFissionFluidPort<TileFissionHeate
 			getFilterTanks().get(i).readInfo(message.filterTanksInfo.get(i));
 		}
 	}
+	
+	// NBT
+	
+	@Override
+	public NBTTagCompound writeAll(NBTTagCompound nbt) {
+		super.writeAll(nbt);
+		nbt.setString("coolantName", coolantName);
+		return nbt;
+	}
+	
+	@Override
+	public void readAll(NBTTagCompound nbt) {
+		super.readAll(nbt);
+		if (nbt.hasKey("coolantName")) {
+			coolantName = nbt.getString("coolantName");
+			tanks.get(0).setAllowedFluids(Lists.newArrayList(coolantName));
+		}
+	}
 }
--- a/src/main/java/nc/multiblock/heatExchanger/tile/TileHeatExchangerComputerPort.java
+++ b/src/main/java/nc/multiblock/heatExchanger/tile/TileHeatExchangerComputerPort.java
@ -36,7 +36,7 @@ public class TileHeatExchangerComputerPort extends TileHeatExchangerPart impleme
 	@Override
 	@Optional.Method(modid = "opencomputers")
 	public String getComponentName() {
-		return Global.MOD_SHORT_ID + "_heat_exchanger";
+		return "nc_heat_exchanger";
 	}
 	
 	@Callback
--- a/src/main/java/nc/multiblock/qComputer/tile/TileQuantumComputerPort.java
+++ b/src/main/java/nc/multiblock/qComputer/tile/TileQuantumComputerPort.java
@ -26,7 +26,7 @@ public class TileQuantumComputerPort extends TileQuantumComputerPart implements
 	@Override
 	@Optional.Method(modid = "opencomputers")
 	public String getComponentName() {
-		return Global.MOD_SHORT_ID + "_quantum_computer";
+		return "nc_quantum_computer";
 	}
 	
 	@Callback
--- a/src/main/java/nc/multiblock/turbine/block/BlockTurbineRotorBlade.java
+++ b/src/main/java/nc/multiblock/turbine/block/BlockTurbineRotorBlade.java
@ -1,22 +1,35 @@
 package nc.multiblock.turbine.block;

+import static nc.util.NCRenderHelper.PIXEL;
+
 import nc.multiblock.turbine.TurbineRotorBladeUtil;
-import nc.multiblock.turbine.TurbineRotorBladeUtil.*;
+import nc.multiblock.turbine.TurbineRotorBladeUtil.IBlockRotorBlade;
+import nc.multiblock.turbine.TurbineRotorBladeUtil.TurbinePartDir;
+import nc.multiblock.turbine.TurbineRotorBladeUtil.TurbineRotorBladeType;
 import nc.multiblock.turbine.tile.TileTurbineRotorBlade;
 import net.minecraft.block.properties.IProperty;
-import net.minecraft.block.state.*;
+import net.minecraft.block.state.BlockStateContainer;
+import net.minecraft.block.state.IBlockState;
 import net.minecraft.entity.EntityLivingBase;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.tileentity.TileEntity;
-import net.minecraft.util.*;
-import net.minecraft.util.math.*;
-import net.minecraft.world.*;
-import net.minecraftforge.fml.relauncher.*;
+import net.minecraft.util.BlockRenderLayer;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.EnumHand;
+import net.minecraft.util.math.AxisAlignedBB;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;

 public class BlockTurbineRotorBlade extends BlockTurbinePart implements IBlockRotorBlade {
 	
-	// Bounding box pulled from the rotor blade model
-	private final AxisAlignedBB bbox = new AxisAlignedBB(2D, 0D, 7D, 14D, 16D, 9D);
+	private static final AxisAlignedBB[] BLADE_AABB = {
+			new AxisAlignedBB(0D, PIXEL*7D, PIXEL*2D, PIXEL*16D, PIXEL*9D, PIXEL*14D),
+			new AxisAlignedBB(PIXEL*2D, 0D, PIXEL*7D, PIXEL*14D, PIXEL*16D, PIXEL*9D),
+			new AxisAlignedBB(PIXEL*2D, PIXEL*7D, 0D, PIXEL*14D, PIXEL*9D, PIXEL*16D)
+	};
 	
 	private final TurbineRotorBladeType bladeType;
 	
@ -50,6 +63,24 @@ public class BlockTurbineRotorBlade extends BlockTurbinePart implements IBlockRo
 		}
 	}
 	
+	@Override
+	public AxisAlignedBB getBoundingBox(IBlockState state, IBlockAccess source, BlockPos pos) {
+		if (state.getBlock() != this) {
+			return super.getBoundingBox(state, source, pos);
+		}
+		
+		switch (state.getValue(TurbineRotorBladeUtil.DIR)) {
+			case X:
+				return BLADE_AABB[0];
+			case Y:
+				return BLADE_AABB[1];
+			case Z:
+				return BLADE_AABB[2];
+			default:
+				return super.getBoundingBox(state, source, pos);
+		}
+	}
+	
 	@Override
 	public AxisAlignedBB getCollisionBoundingBox(IBlockState blockState, IBlockAccess worldIn, BlockPos pos) {
 		return NULL_AABB;
@ -57,7 +88,20 @@ public class BlockTurbineRotorBlade extends BlockTurbinePart implements IBlockRo
 	
 	@Override
 	public AxisAlignedBB getSelectedBoundingBox(IBlockState state, World worldIn, BlockPos pos) {
-		return bbox;
+		if (state.getBlock() != this) {
+			return super.getSelectedBoundingBox(state, worldIn, pos);
+		}
+		
+		switch (state.getValue(TurbineRotorBladeUtil.DIR)) {
+			case X:
+				return BLADE_AABB[0].offset(pos);
+			case Y:
+				return BLADE_AABB[1].offset(pos);
+			case Z:
+				return BLADE_AABB[2].offset(pos);
+			default:
+				return super.getSelectedBoundingBox(state, worldIn, pos);
+		}
 	}

 	@Override
--- a/src/main/java/nc/multiblock/turbine/block/BlockTurbineRotorStator.java
+++ b/src/main/java/nc/multiblock/turbine/block/BlockTurbineRotorStator.java
@ -1,22 +1,34 @@
 package nc.multiblock.turbine.block;

+import static nc.util.NCRenderHelper.PIXEL;
+
 import nc.multiblock.turbine.TurbineRotorBladeUtil;
-import nc.multiblock.turbine.TurbineRotorBladeUtil.*;
+import nc.multiblock.turbine.TurbineRotorBladeUtil.IBlockRotorBlade;
+import nc.multiblock.turbine.TurbineRotorBladeUtil.TurbinePartDir;
 import nc.multiblock.turbine.tile.TileTurbineRotorStator;
 import net.minecraft.block.properties.IProperty;
-import net.minecraft.block.state.*;
+import net.minecraft.block.state.BlockStateContainer;
+import net.minecraft.block.state.IBlockState;
 import net.minecraft.entity.EntityLivingBase;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.tileentity.TileEntity;
-import net.minecraft.util.*;
-import net.minecraft.util.math.*;
-import net.minecraft.world.*;
-import net.minecraftforge.fml.relauncher.*;
+import net.minecraft.util.BlockRenderLayer;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.EnumHand;
+import net.minecraft.util.math.AxisAlignedBB;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;

 public class BlockTurbineRotorStator extends BlockTurbinePart implements IBlockRotorBlade {
 	
-	// Bounding box pulled from the rotor stator model
-	private final AxisAlignedBB bbox = new AxisAlignedBB(7D, 0D, 2D, 9D, 16D, 14D);
+	private static final AxisAlignedBB[] STATOR_AABB = {
+			new AxisAlignedBB(0D, PIXEL*2D, PIXEL*7D, PIXEL*16D, PIXEL*14D, PIXEL*9D),
+			new AxisAlignedBB(PIXEL*7D, 0D, PIXEL*2D, PIXEL*9D, PIXEL*16D, PIXEL*14D),
+			new AxisAlignedBB(PIXEL*7D, PIXEL*2D, 0D, PIXEL*9D, PIXEL*14D, PIXEL*16D)
+	};
 	
 	public BlockTurbineRotorStator() {
 		super();
@ -38,6 +50,24 @@ public class BlockTurbineRotorStator extends BlockTurbinePart implements IBlockR
 		return new TileTurbineRotorStator();
 	}
 	
+	@Override
+	public AxisAlignedBB getBoundingBox(IBlockState state, IBlockAccess source, BlockPos pos) {
+		if (state.getBlock() != this) {
+			return super.getBoundingBox(state, source, pos);
+		}
+		
+		switch (state.getValue(TurbineRotorBladeUtil.DIR)) {
+			case X:
+				return STATOR_AABB[0];
+			case Y:
+				return STATOR_AABB[1];
+			case Z:
+				return STATOR_AABB[2];
+			default:
+				return super.getBoundingBox(state, source, pos);
+		}
+	}
+	
 	@Override
 	public AxisAlignedBB getCollisionBoundingBox(IBlockState blockState, IBlockAccess worldIn, BlockPos pos) {
 		return NULL_AABB;
@ -45,7 +75,20 @@ public class BlockTurbineRotorStator extends BlockTurbinePart implements IBlockR
 	
 	@Override
 	public AxisAlignedBB getSelectedBoundingBox(IBlockState state, World worldIn, BlockPos pos) {
-		return bbox;
+		if (state.getBlock() != this) {
+			return super.getSelectedBoundingBox(state, worldIn, pos);
+		}
+		
+		switch (state.getValue(TurbineRotorBladeUtil.DIR)) {
+			case X:
+				return STATOR_AABB[0].offset(pos);
+			case Y:
+				return STATOR_AABB[1].offset(pos);
+			case Z:
+				return STATOR_AABB[2].offset(pos);
+			default:
+				return super.getSelectedBoundingBox(state, worldIn, pos);
+		}
 	}
 	
 	@Override
--- a/src/main/java/nc/multiblock/turbine/tile/TileTurbineCoilConnector.java
+++ b/src/main/java/nc/multiblock/turbine/tile/TileTurbineCoilConnector.java
@ -5,7 +5,7 @@ import nc.multiblock.turbine.*;
 public class TileTurbineCoilConnector extends TileTurbineDynamoPart {
 	
 	public TileTurbineCoilConnector() {
-		super("connector", null, TurbinePlacement.RULE_MAP.get("connector"));
+		super("connector", null, "connector");
 	}
 	
 	@Override
--- a/src/main/java/nc/multiblock/turbine/tile/TileTurbineComputerPort.java
+++ b/src/main/java/nc/multiblock/turbine/tile/TileTurbineComputerPort.java
@ -36,7 +36,7 @@ public class TileTurbineComputerPort extends TileTurbinePart implements SimpleCo
 	@Override
 	@Optional.Method(modid = "opencomputers")
 	public String getComponentName() {
-		return Global.MOD_SHORT_ID + "_turbine";
+		return "nc_turbine";
 	}
 	
 	@Callback
--- a/src/main/java/nc/multiblock/turbine/tile/TileTurbineDynamoCoil.java
+++ b/src/main/java/nc/multiblock/turbine/tile/TileTurbineDynamoCoil.java
@ -5,12 +5,17 @@ import nc.multiblock.turbine.*;

 public abstract class TileTurbineDynamoCoil extends TileTurbineDynamoPart {
 	
-	public TileTurbineDynamoCoil(String coilName, Double conductivity, PlacementRule<ITurbinePart> placementRule) {
-		super(coilName, conductivity, placementRule);
+	/** Don't use this constructor! */
+	public TileTurbineDynamoCoil() {
+		super();
+	}
+	
+	public TileTurbineDynamoCoil(String coilName, Double conductivity, String ruleID) {
+		super(coilName, conductivity, ruleID);
 	}
 	
 	private TileTurbineDynamoCoil(TurbineDynamoCoilType coilType) {
-		this(coilType.getName(), coilType.getConductivity(), TurbinePlacement.RULE_MAP.get(coilType.getName() + "_coil"));
+		this(coilType.getName(), coilType.getConductivity(), coilType.getName() + "_coil");
 	}
 	
 	public static class Magnesium extends TileTurbineDynamoCoil {
--- a/src/main/java/nc/multiblock/turbine/tile/TileTurbineDynamoPart.java
+++ b/src/main/java/nc/multiblock/turbine/tile/TileTurbineDynamoPart.java
@ -1,21 +1,30 @@
 package nc.multiblock.turbine.tile;

-import static nc.config.NCConfig.*;
+import static nc.config.NCConfig.enable_gtce_eu;
+import static nc.config.NCConfig.rf_per_eu;

-import javax.annotation.*;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;

-import gregtech.api.capability.*;
+import gregtech.api.capability.GregtechCapabilities;
+import gregtech.api.capability.IEnergyContainer;
 import ic2.api.energy.EnergyNet;
-import ic2.api.energy.tile.*;
+import ic2.api.energy.tile.IEnergyAcceptor;
+import ic2.api.energy.tile.IEnergySink;
+import ic2.api.energy.tile.IEnergySource;
 import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
 import it.unimi.dsi.fastutil.objects.ObjectSet;
 import nc.ModCheck;
 import nc.multiblock.PlacementRule;
 import nc.multiblock.cuboidal.CuboidalPartPositionType;
+import nc.multiblock.fission.FissionPlacement;
 import nc.multiblock.turbine.Turbine;
+import nc.multiblock.turbine.TurbinePlacement;
 import nc.tile.energy.ITileEnergy;
-import nc.tile.internal.energy.*;
+import nc.tile.internal.energy.EnergyConnection;
 import nc.tile.internal.energy.EnergyStorage;
+import nc.tile.internal.energy.EnergyTileWrapper;
+import nc.tile.internal.energy.EnergyTileWrapperGT;
 import nc.tile.passive.ITilePassive;
 import nc.util.EnergyHelper;
 import net.minecraft.nbt.NBTTagCompound;
@ -23,7 +32,8 @@ import net.minecraft.tileentity.TileEntity;
 import net.minecraft.util.EnumFacing;
 import net.minecraft.util.math.MathHelper;
 import net.minecraftforge.common.capabilities.Capability;
-import net.minecraftforge.energy.*;
+import net.minecraftforge.energy.CapabilityEnergy;
+import net.minecraftforge.energy.IEnergyStorage;
 import net.minecraftforge.fml.common.Optional;

@Optional.InterfaceList({@Optional.Interface(iface = "ic2.api.energy.tile.IEnergyTile", modid = "ic2"), @Optional.Interface(iface = "ic2.api.energy.tile.IEnergySink", modid = "ic2"), @Optional.Interface(iface = "ic2.api.energy.tile.IEnergySource", modid = "ic2")})
@ -38,17 +48,25 @@ public abstract class TileTurbineDynamoPart extends TileTurbinePart implements I
 	
 	protected boolean ic2reg = false;
 	
-	public final String partName;
-	public final Double conductivity;
+	public String partName;
+	public Double conductivity;
+	
 	public boolean isSearched = false, isInValidPosition = false;
 	
-	public final PlacementRule<ITurbinePart> placementRule;
+	public String ruleID;
+	public PlacementRule<ITurbinePart> placementRule;
 	
-	public TileTurbineDynamoPart(String partName, Double conductivity, PlacementRule<ITurbinePart> placementRule) {
+	/** Don't use this constructor! */
+	public TileTurbineDynamoPart() {
+		super(CuboidalPartPositionType.WALL);
+	}
+	
+	public TileTurbineDynamoPart(String partName, Double conductivity, String ruleID) {
 		super(CuboidalPartPositionType.WALL);
 		this.partName = partName;
 		this.conductivity = conductivity;
-		this.placementRule = placementRule;
+		this.ruleID = ruleID;
+		this.placementRule = TurbinePlacement.RULE_MAP.get(ruleID);
 	}
 	
 	@Override
@ -278,6 +296,10 @@ public abstract class TileTurbineDynamoPart extends TileTurbinePart implements I
 	@Override
 	public NBTTagCompound writeAll(NBTTagCompound nbt) {
 		super.writeAll(nbt);
+		nbt.setString("partName", partName);
+		if (conductivity != null) nbt.setDouble("conductivity", conductivity);
+		nbt.setString("ruleID", ruleID);
+		
 		writeEnergy(nbt);
 		writeEnergyConnections(nbt);
 		nbt.setBoolean("isInValidPosition", isInValidPosition);
@ -287,6 +309,13 @@ public abstract class TileTurbineDynamoPart extends TileTurbinePart implements I
 	@Override
 	public void readAll(NBTTagCompound nbt) {
 		super.readAll(nbt);
+		if (nbt.hasKey("partName")) partName = nbt.getString("partName");
+		if (nbt.hasKey("conductivity")) conductivity = nbt.getDouble("conductivity");
+		if (nbt.hasKey("ruleID")) {
+			ruleID = nbt.getString("ruleID");
+			placementRule = TurbinePlacement.RULE_MAP.get(ruleID);
+		}
+		
 		readEnergy(nbt);
 		readEnergyConnections(nbt);
 		isInValidPosition = nbt.getBoolean("isInValidPosition");
--- a/src/main/java/nc/multiblock/turbine/tile/TileTurbineRotorBlade.java
+++ b/src/main/java/nc/multiblock/turbine/tile/TileTurbineRotorBlade.java
@ -11,9 +11,14 @@ import net.minecraft.world.World;

 public abstract class TileTurbineRotorBlade extends TileTurbinePart implements ITurbineRotorBlade {
 	
-	public final TurbineRotorBladeType bladeType;
+	public IRotorBladeType bladeType = null;
 	protected TurbinePartDir dir = TurbinePartDir.Y;
 	
+	/** Don't use this constructor! */
+	public TileTurbineRotorBlade() {
+		super(CuboidalPartPositionType.INTERIOR);
+	}
+	
 	public static class Steel extends TileTurbineRotorBlade {
 		
 		public Steel() {
@ -50,9 +55,8 @@ public abstract class TileTurbineRotorBlade extends TileTurbinePart implements I
 		}
 	}
 	
-	private TileTurbineRotorBlade(TurbineRotorBladeType bladeType) {
-		super(CuboidalPartPositionType.INTERIOR);
-		
+	public TileTurbineRotorBlade(IRotorBladeType bladeType) {
+		this();
 		this.bladeType = bladeType;
 	}
 	
@ -110,6 +114,12 @@ public abstract class TileTurbineRotorBlade extends TileTurbinePart implements I
 	@Override
 	public NBTTagCompound writeAll(NBTTagCompound nbt) {
 		super.writeAll(nbt);
+		if (bladeType != null) {
+			nbt.setString("bladeName", bladeType.getName());
+			nbt.setDouble("bladeEfficiency", bladeType.getEfficiency());
+			nbt.setDouble("bladeExpansionCoefficient", bladeType.getExpansionCoefficient());
+		}
+		
 		nbt.setInteger("bladeDir", dir.ordinal());
 		return nbt;
 	}
@ -117,6 +127,30 @@ public abstract class TileTurbineRotorBlade extends TileTurbinePart implements I
 	@Override
 	public void readAll(NBTTagCompound nbt) {
 		super.readAll(nbt);
+		if (bladeType == null && nbt.hasKey("bladeName") && nbt.hasKey("bladeEfficiency") && nbt.hasKey("bladeExpansionCoefficient")) {
+			bladeType = new IRotorBladeType() {
+				
+				final String name = nbt.getString("bladeName");
+				final double efficiency = nbt.getDouble("bladeEfficiency"), expansionCoefficient = nbt.getDouble("bladeExpansionCoefficient");
+				
+				@Override
+				public String getName() {
+					return name;
+				}
+				
+				@Override
+				public double getEfficiency() {
+					return efficiency;
+				}
+				
+				@Override
+				public double getExpansionCoefficient() {
+					return expansionCoefficient;
+				}
+				
+			};
+		}
+		
 		dir = TurbinePartDir.values()[nbt.getInteger("bladeDir")];
 	}
 }
--- a/src/main/java/nc/multiblock/turbine/tile/TileTurbineRotorStator.java
+++ b/src/main/java/nc/multiblock/turbine/tile/TileTurbineRotorStator.java
@ -11,12 +11,18 @@ import net.minecraft.world.World;

 public class TileTurbineRotorStator extends TileTurbinePart implements ITurbineRotorBlade {
 	
+	public IRotorStatorType statorType = null;
 	protected TurbinePartDir dir = TurbinePartDir.Y;
 	
 	public TileTurbineRotorStator() {
 		super(CuboidalPartPositionType.INTERIOR);
 	}
 	
+	public TileTurbineRotorStator(IRotorStatorType statorType) {
+		this();
+		this.statorType = statorType;
+	}
+	
 	@Override
 	public void onMachineAssembled(Turbine controller) {
 		doStandardNullControllerResponse(controller);
@ -75,6 +81,11 @@ public class TileTurbineRotorStator extends TileTurbinePart implements ITurbineR
 	@Override
 	public NBTTagCompound writeAll(NBTTagCompound nbt) {
 		super.writeAll(nbt);
+		if (statorType != null) {
+			nbt.setString("statorName", statorType.getName());
+			nbt.setDouble("statorExpansionCoefficient", statorType.getExpansionCoefficient());
+		}
+		
 		nbt.setInteger("bladeDir", dir.ordinal());
 		return nbt;
 	}
@ -82,6 +93,25 @@ public class TileTurbineRotorStator extends TileTurbinePart implements ITurbineR
 	@Override
 	public void readAll(NBTTagCompound nbt) {
 		super.readAll(nbt);
+		if (statorType == null && nbt.hasKey("statorName") && nbt.hasKey("statorExpansionCoefficient")) {
+			statorType = new IRotorStatorType() {
+				
+				final String name = nbt.getString("bladeName");
+				final double expansionCoefficient = nbt.getDouble("bladeExpansionCoefficient");
+				
+				@Override
+				public String getName() {
+					return name;
+				}
+				
+				@Override
+				public double getExpansionCoefficient() {
+					return expansionCoefficient;
+				}
+				
+			};
+		}
+		
 		dir = TurbinePartDir.values()[nbt.getInteger("bladeDir")];
 	}
 }
--- a/src/main/java/nc/network/radiation/PlayerRadsUpdatePacket.java
+++ b/src/main/java/nc/network/radiation/PlayerRadsUpdatePacket.java
@ -28,6 +28,7 @@ public class PlayerRadsUpdatePacket implements IMessage {
 	protected double radiationImmunityTime;
 	protected boolean radiationImmunityStage;
 	protected boolean shouldWarn;
+	protected boolean giveGuidebook;
 	
 	public PlayerRadsUpdatePacket() {
 		messageValid = false;
@ -53,6 +54,7 @@ public class PlayerRadsUpdatePacket implements IMessage {
 		radiationImmunityTime = playerRads.getRadiationImmunityTime();
 		radiationImmunityStage = playerRads.getRadiationImmunityStage();
 		shouldWarn = playerRads.getShouldWarn();
+		giveGuidebook = playerRads.getGiveGuidebook();
 		
 		messageValid = true;
 	}
@ -79,6 +81,7 @@ public class PlayerRadsUpdatePacket implements IMessage {
 			radiationImmunityTime = buf.readDouble();
 			radiationImmunityStage = buf.readBoolean();
 			shouldWarn = buf.readBoolean();
+			giveGuidebook = buf.readBoolean();
 		}
 		catch (IndexOutOfBoundsException e) {
 			e.printStackTrace();
@ -112,6 +115,7 @@ public class PlayerRadsUpdatePacket implements IMessage {
 		buf.writeDouble(radiationImmunityTime);
 		buf.writeBoolean(radiationImmunityStage);
 		buf.writeBoolean(shouldWarn);
+		buf.writeBoolean(giveGuidebook);
 	}
 	
 	public static class Handler implements IMessageHandler<PlayerRadsUpdatePacket, IMessage> {
@ -153,6 +157,7 @@ public class PlayerRadsUpdatePacket implements IMessage {
 			playerRads.setRadiationImmunityTime(message.radiationImmunityTime);
 			playerRads.setRadiationImmunityStage(message.radiationImmunityStage);
 			playerRads.setShouldWarn(message.shouldWarn);
+			playerRads.setGiveGuidebook(message.giveGuidebook);
 		}
 	}
 }
--- a/src/main/java/nc/proxy/ClientProxy.java
+++ b/src/main/java/nc/proxy/ClientProxy.java
@ -1,12 +1,17 @@
 package nc.proxy;

-import java.util.*;
+import java.util.ArrayList;
+import java.util.List;

 import nc.Global;
 import nc.block.fluid.NCBlockFluid;
 import nc.config.NCConfig;
-import nc.handler.*;
-import nc.init.*;
+import nc.handler.RenderHandler;
+import nc.handler.SoundHandler;
+import nc.handler.TooltipHandler;
+import nc.init.NCBlocks;
+import nc.init.NCCoolantFluids;
+import nc.init.NCFissionFluids;
 import nc.model.ModelTexturedFluid;
 import nc.radiation.RadiationRenders;
 import nc.render.ColorRenderer;
@ -14,17 +19,22 @@ import net.minecraft.block.Block;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.renderer.ItemMeshDefinition;
-import net.minecraft.client.renderer.block.model.*;
+import net.minecraft.client.renderer.block.model.ModelBakery;
+import net.minecraft.client.renderer.block.model.ModelResourceLocation;
 import net.minecraft.client.renderer.block.statemap.StateMapperBase;
 import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.item.*;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
 import net.minecraft.world.World;
-import net.minecraftforge.client.model.*;
+import net.minecraftforge.client.model.ModelLoader;
+import net.minecraftforge.client.model.ModelLoaderRegistry;
 import net.minecraftforge.common.MinecraftForge;
 import net.minecraftforge.fluids.Fluid;
 import net.minecraftforge.fml.common.FMLCommonHandler;
 import net.minecraftforge.fml.common.Optional;
-import net.minecraftforge.fml.common.event.*;
+import net.minecraftforge.fml.common.event.FMLInitializationEvent;
+import net.minecraftforge.fml.common.event.FMLPostInitializationEvent;
+import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
 import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
 import slimeknights.tconstruct.library.client.MaterialRenderInfo;
 import slimeknights.tconstruct.library.materials.Material;
@ -93,8 +103,7 @@ public class ClientProxy extends CommonProxy {
 		ModelBakery.registerItemVariants(item);
 		ModelLoader.setCustomMeshDefinition(item, mapper);
 		
-		// ModelLoader.setCustomStateMapper(block, new
-		// StateMap.Builder().ignore(block.LEVEL).build());
+		// ModelLoader.setCustomStateMapper(block, new StateMap.Builder().ignore(block.LEVEL).build());
 		ModelLoader.setCustomStateMapper(block, mapper);
 	}
 	
--- a/src/main/java/nc/proxy/CommonProxy.java
+++ b/src/main/java/nc/proxy/CommonProxy.java
@ -2,23 +2,55 @@ package nc.proxy;

 import java.util.Locale;

-import nc.*;
+import nc.Global;
+import nc.ModCheck;
 import nc.capability.radiation.RadiationCapabilityHandler;
 import nc.command.CommandHandler;
 import nc.config.NCConfig;
-import nc.handler.*;
-import nc.init.*;
+import nc.handler.CapabilityHandler;
+import nc.handler.DropHandler;
+import nc.handler.DungeonLootHandler;
+import nc.handler.EntityHandler;
+import nc.handler.ItemUseHandler;
+import nc.handler.OreDictHandler;
+import nc.handler.PlayerRespawnHandler;
+import nc.init.NCArmor;
+import nc.init.NCBlocks;
+import nc.init.NCCoolantFluids;
+import nc.init.NCEntities;
+import nc.init.NCFissionFluids;
+import nc.init.NCFluids;
+import nc.init.NCItems;
+import nc.init.NCSounds;
+import nc.init.NCTiles;
+import nc.init.NCTools;
+import nc.integration.crafttweaker.CTRegistration;
+import nc.integration.crafttweaker.CTRegistration.RegistrationInfo;
 import nc.integration.hwyla.NCHWLYA;
 import nc.integration.projecte.NCProjectE;
-import nc.integration.tconstruct.*;
+import nc.integration.tconstruct.TConstructExtras;
+import nc.integration.tconstruct.TConstructIMC;
+import nc.integration.tconstruct.TConstructMaterials;
 import nc.integration.tconstruct.conarm.ConArmMaterials;
-import nc.multiblock.*;
+import nc.multiblock.MultiblockHandler;
+import nc.multiblock.MultiblockLogic;
+import nc.multiblock.MultiblockRegistry;
+import nc.multiblock.PlacementRule;
 import nc.network.PacketHandler;
-import nc.radiation.*;
+import nc.radiation.RadArmor;
+import nc.radiation.RadBiomes;
+import nc.radiation.RadEntities;
+import nc.radiation.RadPotionEffects;
+import nc.radiation.RadSources;
+import nc.radiation.RadStructures;
+import nc.radiation.RadWorlds;
+import nc.radiation.RadiationHandler;
 import nc.radiation.environment.RadiationEnvironmentHandler;
 import nc.recipe.NCRecipes;
 import nc.recipe.vanilla.CraftingRecipeHandler;
-import nc.util.*;
+import nc.util.GasHelper;
+import nc.util.OreDictHelper;
+import nc.util.StructureHelper;
 import nc.worldgen.biome.NCBiomes;
 import nc.worldgen.decoration.BushGenerator;
 import nc.worldgen.dimension.NCWorlds;
@ -27,8 +59,14 @@ import net.minecraft.block.Block;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.world.World;
 import net.minecraftforge.common.MinecraftForge;
-import net.minecraftforge.fml.common.*;
-import net.minecraftforge.fml.common.event.*;
+import net.minecraftforge.fml.common.FMLCommonHandler;
+import net.minecraftforge.fml.common.Optional;
+import net.minecraftforge.fml.common.event.FMLInitializationEvent;
+import net.minecraftforge.fml.common.event.FMLModIdMappingEvent;
+import net.minecraftforge.fml.common.event.FMLPostInitializationEvent;
+import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
+import net.minecraftforge.fml.common.event.FMLServerStartingEvent;
+import net.minecraftforge.fml.common.event.FMLServerStoppedEvent;
 import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
 import net.minecraftforge.fml.common.registry.GameRegistry;
 import slimeknights.tconstruct.library.materials.Material;
@ -81,6 +119,10 @@ public class CommonProxy {
 				ConArmMaterials.preInit();
 			}
 		}
+		
+		for (RegistrationInfo info : CTRegistration.INFO_LIST) {
+			info.preInit();
+		}
 	}
 	
 	public void init(FMLInitializationEvent event) {
@ -100,8 +142,7 @@ public class CommonProxy {
 		
 		GameRegistry.registerWorldGenerator(new OreGenerator(), 0);
 		GameRegistry.registerWorldGenerator(new BushGenerator(), 100);
-		// GameRegistry.registerWorldGenerator(new WastelandPortalGenerator(),
-		// 10);
+		// GameRegistry.registerWorldGenerator(new WastelandPortalGenerator(), 10);
 		
 		NCEntities.register();
 		MinecraftForge.EVENT_BUS.register(new EntityHandler());
@ -119,6 +160,10 @@ public class CommonProxy {
 		if (ModCheck.hwylaLoaded()) {
 			NCHWLYA.init();
 		}
+		
+		for (RegistrationInfo info : CTRegistration.INFO_LIST) {
+			info.init();
+		}
 	}
 	
 	public void postInit(FMLPostInitializationEvent postEvent) {
@ -148,6 +193,10 @@ public class CommonProxy {
 		if (ModCheck.projectELoaded() && NCConfig.register_projecte_emc) {
 			NCProjectE.addEMCValues();
 		}
+		
+		for (RegistrationInfo info : CTRegistration.INFO_LIST) {
+			info.postInit();
+		}
 	}
 	
 	public void serverStart(FMLServerStartingEvent serverStartEvent) {
@ -178,7 +227,7 @@ public class CommonProxy {
 	}
 	
 	public int getCurrentClientDimension() {
-		return -8954;
+		return Integer.MIN_VALUE;
 	}
 	
 	public EntityPlayer getPlayerEntity(MessageContext ctx) {
--- a/src/main/java/nc/radiation/RadSources.java
+++ b/src/main/java/nc/radiation/RadSources.java
@ -1,20 +1,41 @@
 package nc.radiation;

-import static nc.config.NCConfig.*;
+import static nc.config.NCConfig.radiation_blocks;
+import static nc.config.NCConfig.radiation_blocks_blacklist;
+import static nc.config.NCConfig.radiation_fluids;
+import static nc.config.NCConfig.radiation_fluids_blacklist;
+import static nc.config.NCConfig.radiation_foods;
+import static nc.config.NCConfig.radiation_items;
+import static nc.config.NCConfig.radiation_items_blacklist;
+import static nc.config.NCConfig.radiation_ores;
+import static nc.config.NCConfig.radiation_ores_blacklist;

+import java.util.ArrayList;
 import java.util.List;

 import com.google.common.collect.Lists;

-import it.unimi.dsi.fastutil.ints.*;
-import it.unimi.dsi.fastutil.objects.*;
+import it.unimi.dsi.fastutil.ints.Int2DoubleMap;
+import it.unimi.dsi.fastutil.ints.Int2DoubleOpenHashMap;
+import it.unimi.dsi.fastutil.ints.IntOpenHashSet;
+import it.unimi.dsi.fastutil.ints.IntSet;
+import it.unimi.dsi.fastutil.objects.Object2DoubleMap;
+import it.unimi.dsi.fastutil.objects.Object2DoubleOpenHashMap;
+import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet;
+import it.unimi.dsi.fastutil.objects.ObjectSet;
 import nc.ModCheck;
-import nc.init.*;
-import nc.util.*;
+import nc.init.NCBlocks;
+import nc.init.NCItems;
+import nc.util.OreDictHelper;
+import nc.util.RegistryHelper;
+import nc.util.StringHelper;
 import net.minecraft.block.Block;
 import net.minecraft.client.util.RecipeItemHelper;
-import net.minecraft.item.*;
-import net.minecraftforge.fluids.*;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemFood;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidRegistry;
 import net.minecraftforge.oredict.OreDictionary;

 public class RadSources {
@ -30,6 +51,27 @@ public class RadSources {
 	public static final Int2DoubleMap FOOD_RAD_MAP = new Int2DoubleOpenHashMap();
 	public static final Int2DoubleMap FOOD_RESISTANCE_MAP = new Int2DoubleOpenHashMap();
 	
+	public static final List<Runnable> RUNNABLES = new ArrayList<>();
+	
+	public static void addToOreBlacklist(String ore) {
+		if (StringHelper.isGlob(ore)) {
+			OreDictHelper.addWildcard(ORE_BLACKLIST, ore);
+		}
+		else {
+			ORE_BLACKLIST.add(ore);
+		}
+	}
+	
+	public static void addToStackBlacklist(ItemStack stack) {
+		if (stack != null) {
+			STACK_BLACKLIST.add(RecipeItemHelper.pack(stack));
+		}
+	}
+	
+	public static void addToFluidBlacklist(String fluidName) {
+		FLUID_BLACKLIST.add(fluidName);
+	}
+	
 	public static void addToOreMap(String ore, double radiation) {
 		if (ORE_BLACKLIST.contains(ore)) {
 			return;
@ -105,27 +147,16 @@ public class RadSources {
 	
 	public static void init() {
 		for (String ore : radiation_ores_blacklist) {
-			if (StringHelper.isGlob(ore)) {
-				OreDictHelper.addWildcard(ORE_BLACKLIST, ore);
-			}
-			else {
-				ORE_BLACKLIST.add(ore);
-			}
+			addToOreBlacklist(ore);
 		}
 		for (String item : radiation_items_blacklist) {
-			ItemStack stack = RegistryHelper.itemStackFromRegistry(item);
-			if (stack != null) {
-				STACK_BLACKLIST.add(RecipeItemHelper.pack(stack));
-			}
+			addToStackBlacklist(RegistryHelper.itemStackFromRegistry(item));
 		}
 		for (String block : radiation_blocks_blacklist) {
-			ItemStack stack = RegistryHelper.blockStackFromRegistry(block);
-			if (stack != null) {
-				STACK_BLACKLIST.add(RecipeItemHelper.pack(stack));
-			}
+			addToStackBlacklist(RegistryHelper.blockStackFromRegistry(block));
 		}
 		for (String fluid : radiation_fluids_blacklist) {
-			FLUID_BLACKLIST.add(fluid);
+			addToFluidBlacklist(fluid);
 		}
 		
 		if (ModCheck.gregtechLoaded()) {
@ -216,7 +247,7 @@ public class RadSources {
 		putFuel(LECf_251, DEPLETED_LECf_251, "LECf251", "lecf_251");
 		putFuel(HECf_251, DEPLETED_HECf_251, "HECf251", "hecf_251");
 		
-		put(URANIUM_238 * 4D, "plateDU");
+		putOre(URANIUM_238 * 4D, "plateDU");
 		put(URANIUM_238 * 16D, NCBlocks.solar_panel_du, NCBlocks.voltaic_pile_du, NCBlocks.lithium_ion_battery_du);
 		put(URANIUM_238 * 12D, new ItemStack(NCItems.rad_shielding, 1, 2));
 		
@ -231,11 +262,11 @@ public class RadSources {
 		
 		put(TRITIUM / 256D, NCBlocks.tritium_lamp);
 		
-		put(CAESIUM_137 / 4D, "dustIrradiatedBorax");
+		putOre(CAESIUM_137 / 4D, "dustIrradiatedBorax");
 		
 		if (ModCheck.gregtechLoaded()) {
 			for (String prefix : ORE_PREFIXES) {
-				put(17D * THORIUM / 4D, prefix + "Monazite");
+				putOre(17D * THORIUM / 4D, prefix + "Monazite");
 			}
 		}
 		
@ -308,6 +339,10 @@ public class RadSources {
 				addToFoodMaps(stack, rads, resistance);
 			}
 		}
+		
+		for (Runnable runnable : RUNNABLES) {
+			runnable.run();
+		}
 	}
 	
 	public static void postInit() {
@ -387,7 +422,7 @@ public class RadSources {
 		}
 	}
 	
-	public static void put(double radiation, String... ores) {
+	public static void putOre(double radiation, String... ores) {
 		for (String ore : ores) {
 			addToOreMap(ore, radiation);
 		}
--- a/src/main/java/nc/radiation/RadiationHandler.java
+++ b/src/main/java/nc/radiation/RadiationHandler.java
@ -10,7 +10,9 @@ import com.google.common.collect.Lists;
 import nc.ModCheck;
 import nc.capability.radiation.entity.IEntityRads;
 import nc.capability.radiation.source.IRadiationSource;
+import nc.config.NCConfig;
 import nc.entity.EntityFeralGhoul;
+import nc.init.NCItems;
 import nc.init.NCSounds;
 import nc.network.PacketHandler;
 import nc.network.radiation.PlayerRadsUpdatePacket;
@ -36,6 +38,9 @@ import net.minecraft.world.gen.ChunkProviderServer;
 import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 import net.minecraftforge.fml.common.gameevent.TickEvent;
 import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.items.ItemHandlerHelper;
+import vazkii.patchouli.common.item.ItemModBook;
+import vazkii.patchouli.common.item.PatchouliItems;

 public class RadiationHandler {
 	
@ -70,6 +75,13 @@ public class RadiationHandler {
 				return;
 			}
 			
+			if (NCConfig.give_guidebook && ModCheck.patchouliLoaded() && playerRads.getGiveGuidebook()) {
+				boolean success = player.inventory.addItemStackToInventory(ItemModBook.forBook("nuclearcraft:guide"));
+				if (success) {
+					playerRads.setGiveGuidebook(false);
+				}
+			}
+			
 			if (ModCheck.gameStagesLoaded()) {
 				playerRads.setRadiationImmunityStage(default_rad_immunity ^ GameStageHelper.hasAnyOf(player, rad_immunity_stages));
 			}
--- a/src/main/java/nc/recipe/NCRecipes.java
+++ b/src/main/java/nc/recipe/NCRecipes.java
@ -2,16 +2,53 @@ package nc.recipe;

 import java.util.List;

-import nc.radiation.RadBlockEffects.*;
+import nc.integration.crafttweaker.CTRegistration;
+import nc.integration.crafttweaker.CTRegistration.RegistrationInfo;
+import nc.radiation.RadBlockEffects.RadiationBlockMutation;
+import nc.radiation.RadBlockEffects.RadiationBlockPurification;
 import nc.radiation.RadSources;
-import nc.recipe.generator.*;
-import nc.recipe.multiblock.*;
-import nc.recipe.other.*;
-import nc.recipe.processor.*;
-import nc.recipe.vanilla.*;
+import nc.recipe.generator.DecayGeneratorRecipes;
+import nc.recipe.generator.FusionRecipes;
+import nc.recipe.multiblock.CondenserRecipes;
+import nc.recipe.multiblock.CoolantHeaterRecipes;
+import nc.recipe.multiblock.FissionEmergencyCoolingRecipes;
+import nc.recipe.multiblock.FissionHeatingRecipes;
+import nc.recipe.multiblock.FissionIrradiatorRecipes;
+import nc.recipe.multiblock.FissionModeratorRecipes;
+import nc.recipe.multiblock.FissionReflectorRecipes;
+import nc.recipe.multiblock.HeatExchangerRecipes;
+import nc.recipe.multiblock.PebbleFissionRecipes;
+import nc.recipe.multiblock.SaltFissionRecipes;
+import nc.recipe.multiblock.SolidFissionRecipes;
+import nc.recipe.multiblock.TurbineRecipes;
+import nc.recipe.other.CollectorRecipes;
+import nc.recipe.other.RadiationScrubberRecipes;
+import nc.recipe.processor.AlloyFurnaceRecipes;
+import nc.recipe.processor.AssemblerRecipes;
+import nc.recipe.processor.CentrifugeRecipes;
+import nc.recipe.processor.ChemicalReactorRecipes;
+import nc.recipe.processor.CrystallizerRecipes;
+import nc.recipe.processor.DecayHastenerRecipes;
+import nc.recipe.processor.ElectrolyzerRecipes;
+import nc.recipe.processor.EnricherRecipes;
+import nc.recipe.processor.ExtractorRecipes;
+import nc.recipe.processor.FuelReprocessorRecipes;
+import nc.recipe.processor.InfuserRecipes;
+import nc.recipe.processor.IngotFormerRecipes;
+import nc.recipe.processor.ManufactoryRecipes;
+import nc.recipe.processor.MelterRecipes;
+import nc.recipe.processor.PressurizerRecipes;
+import nc.recipe.processor.RockCrusherRecipes;
+import nc.recipe.processor.SaltMixerRecipes;
+import nc.recipe.processor.SeparatorRecipes;
+import nc.recipe.processor.SupercoolerRecipes;
+import nc.recipe.vanilla.CraftingRecipeHandler;
+import nc.recipe.vanilla.FurnaceFuelHandler;
+import nc.recipe.vanilla.FurnaceRecipeHandler;
 import net.minecraft.item.crafting.IRecipe;
 import net.minecraftforge.event.RegistryEvent;
-import net.minecraftforge.fml.common.eventhandler.*;
+import net.minecraftforge.fml.common.eventhandler.EventPriority;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 import net.minecraftforge.fml.common.registry.GameRegistry;

 public class NCRecipes {
@ -106,6 +143,10 @@ public class NCRecipes {
 		FurnaceRecipeHandler.registerFurnaceRecipes();
 		GameRegistry.registerFuelHandler(new FurnaceFuelHandler());
 		
+		for (RegistrationInfo info : CTRegistration.INFO_LIST) {
+			info.recipeInit();
+		}
+		
 		initialized = true;
 	}
 	
--- a/src/main/java/nc/tile/internal/fluid/Tank.java
+++ b/src/main/java/nc/tile/internal/fluid/Tank.java
@ -10,7 +10,7 @@ import net.minecraftforge.fml.common.network.ByteBufUtils;

 public class Tank extends FluidTank {
 	
-	private final List<String> allowedFluids;
+	private List<String> allowedFluids;
 	
 	public Tank(int capacity, List<String> allowedFluids) {
 		super(capacity);
@ -28,6 +28,21 @@ public class Tank extends FluidTank {
 		return fluid != null && (allowedFluids == null || allowedFluids.contains(fluid.getName()));
 	}
 	
+	public void setAllowedFluids(List<String> allowedFluids) {
+		if (allowedFluids == null) {
+			this.allowedFluids = null;
+		}
+		else {
+			if (this.allowedFluids == null) {
+				this.allowedFluids = new ArrayList<>();
+			}
+			else {
+				this.allowedFluids.clear();
+			}
+			this.allowedFluids.addAll(allowedFluids);
+		}
+	}
+	
 	// Tank Methods
 	
 	public void changeFluidStored(Fluid fluid, int amount) {
--- a/src/main/java/nc/tile/radiation/TileGeigerCounter.java
+++ b/src/main/java/nc/tile/radiation/TileGeigerCounter.java
@ -62,7 +62,7 @@ public class TileGeigerCounter extends NCTile implements SimpleComponent {
 	@Override
 	@Optional.Method(modid = "opencomputers")
 	public String getComponentName() {
-		return Global.MOD_SHORT_ID + "_geiger_counter";
+		return "nc_geiger_counter";
 	}
 	
 	@Callback
--- a/src/main/java/nc/tile/radiation/TileRadiationScrubber.java
+++ b/src/main/java/nc/tile/radiation/TileRadiationScrubber.java
@ -313,7 +313,7 @@ public class TileRadiationScrubber extends TileItemFluidGenerator implements ITi
 	@Override
 	@Optional.Method(modid = "opencomputers")
 	public String getComponentName() {
-		return Global.MOD_SHORT_ID + "_radiation_scrubber";
+		return "nc_radiation_scrubber";
 	}
 	
 	@Callback
--- a/src/main/java/nc/util/BlockHelper.java
+++ b/src/main/java/nc/util/BlockHelper.java
@ -99,8 +99,7 @@ public class BlockHelper {
 		}
 	}
 	
-	// Accessing machine tanks - taken from net.minecraftforge.fluids.FluidUtil
-	// and modified to correctly handle ITileFluids
+	// Accessing machine tanks - taken from net.minecraftforge.fluids.FluidUtil and modified to correctly handle ITileFluids
 	public static boolean accessTanks(EntityPlayer player, EnumHand hand, EnumFacing facing, ITileFluid tile) {
 		if (player == null || tile == null) {
 			return false;
--- a/src/main/java/nc/util/NCUtil.java
+++ b/src/main/java/nc/util/NCUtil.java
@ -8,6 +8,7 @@ import org.apache.logging.log4j.*;
 import org.lwjgl.input.Keyboard;

 import nc.Global;
+import net.minecraft.launchwrapper.Launch;

 public class NCUtil {
 	
--- a/src/main/java/nc/util/OreDictHelper.java
+++ b/src/main/java/nc/util/OreDictHelper.java
@ -150,11 +150,11 @@ public class OreDictHelper {
 	
 	// Wildcard Helper
 	
-	public static void addWildcard(Set<String> set, String ore) {
+	public static void addWildcard(Collection<String> collection, String ore) {
 		ore = StringHelper.regex(ore);
 		for (String o : OreDictionary.getOreNames()) {
 			if (o.matches(ore)) {
-				set.add(o);
+				collection.add(o);
 			}
 		}
 	}
--- a/src/main/java/nc/worldgen/dimension/NCWorlds.java
+++ b/src/main/java/nc/worldgen/dimension/NCWorlds.java
@ -8,7 +8,7 @@ import net.minecraftforge.common.DimensionManager;

 public class NCWorlds {
 	
-	public static final String WASTELAND_DIM_NAME = Global.MOD_SHORT_ID + "_wasteland";
+	public static final String WASTELAND_DIM_NAME = "nc_wasteland";
 	public static final int WASTELAND_DIM_ID = wasteland_dimension;
 	public static final DimensionType WASTELAND_DIM_TYPE = DimensionType.register(WASTELAND_DIM_NAME, "_" + WASTELAND_DIM_NAME, WASTELAND_DIM_ID, WorldProviderWasteland.class, false);
 	public static final WorldProvider WASTELAND_WORLD_PROVIDER = new WorldProviderWasteland();
--- a/src/main/resources/assets/nuclearcraft/blockstates/fission_cell_port.json
+++ b/src/main/resources/assets/nuclearcraft/blockstates/fission_cell_port.json
@ -1,12 +1,9 @@
 {
 	"forge_marker": 1,
 	"defaults": {
-		"model": "nuclearcraft:wall_part",
+		"model": "nuclearcraft:fission_port",
 		"textures": {
-			"in": "nuclearcraft:blocks/fission/port/cell",
-			"out": "nuclearcraft:blocks/fission/port/cell",
-			"side": "nuclearcraft:blocks/fission/port/side",
-			"top": "nuclearcraft:blocks/fission/port/top"
+			"front": "nuclearcraft:blocks/fission/port/cell"
 		}
 	},
 	"variants": {
--- a/src/main/resources/assets/nuclearcraft/blockstates/fission_heater_port.json
+++ b/src/main/resources/assets/nuclearcraft/blockstates/fission_heater_port.json
@ -1,11 +1,7 @@
 {
 	"forge_marker": 1,
 	"defaults": {
-		"model": "nuclearcraft:wall_part",
-		"textures": {
-			"side": "nuclearcraft:blocks/fission/port/side",
-			"top": "nuclearcraft:blocks/fission/port/top"
-		}
+		"model": "nuclearcraft:fission_port"
 	},
 	"variants": {
 		"axis": {
@ -16,98 +12,82 @@
 		"type": {
 			"standard": {
 				"textures": {
-					"in": "nuclearcraft:blocks/fission/port/heater/standard",
-					"out": "nuclearcraft:blocks/fission/port/heater/standard"
+					"front": "nuclearcraft:blocks/fission/port/heater/standard"
 				}
 			},
 			"iron": {
 				"textures": {
-					"in": "nuclearcraft:blocks/fission/port/heater/iron",
-					"out": "nuclearcraft:blocks/fission/port/heater/iron"
+					"front": "nuclearcraft:blocks/fission/port/heater/iron"
 				}
 			},
 			"redstone": {
 				"textures": {
-					"in": "nuclearcraft:blocks/fission/port/heater/redstone",
-					"out": "nuclearcraft:blocks/fission/port/heater/redstone"
+					"front": "nuclearcraft:blocks/fission/port/heater/redstone"
 				}
 			},
 			"quartz": {
 				"textures": {
-					"in": "nuclearcraft:blocks/fission/port/heater/quartz",
-					"out": "nuclearcraft:blocks/fission/port/heater/quartz"
+					"front": "nuclearcraft:blocks/fission/port/heater/quartz"
 				}
 			},
 			"obsidian": {
 				"textures": {
-					"in": "nuclearcraft:blocks/fission/port/heater/obsidian",
-					"out": "nuclearcraft:blocks/fission/port/heater/obsidian"
+					"front": "nuclearcraft:blocks/fission/port/heater/obsidian"
 				}
 			},
 			"nether_brick": {
 				"textures": {
-					"in": "nuclearcraft:blocks/fission/port/heater/nether_brick",
-					"out": "nuclearcraft:blocks/fission/port/heater/nether_brick"
+					"front": "nuclearcraft:blocks/fission/port/heater/nether_brick"
 				}
 			},
 			"glowstone": {
 				"textures": {
-					"in": "nuclearcraft:blocks/fission/port/heater/glowstone",
-					"out": "nuclearcraft:blocks/fission/port/heater/glowstone"
+					"front": "nuclearcraft:blocks/fission/port/heater/glowstone"
 				}
 			},
 			"lapis": {
 				"textures": {
-					"in": "nuclearcraft:blocks/fission/port/heater/lapis",
-					"out": "nuclearcraft:blocks/fission/port/heater/lapis"
+					"front": "nuclearcraft:blocks/fission/port/heater/lapis"
 				}
 			},
 			"gold": {
 				"textures": {
-					"in": "nuclearcraft:blocks/fission/port/heater/gold",
-					"out": "nuclearcraft:blocks/fission/port/heater/gold"
+					"front": "nuclearcraft:blocks/fission/port/heater/gold"
 				}
 			},
 			"prismarine": {
 				"textures": {
-					"in": "nuclearcraft:blocks/fission/port/heater/prismarine",
-					"out": "nuclearcraft:blocks/fission/port/heater/prismarine"
+					"front": "nuclearcraft:blocks/fission/port/heater/prismarine"
 				}
 			},
 			"slime": {
 				"textures": {
-					"in": "nuclearcraft:blocks/fission/port/heater/slime",
-					"out": "nuclearcraft:blocks/fission/port/heater/slime"
+					"front": "nuclearcraft:blocks/fission/port/heater/slime"
 				}
 			},
 			"end_stone": {
 				"textures": {
-					"in": "nuclearcraft:blocks/fission/port/heater/end_stone",
-					"out": "nuclearcraft:blocks/fission/port/heater/end_stone"
+					"front": "nuclearcraft:blocks/fission/port/heater/end_stone"
 				}
 			},
 			"purpur": {
 				"textures": {
-					"in": "nuclearcraft:blocks/fission/port/heater/purpur",
-					"out": "nuclearcraft:blocks/fission/port/heater/purpur"
+					"front": "nuclearcraft:blocks/fission/port/heater/purpur"
 				}
 			},
 			"diamond": {
 				"textures": {
-					"in": "nuclearcraft:blocks/fission/port/heater/diamond",
-					"out": "nuclearcraft:blocks/fission/port/heater/diamond"
+					"front": "nuclearcraft:blocks/fission/port/heater/diamond"
 				}
 			},
 			"emerald": {
 				"textures": {
-					"in": "nuclearcraft:blocks/fission/port/heater/emerald",
-					"out": "nuclearcraft:blocks/fission/port/heater/emerald"
+					"front": "nuclearcraft:blocks/fission/port/heater/emerald"
 				}
 			},
 			"copper": {
 				"textures": {
-					"in": "nuclearcraft:blocks/fission/port/heater/copper",
-					"out": "nuclearcraft:blocks/fission/port/heater/copper"
+					"front": "nuclearcraft:blocks/fission/port/heater/copper"
 				}
 			}
 		}
--- a/src/main/resources/assets/nuclearcraft/blockstates/fission_heater_port2.json
+++ b/src/main/resources/assets/nuclearcraft/blockstates/fission_heater_port2.json
@ -1,11 +1,7 @@
 {
 	"forge_marker": 1,
 	"defaults": {
-		"model": "nuclearcraft:wall_part",
-		"textures": {
-			"side": "nuclearcraft:blocks/fission/port/side",
-			"top": "nuclearcraft:blocks/fission/port/top"
-		}
+		"model": "nuclearcraft:fission_port"
 	},
 	"variants": {
 		"axis": {
@ -16,98 +12,82 @@
 		"type": {
 			"tin": {
 				"textures": {
-					"in": "nuclearcraft:blocks/fission/port/heater/tin",
-					"out": "nuclearcraft:blocks/fission/port/heater/tin"
+					"front": "nuclearcraft:blocks/fission/port/heater/tin"
 				}
 			},
 			"lead": {
 				"textures": {
-					"in": "nuclearcraft:blocks/fission/port/heater/lead",
-					"out": "nuclearcraft:blocks/fission/port/heater/lead"
+					"front": "nuclearcraft:blocks/fission/port/heater/lead"
 				}
 			},
 			"boron": {
 				"textures": {
-					"in": "nuclearcraft:blocks/fission/port/heater/boron",
-					"out": "nuclearcraft:blocks/fission/port/heater/boron"
+					"front": "nuclearcraft:blocks/fission/port/heater/boron"
 				}
 			},
 			"lithium": {
 				"textures": {
-					"in": "nuclearcraft:blocks/fission/port/heater/lithium",
-					"out": "nuclearcraft:blocks/fission/port/heater/lithium"
+					"front": "nuclearcraft:blocks/fission/port/heater/lithium"
 				}
 			},
 			"magnesium": {
 				"textures": {
-					"in": "nuclearcraft:blocks/fission/port/heater/magnesium",
-					"out": "nuclearcraft:blocks/fission/port/heater/magnesium"
+					"front": "nuclearcraft:blocks/fission/port/heater/magnesium"
 				}
 			},
 			"manganese": {
 				"textures": {
-					"in": "nuclearcraft:blocks/fission/port/heater/manganese",
-					"out": "nuclearcraft:blocks/fission/port/heater/manganese"
+					"front": "nuclearcraft:blocks/fission/port/heater/manganese"
 				}
 			},
 			"aluminum": {
 				"textures": {
-					"in": "nuclearcraft:blocks/fission/port/heater/aluminum",
-					"out": "nuclearcraft:blocks/fission/port/heater/aluminum"
+					"front": "nuclearcraft:blocks/fission/port/heater/aluminum"
 				}
 			},
 			"silver": {
 				"textures": {
-					"in": "nuclearcraft:blocks/fission/port/heater/silver",
-					"out": "nuclearcraft:blocks/fission/port/heater/silver"
+					"front": "nuclearcraft:blocks/fission/port/heater/silver"
 				}
 			},
 			"fluorite": {
 				"textures": {
-					"in": "nuclearcraft:blocks/fission/port/heater/fluorite",
-					"out": "nuclearcraft:blocks/fission/port/heater/fluorite"
+					"front": "nuclearcraft:blocks/fission/port/heater/fluorite"
 				}
 			},
 			"villiaumite": {
 				"textures": {
-					"in": "nuclearcraft:blocks/fission/port/heater/villiaumite",
-					"out": "nuclearcraft:blocks/fission/port/heater/villiaumite"
+					"front": "nuclearcraft:blocks/fission/port/heater/villiaumite"
 				}
 			},
 			"carobbiite": {
 				"textures": {
-					"in": "nuclearcraft:blocks/fission/port/heater/carobbiite",
-					"out": "nuclearcraft:blocks/fission/port/heater/carobbiite"
+					"front": "nuclearcraft:blocks/fission/port/heater/carobbiite"
 				}
 			},
 			"arsenic": {
 				"textures": {
-					"in": "nuclearcraft:blocks/fission/port/heater/arsenic",
-					"out": "nuclearcraft:blocks/fission/port/heater/arsenic"
+					"front": "nuclearcraft:blocks/fission/port/heater/arsenic"
 				}
 			},
 			"liquid_nitrogen": {
 				"textures": {
-					"in": "nuclearcraft:blocks/fission/port/heater/liquid_nitrogen",
-					"out": "nuclearcraft:blocks/fission/port/heater/liquid_nitrogen"
+					"front": "nuclearcraft:blocks/fission/port/heater/liquid_nitrogen"
 				}
 			},
 			"liquid_helium": {
 				"textures": {
-					"in": "nuclearcraft:blocks/fission/port/heater/liquid_helium",
-					"out": "nuclearcraft:blocks/fission/port/heater/liquid_helium"
+					"front": "nuclearcraft:blocks/fission/port/heater/liquid_helium"
 				}
 			},
 			"enderium": {
 				"textures": {
-					"in": "nuclearcraft:blocks/fission/port/heater/enderium",
-					"out": "nuclearcraft:blocks/fission/port/heater/enderium"
+					"front": "nuclearcraft:blocks/fission/port/heater/enderium"
 				}
 			},
 			"cryotheum": {
 				"textures": {
-					"in": "nuclearcraft:blocks/fission/port/heater/cryotheum",
-					"out": "nuclearcraft:blocks/fission/port/heater/cryotheum"
+					"front": "nuclearcraft:blocks/fission/port/heater/cryotheum"
 				}
 			}
 		}
--- a/src/main/resources/assets/nuclearcraft/blockstates/fission_irradiator_port.json
+++ b/src/main/resources/assets/nuclearcraft/blockstates/fission_irradiator_port.json
@ -1,12 +1,9 @@
 {
 	"forge_marker": 1,
 	"defaults": {
-		"model": "nuclearcraft:wall_part",
+		"model": "nuclearcraft:fission_port",
 		"textures": {
-			"in": "nuclearcraft:blocks/fission/port/irradiator",
-			"out": "nuclearcraft:blocks/fission/port/irradiator",
-			"side": "nuclearcraft:blocks/fission/port/side",
-			"top": "nuclearcraft:blocks/fission/port/top"
+			"front": "nuclearcraft:blocks/fission/port/irradiator"
 		}
 	},
 	"variants": {
--- a/src/main/resources/assets/nuclearcraft/blockstates/fission_vessel_port.json
+++ b/src/main/resources/assets/nuclearcraft/blockstates/fission_vessel_port.json
@ -1,12 +1,9 @@
 {
 	"forge_marker": 1,
 	"defaults": {
-		"model": "nuclearcraft:wall_part",
+		"model": "nuclearcraft:fission_port",
 		"textures": {
-			"in": "nuclearcraft:blocks/fission/port/vessel",
-			"out": "nuclearcraft:blocks/fission/port/vessel",
-			"side": "nuclearcraft:blocks/fission/port/side",
-			"top": "nuclearcraft:blocks/fission/port/top"
+			"front": "nuclearcraft:blocks/fission/port/vessel"
 		}
 	},
 	"variants": {
--- a/src/main/resources/assets/nuclearcraft/models/block/fission_port.json
+++ b/src/main/resources/assets/nuclearcraft/models/block/fission_port.json
@ -0,0 +1,9 @@
+{
+    "parent": "nuclearcraft:block/wall_part",
+	"textures": {
+        "side": "nuclearcraft:blocks/fission/port/side",
+        "top": "nuclearcraft:blocks/fission/port/side",
+        "in": "#front",
+        "out": "#front"
+    }
+}
--- a/todo.txt
+++ b/todo.txt
@ -21,6 +21,10 @@ Link managers to listeners with multitool (default behaviour: act on all listene

 Multiblock monitors: show cluster information, side configurations, etc.

+Dimension dependent radiation spread rate, use overworld rate if entry doesn't exist
+
+OC support for side configurations
+
 Patchouli documentation
 ___________________________________________________________________________________________________________________________
 ---------------------------------------------------------------------------------------------------------------------------
@ -44,11 +48,6 @@ ________________________________________________________________________________
 1.15: Add sound effects from Exile to machines
 ___________________________________________________________________________________________________________________________

-Dimension dependent radiation spread rate, use overworld rate if entry doesn't exist
-
-OC support for side configurations
-___________________________________________________________________________________________________________________________
-
 Multiblock Electrolyser

 Girdler process for deuterium extraction: https://en.wikipedia.org/wiki/Girdler_sulfide_process
Author	SHA1	Message	Date
Tom Dodd	648cbb546d	Update build.gradle	2020-07-21 22:41:11 +01:00
Tom Dodd	bd4ce97bc9	Update build.gradle	2020-07-21 20:39:47 +01:00
Tom Dodd	d484fbd20d	Merge branch 'master' of https://github.com/turbodiesel4598/NuclearCraft	2020-07-21 20:24:33 +01:00
Tom Dodd	c71090c3db	v2o.3.4 v2o.3.4	2020-07-21 20:24:23 +01:00