Added Recipe for Computer Cube MKII, Turbine Shaft, Rotor Assembly & Elemental Duplicator.

Removed a whole heap of pointless Reactor Planner files/functions.
Hide some of the modes in the Computer Cube.

1 files changed, 91 insertions, 159 deletions

diff --git a/src/main/java/Ic2ExpReactorPlanner/AutomationSimulator.java b/src/main/java/Ic2ExpReactorPlanner/AutomationSimulator.java
index 488de59a8d..729642e837 100644
--- a/src/main/java/Ic2ExpReactorPlanner/AutomationSimulator.java
+++ b/src/main/java/Ic2ExpReactorPlanner/AutomationSimulator.java
@@ -1,8 +1,5 @@
 package Ic2ExpReactorPlanner;
 
-import static Ic2ExpReactorPlanner.BundleHelper.formatI18n;
-import static Ic2ExpReactorPlanner.BundleHelper.getI18n;
-
 import java.text.DecimalFormat;
 import java.util.ArrayList;
 import java.util.List;
@@ -24,8 +21,6 @@ public class AutomationSimulator {
 
 	private final GT_TileEntity_ComputerCube mReactor;
 
-	private final boolean[][] alreadyBroken = new boolean[6][9];
-
 	private final boolean[][] needsCooldown = new boolean[6][9];
 
 	private final int initialHeat;
@@ -77,13 +72,11 @@ public class AutomationSimulator {
 
 	private int lapisUsed = 0;
 
-	private final MaterialsList replacedItems = new MaterialsList();
-
-	private static final DecimalFormat DECIMAL_FORMAT = new DecimalFormat(getI18n("Simulation.DecimalFormat"));
 
 	private boolean completed = false;
 	
 	private boolean mRunning = false;
+    private static final DecimalFormat DECIMAL_FORMAT = new DecimalFormat("#,##0.##");
 
 	private final SimulationData data = new SimulationData();
 	public SimulationData getData() {
@@ -116,7 +109,7 @@ public class AutomationSimulator {
 		int totalRodCount = 0;
 
 		publish(""); // NOI18N
-		publish(getI18n("Simulation.Started"));
+		publish("Simulation.Started");
 		reactor.setCurrentHeat(initialHeat);
 		reactor.clearVentedHeat();
 		double minReactorHeat = initialHeat;
@@ -241,40 +234,34 @@ public class AutomationSimulator {
 			calculateHeatingCooling(reactorTicks);
 			handleAutomation(reactorTicks);
 
-			handleBrokenComponents(reactorTicks, totalHeatOutput, totalRodCount, totalEUoutput, minReactorHeat, maxReactorHeat);
 		}
 
 		if (hasStopped()) {
-			publish(formatI18n("Simulation.CancelledAtTick", reactorTicks));
+			publish("Simulation.CancelledAtTick", reactorTicks);
 		}
 		data.minTemp = (int) minReactorHeat;
 		data.maxTemp = (int) maxReactorHeat;
-		publish(formatI18n("Simulation.ReactorMinTemp", minReactorHeat));
-		publish(formatI18n("Simulation.ReactorMaxTemp", maxReactorHeat));
+		publish("Simulation.ReactorMinTemp", minReactorHeat);
+		publish("Simulation.ReactorMaxTemp", maxReactorHeat);
 		if (reactor.getCurrentHeat() < reactor.getMaxHeat()) {
-			publish(formatI18n("Simulation.TimeWithoutExploding", reactorTicks));
+			publish("Simulation.TimeWithoutExploding", reactorTicks);
 			if (reactor.isPulsed()) {
 				String rangeString = "";
 				if (maxActiveTime > minActiveTime) {
-					rangeString = formatI18n("Simulation.ActiveTimeRange", minActiveTime, maxActiveTime);
+					rangeString = rangeString("Simulation.ActiveTimeRange", minActiveTime, maxActiveTime);
 				}
 				else if (minActiveTime < activeTime) {
-					rangeString = formatI18n("Simulation.ActiveTimeSingle", minActiveTime);
+					rangeString = "Simulation.ActiveTimeSingle "+minActiveTime;
 				}
-				publish(formatI18n("Simulation.ActiveTime", activeTime, rangeString));
+				publish("Simulation.ActiveTime", activeTime, rangeString);
 				rangeString = "";
 				if (maxInactiveTime > minInactiveTime) {
-					rangeString = formatI18n("Simulation.InactiveTimeRange", minInactiveTime, maxInactiveTime);
+					rangeString = rangeString("Simulation.InactiveTimeRange", minInactiveTime, maxInactiveTime);
 				}
 				else if (minInactiveTime < inactiveTime) {
-					rangeString = formatI18n("Simulation.InactiveTimeSingle", minInactiveTime);
+					rangeString = "Simulation.InactiveTimeSingle " + minInactiveTime;
 				}
-				publish(formatI18n("Simulation.InactiveTime", inactiveTime, rangeString));
-			}
-			final String replacedItemsString = replacedItems.toString();
-			if (!replacedItemsString.isEmpty()) {
-				data.replacedItems = new MaterialsList(replacedItems);
-				publish(formatI18n("Simulation.ComponentsReplaced", replacedItemsString));
+				publish("Simulation.InactiveTime", inactiveTime, rangeString);
 			}
 
 			if (reactorTicks > 0) {
@@ -285,10 +272,10 @@ public class AutomationSimulator {
 					data.minHUoutput = 2 * minHeatOutput;
 					data.maxHUoutput = (int) (2 * maxHeatOutput);
 					if (totalHeatOutput > 0) {
-						publish(formatI18n("Simulation.HeatOutputs", DECIMAL_FORMAT.format(40 * totalHeatOutput), DECIMAL_FORMAT.format(2 * totalHeatOutput / reactorTicks), DECIMAL_FORMAT.format(2
-								* minHeatOutput), DECIMAL_FORMAT.format(2 * maxHeatOutput)));
+						publish("Simulation.HeatOutputs", DECIMAL_FORMAT.format(40 * totalHeatOutput), DECIMAL_FORMAT.format(2 * totalHeatOutput / reactorTicks), DECIMAL_FORMAT.format(2
+								* minHeatOutput), DECIMAL_FORMAT.format(2 * maxHeatOutput));
 						if (totalRodCount > 0) {
-							publish(formatI18n("Simulation.Efficiency", totalHeatOutput / reactorTicks / 4 / totalRodCount, minHeatOutput / 4 / totalRodCount, maxHeatOutput / 4 / totalRodCount));
+							publish("Simulation.Efficiency", totalHeatOutput / reactorTicks / 4 / totalRodCount, minHeatOutput / 4 / totalRodCount, maxHeatOutput / 4 / totalRodCount);
 						}
 					}
 				}
@@ -298,17 +285,17 @@ public class AutomationSimulator {
 					data.minEUoutput = minEUoutput / 20.0;
 					data.maxEUoutput = (int) (maxEUoutput / 20.0);
 					if (totalEUoutput > 0) {
-						publish(formatI18n("Simulation.EUOutputs", DECIMAL_FORMAT.format(totalEUoutput), DECIMAL_FORMAT.format(totalEUoutput / (reactorTicks * 20)), DECIMAL_FORMAT.format(minEUoutput
-								/ 20.0), DECIMAL_FORMAT.format(maxEUoutput / 20.0)));
+						publish("Simulation.EUOutputs", DECIMAL_FORMAT.format(totalEUoutput), DECIMAL_FORMAT.format(totalEUoutput / (reactorTicks * 20)), DECIMAL_FORMAT.format(minEUoutput
+								/ 20.0), DECIMAL_FORMAT.format(maxEUoutput / 20.0));
 						if (totalRodCount > 0) {
-							publish(formatI18n("Simulation.Efficiency", totalEUoutput / reactorTicks / 100 / totalRodCount, minEUoutput / 100 / totalRodCount, maxEUoutput / 100 / totalRodCount));
+							publish("Simulation.Efficiency", totalEUoutput / reactorTicks / 100 / totalRodCount, minEUoutput / 100 / totalRodCount, maxEUoutput / 100 / totalRodCount);
 						}
 					}
 				}
 			}
 
 			if (reactor.getCurrentHeat() > 0.0) {
-				publish(formatI18n("Simulation.ReactorRemainingHeat", reactor.getCurrentHeat()));
+				publish("Simulation.ReactorRemainingHeat", reactor.getCurrentHeat());
 			}
 			double prevReactorHeat = reactor.getCurrentHeat();
 			double prevTotalComponentHeat = 0.0;
@@ -319,13 +306,13 @@ public class AutomationSimulator {
 						if (component.getCurrentHeat() > 0.0) {
 							prevTotalComponentHeat += component.getCurrentHeat();
 							publish(String.format("R%dC%d:0xFFA500", row, col)); // NOI18N
-							component.info.append(formatI18n("ComponentInfo.RemainingHeat", component.getCurrentHeat()));
+							component.info.append("ComponentInfo.RemainingHeat " + component.getCurrentHeat());
 						}
 					}
 				}
 			}
 			if (prevReactorHeat == 0.0 && prevTotalComponentHeat == 0.0) {
-				publish(getI18n("Simulation.NoCooldown"));
+				publish("Simulation.NoCooldown");
 			}
 			else if (reactor.getCurrentHeat() < reactor.getMaxHeat()) {
 				double currentTotalComponentHeat = prevTotalComponentHeat;
@@ -360,7 +347,7 @@ public class AutomationSimulator {
 							if (component != null && !component.isBroken()) {
 								currentTotalComponentHeat += component.getCurrentHeat();
 								if (component.getCurrentHeat() == 0.0 && needsCooldown[row][col]) {
-									component.info.append(formatI18n("ComponentInfo.CooldownTime", cooldownTicks));
+									component.info.append("ComponentInfo.CooldownTime " + cooldownTicks);
 									needsCooldown[row][col] = false;
 								}
 							}
@@ -370,17 +357,17 @@ public class AutomationSimulator {
 				while (lastHeatOutput > 0 && cooldownTicks < 50000);
 				if (reactor.getCurrentHeat() < reactor.getMaxHeat()) {
 					if (reactor.getCurrentHeat() == 0.0) {
-						publish(formatI18n("Simulation.ReactorCooldownTime", reactorCooldownTime));
+						publish("Simulation.ReactorCooldownTime", reactorCooldownTime);
 					}
 					else if (reactorCooldownTime > 0) {
-						publish(formatI18n("Simulation.ReactorResidualHeat", reactor.getCurrentHeat(), reactorCooldownTime));
+						publish("Simulation.ReactorResidualHeat", reactor.getCurrentHeat(), reactorCooldownTime);
 					}
-					publish(formatI18n("Simulation.TotalCooldownTime", cooldownTicks));
+					publish("Simulation.TotalCooldownTime", cooldownTicks);
 				}
 			}
 		}
 		else {
-			publish(formatI18n("Simulation.ReactorOverheatedTime", reactorTicks));
+			publish("Simulation.ReactorOverheatedTime", reactorTicks);
 			explosionPower = 10.0;
 			double explosionPowerMult = 1.0;
 			for (int row = 0; row < 6; row++) {
@@ -393,7 +380,7 @@ public class AutomationSimulator {
 				}
 			}
 			explosionPower *= explosionPowerMult;
-			publish(formatI18n("Simulation.ExplosionPower", explosionPower));
+			publish("Simulation.ExplosionPower", explosionPower);
 		}
 		double totalEffectiveVentCooling = 0.0;
 		double totalVentCoolingCapacity = 0.0;
@@ -405,81 +392,82 @@ public class AutomationSimulator {
 				ReactorItem component = reactor.getComponentAt(row, col);
 				if (component != null) {
 					if (component.getVentCoolingCapacity() > 0) {
-						component.info.append(formatI18n("ComponentInfo.UsedCooling", component.getBestVentCooling(), component.getVentCoolingCapacity()));
+						component.info.append("ComponentInfo.UsedCooling " + component.getBestVentCooling() + " | " + component.getVentCoolingCapacity());
 						totalEffectiveVentCooling += component.getBestVentCooling();
 						totalVentCoolingCapacity += component.getVentCoolingCapacity();
 					}
 					else if (component.getBestCellCooling() > 0) {
-						component.info.append(formatI18n("ComponentInfo.ReceivedHeat", component.getBestCellCooling()));
+						component.info.append("ComponentInfo.ReceivedHeat " + component.getBestCellCooling());
 						totalCellCooling += component.getBestCellCooling();
 					}
 					else if (component.getBestCondensatorCooling() > 0) {
-						component.info.append(formatI18n("ComponentInfo.ReceivedHeat", component.getBestCondensatorCooling()));
+						component.info.append("ComponentInfo.ReceivedHeat " + component.getBestCondensatorCooling());
 						totalCondensatorCooling += component.getBestCondensatorCooling();
 					}
 					else if (component.getMaxHeatGenerated() > 0) {
 						if (!reactor.isFluid() && component.getMaxEUGenerated() > 0) {
-							component.info.append(formatI18n("ComponentInfo.GeneratedEU", component.getMinEUGenerated(), component.getMaxEUGenerated()));
+							component.info.append("ComponentInfo.GeneratedEU " + component.getMinEUGenerated() + " | " + component.getMaxEUGenerated());
 						}
-						component.info.append(formatI18n("ComponentInfo.GeneratedHeat", component.getMinHeatGenerated(), component.getMaxHeatGenerated()));
+						component.info.append("ComponentInfo.GeneratedHeat " + component.getMinHeatGenerated() + " | " + component.getMaxHeatGenerated());
 					}
 					if (component.getMaxReachedHeat() > 0) {
-						component.info.append(formatI18n("ComponentInfo.ReachedHeat", component.getMaxReachedHeat(), component.getMaxHeat()));
+						component.info.append("ComponentInfo.ReachedHeat " + component.getMaxReachedHeat() + " | " + component.getMaxHeat());
 					}
 				}
 			}
 		}
 
 		// if (totalVentCoolingCapacity > 0) {
-		// publish(formatI18n("Simulation.TotalVentCooling",
-		// totalEffectiveVentCooling, totalVentCoolingCapacity));
+		// publish("Simulation.TotalVentCooling",
+		// totalEffectiveVentCooling, totalVentCoolingCapacity);
 		// }
 		showHeatingCooling(reactorTicks); // Call to show this info in case it
 											// hasn't already been shown, such
 											// as for an automated reactor.
 		if (totalCellCooling > 0) {
-			publish(formatI18n("Simulation.TotalCellCooling", totalCellCooling));
+			publish("Simulation.TotalCellCooling", totalCellCooling);
 		}
 		if (totalCondensatorCooling > 0) {
-			publish(formatI18n("Simulation.TotalCondensatorCooling", totalCondensatorCooling));
+			publish("Simulation.TotalCondensatorCooling", totalCondensatorCooling);
 		}
 		if (maxGeneratedHeat > 0) {
-			publish(formatI18n("Simulation.MaxHeatGenerated", maxGeneratedHeat));
+			publish("Simulation.MaxHeatGenerated", maxGeneratedHeat);
 		}
 		if (redstoneUsed > 0) {
-			publish(formatI18n("Simulation.RedstoneUsed", redstoneUsed));
+			publish("Simulation.RedstoneUsed", redstoneUsed);
 		}
 		if (lapisUsed > 0) {
-			publish(formatI18n("Simulation.LapisUsed", lapisUsed));
+			publish("Simulation.LapisUsed", lapisUsed);
 		}
 		// double totalCooling = totalEffectiveVentCooling + totalCellCooling +
 		// totalCondensatorCooling;
 		// if (totalCooling >= maxGeneratedHeat) {
-		// publish(formatI18n("Simulation.ExcessCooling", totalCooling -
-		// maxGeneratedHeat));
+		// publish("Simulation.ExcessCooling", totalCooling -
+		// maxGeneratedHeat);
 		// } else {
-		// publish(formatI18n("Simulation.ExcessHeating", maxGeneratedHeat -
-		// totalCooling));
+		// publish("Simulation.ExcessHeating", maxGeneratedHeat -
+		// totalCooling);
 		// }
 		// return null;
 
 		/* catch (Throwable e) {
 		if (cooldownTicks == 0) {
-			publish(formatI18n("Simulation.ErrorReactor", reactorTicks));
+			publish("Simulation.ErrorReactor", reactorTicks);
 		} else {
-			publish(formatI18n("Simulation.ErrorCooldown", cooldownTicks));
+			publish("Simulation.ErrorCooldown", cooldownTicks);
 		}
-		publish(e.toString(), " ", Arrays.toString(e.getStackTrace())); // NO18N
+		publish(e.toString(), " ", Arrays.toString(e.getStackTrace()); // NO18N
 		
 		}*/
 		data.explosionPower = (int) explosionPower;
 		data.totalReactorTicks = reactorTicks;
 		long endTime = System.nanoTime();
-		publish(formatI18n("Simulation.ElapsedTime", (endTime - startTime) / 1e9));
+		publish("Simulation.ElapsedTime", (endTime - startTime) / 1e9);
 		mRunning = false;
 		completed = true;
 	}
 
+
 	public boolean hasStopped() {
 		return !mRunning;
 	}
@@ -488,88 +476,6 @@ public class AutomationSimulator {
 		return mRunning;
 	}
 
-	private void handleBrokenComponents(final int reactorTicks, final double totalHeatOutput, final int totalRodCount, final double totalEUoutput, final double minReactorHeat, final double maxReactorHeat) {
-		for (int row = 0; row < 6; row++) {
-			for (int col = 0; col < 9; col++) {
-				ReactorItem component = reactor.getComponentAt(row, col);
-				if (component != null && component.isBroken() && !alreadyBroken[row][col]) {
-					alreadyBroken[row][col] = true;
-					if (component.getRodCount() == 0) {
-						publish(String.format("R%dC%d:0xFF0000", row, col)); // NOI18N
-						component.info.append(formatI18n("ComponentInfo.BrokeTime", reactorTicks));
-						if (componentsIntact) {
-							componentsIntact = false;
-							data.firstComponentBrokenTime = reactorTicks;
-							data.firstComponentBrokenRow = row;
-							data.firstComponentBrokenCol = col;
-							data.firstComponentBrokenDescription = component.toString();
-							publish(formatI18n("Simulation.FirstComponentBrokenDetails", component.toString(), row, col, reactorTicks));
-							if (reactor.isFluid()) {
-								data.prebreakTotalHUoutput = 40 * totalHeatOutput;
-								data.prebreakAvgHUoutput = 2 * totalHeatOutput / reactorTicks;
-								data.prebreakMinHUoutput = 2 * minHeatOutput;
-								data.prebreakMaxHUoutput = 2 * maxHeatOutput;
-								publish(formatI18n("Simulation.HeatOutputsBeforeBreak", DECIMAL_FORMAT.format(40 * totalHeatOutput), DECIMAL_FORMAT.format(2 * totalHeatOutput
-										/ reactorTicks), DECIMAL_FORMAT.format(2 * minHeatOutput), DECIMAL_FORMAT.format(2 * maxHeatOutput)));
-								if (totalRodCount > 0) {
-									publish(formatI18n("Simulation.Efficiency", totalHeatOutput / reactorTicks / 4 / totalRodCount, minHeatOutput / 4 / totalRodCount, maxHeatOutput / 4
-											/ totalRodCount));
-								}
-							}
-							else {
-								data.prebreakTotalEUoutput = totalEUoutput;
-								data.prebreakAvgEUoutput = totalEUoutput / (reactorTicks * 20);
-								data.prebreakMinEUoutput = minEUoutput / 20.0;
-								data.prebreakMaxEUoutput = maxEUoutput / 20.0;
-								publish(formatI18n("Simulation.EUOutputsBeforeBreak", DECIMAL_FORMAT.format(totalEUoutput), DECIMAL_FORMAT.format(totalEUoutput
-										/ (reactorTicks * 20)), DECIMAL_FORMAT.format(minEUoutput / 20.0), DECIMAL_FORMAT.format(maxEUoutput / 20.0)));
-								if (totalRodCount > 0) {
-									publish(formatI18n("Simulation.Efficiency", totalEUoutput / reactorTicks / 100 / totalRodCount, minEUoutput / 100 / totalRodCount, maxEUoutput / 100
-											/ totalRodCount));
-								}
-							}
-						}
-					}
-					else if (!anyRodsDepleted) {
-						anyRodsDepleted = true;
-						data.firstRodDepletedTime = reactorTicks;
-						data.firstRodDepletedRow = row;
-						data.firstRodDepletedCol = col;
-						data.firstRodDepletedDescription = component.toString();
-						publish(formatI18n("Simulation.FirstRodDepletedDetails", component.toString(), row, col, reactorTicks));
-						if (reactor.isFluid()) {
-							data.predepleteTotalHUoutput = 40 * totalHeatOutput;
-							data.predepleteAvgHUoutput = 2 * totalHeatOutput / reactorTicks;
-							data.predepleteMinHUoutput = 2 * minHeatOutput;
-							data.predepleteMaxHUoutput = 2 * maxHeatOutput;
-							publish(formatI18n("Simulation.HeatOutputsBeforeDepleted", DECIMAL_FORMAT.format(40 * totalHeatOutput), DECIMAL_FORMAT.format(2 * totalHeatOutput
-									/ reactorTicks), DECIMAL_FORMAT.format(2 * minHeatOutput), DECIMAL_FORMAT.format(2 * maxHeatOutput)));
-							if (totalRodCount > 0) {
-								publish(formatI18n("Simulation.Efficiency", totalHeatOutput / reactorTicks / 4 / totalRodCount, minHeatOutput / 4 / totalRodCount, maxHeatOutput / 4 / totalRodCount));
-							}
-						}
-						else {
-							data.predepleteTotalEUoutput = totalEUoutput;
-							data.predepleteAvgEUoutput = totalEUoutput / (reactorTicks * 20);
-							data.predepleteMinEUoutput = minEUoutput / 20.0;
-							data.predepleteMaxEUoutput = maxEUoutput / 20.0;
-							publish(formatI18n("Simulation.EUOutputsBeforeDepleted", DECIMAL_FORMAT.format(totalEUoutput), DECIMAL_FORMAT.format(totalEUoutput
-									/ (reactorTicks * 20)), DECIMAL_FORMAT.format(minEUoutput / 20.0), DECIMAL_FORMAT.format(maxEUoutput / 20.0)));
-							if (totalRodCount > 0) {
-								publish(formatI18n("Simulation.Efficiency", totalEUoutput / reactorTicks / 100 / totalRodCount, minEUoutput / 100 / totalRodCount, maxEUoutput / 100 / totalRodCount));
-							}
-						}
-						data.predepleteMinTemp = minReactorHeat;
-						data.predepleteMaxTemp = maxReactorHeat;
-						publish(formatI18n("Simulation.ReactorMinTempBeforeDepleted", minReactorHeat));
-						publish(formatI18n("Simulation.ReactorMaxTempBeforeDepleted", maxReactorHeat));
-					}
-					showHeatingCooling(reactorTicks);
-				}
-			}
-		}
-	}
-
 	private void handleAutomation(final int reactorTicks) {
 		for (int row = 0; row < 6; row++) {
 			for (int col = 0; col < 9; col++) {
@@ -578,8 +484,7 @@ public class AutomationSimulator {
 					if (component.getMaxHeat() > 1) {
 						if (component.getAutomationThreshold() > component.getInitialHeat() && component.getCurrentHeat() >= component.getAutomationThreshold()) {
 							component.clearCurrentHeat();
-							replacedItems.add(component.name);
-							component.info.append(formatI18n("ComponentInfo.ReplacedTime", reactorTicks));
+							component.info.append("ComponentInfo.ReplacedTime | " + reactorTicks);
 							if (component.getReactorPause() > 0) {
 								active = false;
 								pauseTimer = Math.max(pauseTimer, component.getReactorPause());
@@ -590,8 +495,7 @@ public class AutomationSimulator {
 						}
 						else if (component.getAutomationThreshold() < component.getInitialHeat() && component.getCurrentHeat() <= component.getAutomationThreshold()) {
 							component.clearCurrentHeat();
-							replacedItems.add(component.name);
-							component.info.append(formatI18n("ComponentInfo.ReplacedTime", reactorTicks));
+							component.info.append("ComponentInfo.ReplacedTime | " +reactorTicks);
 							if (component.getReactorPause() > 0) {
 								active = false;
 								pauseTimer = Math.max(pauseTimer, component.getReactorPause());
@@ -603,8 +507,7 @@ public class AutomationSimulator {
 					}
 					else if (component.isBroken() || (component.getMaxDamage() > 1 && component.getCurrentDamage() >= component.getAutomationThreshold())) {
 						component.clearDamage();
-						replacedItems.add(component.name);
-						component.info.append(formatI18n("ComponentInfo.ReplacedTime", reactorTicks));
+						component.info.append("ComponentInfo.ReplacedTime | " +reactorTicks);
 						if (component.getReactorPause() > 0) {
 							active = false;
 							pauseTimer = Math.max(pauseTimer, component.getReactorPause());
@@ -629,32 +532,32 @@ public class AutomationSimulator {
 
 	private void checkReactorTemperature(final int reactorTicks) {
 		if (reactor.getCurrentHeat() < 0.5 * reactor.getMaxHeat() && !reachedBelow50 && reachedEvaporate) {
-			publish(formatI18n("Simulation.TimeToBelow50", reactorTicks));
+			publish("Simulation.TimeToBelow50", reactorTicks);
 			reachedBelow50 = true;
 			data.timeToBelow50 = reactorTicks;
 		}
 		if (reactor.getCurrentHeat() >= 0.4 * reactor.getMaxHeat() && !reachedBurn) {
-			publish(formatI18n("Simulation.TimeToBurn", reactorTicks));
+			publish("Simulation.TimeToBurn", reactorTicks);
 			reachedBurn = true;
 			data.timeToBurn = reactorTicks;
 		}
 		if (reactor.getCurrentHeat() >= 0.5 * reactor.getMaxHeat() && !reachedEvaporate) {
-			publish(formatI18n("Simulation.TimeToEvaporate", reactorTicks));
+			publish("Simulation.TimeToEvaporate", reactorTicks);
 			reachedEvaporate = true;
 			data.timeToEvaporate = reactorTicks;
 		}
 		if (reactor.getCurrentHeat() >= 0.7 * reactor.getMaxHeat() && !reachedHurt) {
-			publish(formatI18n("Simulation.TimeToHurt", reactorTicks));
+			publish("Simulation.TimeToHurt", reactorTicks);
 			reachedHurt = true;
 			data.timeToHurt = reactorTicks;
 		}
 		if (reactor.getCurrentHeat() >= 0.85 * reactor.getMaxHeat() && !reachedLava) {
-			publish(formatI18n("Simulation.TimeToLava", reactorTicks));
+			publish("Simulation.TimeToLava", reactorTicks);
 			reachedLava = true;
 			data.timeToLava = reactorTicks;
 		}
 		if (reactor.getCurrentHeat() >= reactor.getMaxHeat() && !reachedExplode) {
-			publish(formatI18n("Simulation.TimeToXplode", reactorTicks));
+			publish("Simulation.TimeToXplode", reactorTicks);
 			reachedExplode = true;
 			data.timeToXplode = reactorTicks;
 		}
@@ -698,25 +601,54 @@ public class AutomationSimulator {
 				data.ventCooling = totalVentCooling / (reactorTicks - 20);
 				data.ventCoolingCapacity = totalVentCoolingCapacity;
 				if (totalHullHeating > 0) {
-					publish(formatI18n("Simulation.HullHeating", totalHullHeating / (reactorTicks - 20)));
+					publish("Simulation.HullHeating", totalHullHeating / (reactorTicks - 20));
 				}
 				if (totalComponentHeating > 0) {
-					publish(formatI18n("Simulation.ComponentHeating", totalComponentHeating / (reactorTicks - 20)));
+					publish("Simulation.ComponentHeating", totalComponentHeating / (reactorTicks - 20));
 				}
 				if (totalHullCoolingCapacity > 0) {
-					publish(formatI18n("Simulation.HullCooling", totalHullCooling / (reactorTicks - 20), totalHullCoolingCapacity));
+					publish("Simulation.HullCooling | " +totalHullCooling / (reactorTicks - 20), totalHullCoolingCapacity);
 				}
 				if (totalVentCoolingCapacity > 0) {
-					publish(formatI18n("Simulation.VentCooling", totalVentCooling / (reactorTicks - 20), totalVentCoolingCapacity));
+					publish("Simulation.VentCooling | " +totalVentCooling / (reactorTicks - 20), totalVentCoolingCapacity);
 				}
 			}
 		}
 	}
+	
+	private void publish(String string, double currentHeat, int reactorCooldownTime) {
+		publish(string + " | "+currentHeat+" | "+reactorCooldownTime);
+	}
 
+	private void publish(String string, double d, double e, double f) {
+		publish(string + " | "+d+" | "+e+" | "+f);
+	}
+
+	private void publish(String string, String format, String format2, String format3, String format4) {
+		publish(string + " | "+format+" | "+format2+" | "+format3+" | "+format4);
+	}
+
+	private void publish(String string, int activeTime2, String rangeString) {
+		publish(string + " | "+activeTime2+" | "+rangeString);
+	}
+
+	private void publish(String aString, double aData) {
+		publish(aString+":"+aData);
+	}
+
+	private void publish(String aString, long aData) {
+		publish(aString+":"+aData);
+	}
+	
 	private void publish(String aString) {
 		output.add(aString);
+	}	
+
+	private String rangeString(String string, int aMin, int aMax) {
+		return string+" ("+aMin+"-"+aMax+")";		
 	}
 
+
 	protected void process(List<String> chunks) {
 		/*
 		for (String chunk : chunks) {