Buildscript + Spotless (#318)

* Convert AES.java to readable class

* Buildscript

* Spotless

1 files changed, 546 insertions, 513 deletions

diff --git a/src/main/java/Ic2ExpReactorPlanner/components/ReactorItem.java b/src/main/java/Ic2ExpReactorPlanner/components/ReactorItem.java
index 9a9b1ce341..aee7f1c441 100644
--- a/src/main/java/Ic2ExpReactorPlanner/components/ReactorItem.java
+++ b/src/main/java/Ic2ExpReactorPlanner/components/ReactorItem.java
@@ -5,527 +5,560 @@
  */
 package Ic2ExpReactorPlanner.components;
 
-import java.util.HashMap;
-import java.util.ResourceBundle;
-
 import Ic2ExpReactorPlanner.Reactor;
 import gregtech.api.objects.GT_ItemStack;
+import java.util.HashMap;
 
 /**
  * Represents an item (component) in an IndustrialCraft2 Experimental Nuclear
  * Reactor.
- * 
+ *
  * @author Brian McCloud
  */
 public class ReactorItem {
-	
-	public static HashMap<String, ReactorItem> sComponentMap = new HashMap<String, ReactorItem>();
-	// Fundamental values, set at object instantiation, should never need to be
-	// changed.
-	public final int id;
-	public final String baseName; // this is the non-localized version, for
-									// internal program use
-	public final String name; // this is expected to be localized, for display
-								// usage.
-	protected double maxDamage;
-	
-	public double getMaxDamage() {
-		return maxDamage;
-	}
-	
-	protected double maxHeat;
-	
-	public double getMaxHeat() {
-		return maxHeat;
-	}
-	
-	public final String sourceMod; // for potentially adjusting controls based
-									// on whether the mod is in use, will be
-									// null to indicate the item is part of base
-									// IC2.
-	public final GT_ItemStack mItem;
-
-	// Simulation setting values
-	private double initialHeat = 0;
-
-	public double getInitialHeat() {
-		return initialHeat;
-	}
-
-	public void setInitialHeat(final double value) {
-		if (this.isHeatAcceptor() && value >= 0 && value < this.maxHeat) {
-			initialHeat = value;
-		}
-	}
-	private int automationThreshold = 9000;
-
-	public int getAutomationThreshold() {
-		return automationThreshold;
-	}
-
-	public void setAutomationThreshold(final int value) {
-		if (maxHeat > 1 || maxDamage > 1) {
-			automationThreshold = value;
-		}
-	}
-	private int reactorPause = 0;
-
-	public int getReactorPause() {
-		return reactorPause;
-	}
-
-	public void setReactorPause(final int value) {
-		if (maxHeat > 1 || maxDamage > 1) {
-			reactorPause = value;
-		}
-	}
-
-	// fields below here are not to be copied by the copy constructor.
-
-	// Parent reactor and position
-	protected Reactor parent = null;
-	protected int row = -10;
-	protected int col = -10;
-
-	// Special variable for holding information about this item from last
-	// simulation.
-	// Usage of StringBuffer instead of StringBuilder is deliberate - this may
-	// be accessed by
-	// both the simulation worker thread and the event dispatch thread.
-	public final StringBuffer info = new StringBuffer(1000);
-
-	// Calculated values - readable from outside, but only writable by
-	// subclasses.
-	protected double currentDamage = 0;
-	public double getCurrentDamage() {
-		return currentDamage;
-	}
-	protected double currentHeat = 0;
-	public double getCurrentHeat() {
-		return currentHeat;
-	}
-	protected double maxReachedHeat = 0;
-	public double getMaxReachedHeat() {
-		return maxReachedHeat;
-	}
-
-	protected double currentEUGenerated = 0;
-	public double getCurrentEUGenerated() {
-		return currentEUGenerated;
-	}
-	protected double minEUGenerated = Double.MAX_VALUE;
-	public double getMinEUGenerated() {
-		return minEUGenerated;
-	}
-	protected double maxEUGenerated = 0;
-	public double getMaxEUGenerated() {
-		return maxEUGenerated;
-	}
-
-	protected double currentHeatGenerated = 0;
-	public double getCurrentHeatGenerated() {
-		return currentHeatGenerated;
-	}
-	protected double minHeatGenerated = Double.MAX_VALUE;
-	public double getMinHeatGenerated() {
-		return minHeatGenerated;
-	}
-	protected double maxHeatGenerated = 0;
-	public double getMaxHeatGenerated() {
-		return maxHeatGenerated;
-	}
-
-	protected double currentHullHeating = 0;
-	public double getCurrentHullHeating() {
-		return currentHullHeating;
-	}
-	protected double currentComponentHeating = 0;
-	public double getCurrentComponentHeating() {
-		return currentComponentHeating;
-	}
-	protected double currentHullCooling = 0;
-	public double getCurrentHullCooling() {
-		return currentHullCooling;
-	}
-	protected double currentVentCooling = 0;
-	public double getCurrentVentCooling() {
-		return currentVentCooling;
-	}
-	protected double bestVentCooling = 0;
-	public double getBestVentCooling() {
-		return bestVentCooling;
-	}
-
-	protected double currentCellCooling = 0;
-	public double getCurrentCellCooling() {
-		return currentCellCooling;
-	}
-	protected double bestCellCooling = 0;
-	public double getBestCellCooling() {
-		return bestCellCooling;
-	}
-
-	protected double currentCondensatorCooling = 0;
-	public double getCurrentCondensatorCooling() {
-		return currentCondensatorCooling;
-	}
-	protected double bestCondensatorCooling = 0;
-	public double getBestCondensatorCooling() {
-		return bestCondensatorCooling;
-	}
-
-	protected double explosionPowerMultiplier = 1;
-
-	protected ReactorItem(final int id, final String baseName, GT_ItemStack aItem, final double maxDamage, final double maxHeat, String sourceMod) {
-		this.id = id;
-		this.baseName = baseName;
-		this.name = aItem.mItem.getItemStackDisplayName(aItem.toStack());
-		this.mItem = aItem;
-		this.maxDamage = maxDamage;
-		this.maxHeat = maxHeat;
-		if (maxHeat > 1) {
-			automationThreshold = (int) (maxHeat * 0.9);
-		}
-		else if (maxDamage > 1) {
-			automationThreshold = (int) (maxDamage * 1.1);
-		}
-		if (sourceMod == null) {
-			sourceMod = "IC2";
-		}
-		this.sourceMod = sourceMod;
-		sComponentMap.put(sourceMod+"."+aItem.mItem.getUnlocalizedName()+"."+aItem.mMetaData, this);
-	}
-
-	// Protected copy constructor for use by subclasses. Generalized copying
-	// should be done with a method in ComponentFactory (which can check which
-	// subclass copy constructor to use).
-	protected ReactorItem(final ReactorItem other) {
-		this.id = other.id;
-		this.baseName = other.baseName;
-		this.name = other.name;
-		this.mItem = other.mItem;
-		this.maxDamage = other.maxDamage;
-		this.maxHeat = other.maxHeat;
-		this.initialHeat = other.initialHeat;
-		this.automationThreshold = other.automationThreshold;
-		this.reactorPause = other.reactorPause;
-		this.sourceMod = other.sourceMod;
-	}
-
-	/**
-	 * Gets the name of the component, and the initial heat (if applicable).
-	 * 
-	 * @return the name of this component, and potentially initial heat.
-	 */
-	@Override
-	public String toString() {
-		String result = name;
-		if (initialHeat > 0) {
-			result += String.format("\u0020(initial heat: %,d)", (int) initialHeat);
-		}
-		return result;
-	}
-
-	/**
-	 * Checks if this component can accept heat. (e.g. from adjacent fuel rods,
-	 * or from an exchanger)
-	 * 
-	 * @return true if this component can accept heat, false otherwise.
-	 */
-	public boolean isHeatAcceptor() {
-		// maxHeat of 1 means this component never accepts heat (though it might
-		// take damage instead)
-		return maxHeat > 1 && !isBroken();
-	}
-
-	/**
-	 * Determines if this component can be cooled down, such as by a component
-	 * heat vent.
-	 * 
-	 * @return true if this component can be cooled down, false otherwise.
-	 */
-	public boolean isCoolable() {
-		return maxHeat > 1 && !(this instanceof Condensator);
-	}
-
-	/**
-	 * Checks if this component acts as a neutron reflector, and boosts
-	 * performance of adjacent fuel rods, either by being a "neutron reflector"
-	 * item or by being a fuel rod.
-	 * 
-	 * @return true if this component reflects neutrons, false otherwise.
-	 */
-	public boolean isNeutronReflector() {
-		return false;
-	}
-
-	/**
-	 * Prepare for a new reactor tick.
-	 */
-	public void preReactorTick() {
-		currentHullHeating = 0.0;
-		currentComponentHeating = 0.0;
-		currentHullCooling = 0.0;
-		currentVentCooling = 0.0;
-		currentCellCooling = 0.0;
-		currentCondensatorCooling = 0.0;
-		currentEUGenerated = 0;
-		currentHeatGenerated = 0;
-	}
-
-	/**
-	 * Generate heat if appropriate for component type, and spread to reactor or
-	 * adjacent cells.
-	 * 
-	 * @return the amount of heat generated by this component.
-	 */
-	public double generateHeat() {
-		return 0.0;
-	}
-
-	/**
-	 * Generate energy if appropriate for component type.
-	 * 
-	 * @return the number of EU generated by this component during the current
-	 *         reactor tick.
-	 */
-	public double generateEnergy() {
-		return 0.0;
-	}
-
-	/**
-	 * Dissipate (aka vent) heat if appropriate for component type.
-	 * 
-	 * @return the amount of heat successfully vented during the current reactor
-	 *         tick.
-	 */
-	public double dissipate() {
-		return 0.0;
-	}
-
-	/**
-	 * Transfer heat between component, neighbors, and/or reactor, if
-	 * appropriate for component type.
-	 */
-	public void transfer() {
-		// do nothing by default.
-	}
-
-	/**
-	 * Adds this component to a new reactor, and applies changes to the reactor
-	 * when adding this component if appropriate, such as for reactor plating.
-	 * 
-	 * @param parent
-	 *            the reactor to add this component to.
-	 * @param row
-	 *            the row this component will be in.
-	 * @param col
-	 *            the column this component will be in.
-	 */
-	public void addToReactor(final Reactor parent, final int row, final int col) {
-		// call removeFromReactor first, in case it had previously been added to
-		// a different reactor (unlikely)
-		removeFromReactor();
-		this.parent = parent;
-		this.row = row;
-		this.col = col;
-	}
-
-	/**
-	 * Removes this component from its reactor (if any), and applies changes to
-	 * the reactor when removing this component if appropriate, such as for
-	 * reactor plating.
-	 */
-	public void removeFromReactor() {
-		parent = null;
-		this.row = -10;
-		this.col = -10;
-	}
-
-	/**
-	 * Resets heat to 0 (used when resetting simulation).
-	 */
-	public final void clearCurrentHeat() {
-		currentHeat = initialHeat;
-		bestVentCooling = 0.0;
-		bestCondensatorCooling = 0.0;
-		bestCellCooling = 0.0;
-		minEUGenerated = Double.MAX_VALUE;
-		maxEUGenerated = 0.0;
-		minHeatGenerated = Double.MAX_VALUE;
-		maxHeatGenerated = 0.0;
-		maxReachedHeat = initialHeat;
-	}
-
-	/**
-	 * Adjusts the component heat up or down
-	 * 
-	 * @param heat
-	 *            the amount of heat to adjust by (positive to add heat,
-	 *            negative to remove heat).
-	 * @return the amount of heat adjustment refused. (e.g. due to going below
-	 *         minimum heat, breaking due to excessive heat, or attempting to
-	 *         remove heat from a condensator)
-	 */
-	public double adjustCurrentHeat(final double heat) {
-		if (isHeatAcceptor()) {
-			double result = 0.0;
-			double tempHeat = getCurrentHeat();
-			tempHeat += heat;
-			if (tempHeat > getMaxHeat()) {
-				result = getMaxHeat() - tempHeat + 1;
-				tempHeat = getMaxHeat();
-			}
-			else if (tempHeat < 0.0) {
-				result = tempHeat;
-				tempHeat = 0.0;
-			}
-			currentHeat = tempHeat;
-			maxReachedHeat = Math.max(maxReachedHeat, currentHeat);
-			return result;
-		}
-		return heat;
-	}
-
-	/**
-	 * Clears the damage back to 0 (used when resetting simulation, or replacing
-	 * the component in an automation simulation).
-	 */
-	public final void clearDamage() {
-		currentDamage = 0.0;
-	}
-
-	/**
-	 * Applies damage to the component, as opposed to heat. Mainly used for fuel
-	 * rods and neutron reflectors that lose durability as the reactor runs, but
-	 * can't recover it via cooling.
-	 * 
-	 * @param damage
-	 *            the damage to apply (only used if positive).
-	 */
-	public final void applyDamage(final double damage) {
-		// maxDamage of 1 is treated as meaning the component doesn't accept
-		// damage (though it might accept heat instead)
-		// if someone actually writes a mod with such a flimsy component, I
-		// might have to rethink this.
-		if (maxDamage > 1 && damage > 0.0) {
-			currentDamage += damage;
-		}
-	}
-
-	/**
-	 * Determines if this component is broken in the current tick of the
-	 * simulation
-	 * 
-	 * @return true if the component has broken either from damage (e.g. neutron
-	 *         reflectors, fuel rods) or from heat (e.g. heat vents, coolant
-	 *         cells), false otherwise.
-	 */
-	public boolean isBroken() {
-		return currentHeat >= getMaxHeat() || currentDamage >= getMaxDamage();
-	}
-
-	/**
-	 * The number of fuel rods in this component (0 for non-fuel-rod
-	 * components).
-	 * 
-	 * @return The number of fuel rods in this component, or 0 if this component
-	 *         has no fuel rods.
-	 */
-	public int getRodCount() {
-		return 0;
-	}
-
-	/**
-	 * Gets a value added in the formula for calculating explosion power.
-	 * 
-	 * @return the additive value for explosion power caused by this component,
-	 *         or 0 if this component doesn't affect the addition part of the
-	 *         explosion calculation.
-	 */
-	public double getExplosionPowerOffset() {
-		if (!isBroken()) {
-			if (getRodCount() == 0 && isNeutronReflector()) {
-				return -1;
-			}
-			return 2 * getRodCount(); // all known fuel rods (including those
-										// from GT) use this formula, and
-										// non-rod components return 0 for
-										// getRodCount
-		}
-		return 0;
-	}
-
-	/**
-	 * Gets a value multiplied in the formula for calculating explosion power.
-	 * 
-	 * @return the multiplier value for explosion power caused by this
-	 *         component, or 1 if this component doesn't affect the
-	 *         multiplication part of the explosion calculation.
-	 */
-	public double getExplosionPowerMultiplier() {
-		return explosionPowerMultiplier;
-	}
-
-	/**
-	 * Finds the theoretical maximum venting of this component, regardless of
-	 * whether this venting is from itself, directly from the reactor, or from
-	 * adjacent components.
-	 * 
-	 * @return the capacity of this component to vent heat.
-	 */
-	public double getVentCoolingCapacity() {
-		return 0;
-	}
-
-	/**
-	 * Finds the theoretical maximum hull cooling of this component.
-	 * 
-	 * @return the capacity of this component to remove heat from the reactor
-	 *         hull.
-	 */
-	public double getHullCoolingCapacity() {
-		return 0;
-	}
-
-	/**
-	 * Gets the current "output" of this component, presumably for writing to
-	 * CSV data. What this "output" means may vary by component type or reactor
-	 * type.
-	 * 
-	 * @return the output of this component for the current reactor tick.
-	 */
-	public double getCurrentOutput() {
-		return 0;
-	}
-
-	/**
-	 * Determines whether this component expects to produces some sort of output
-	 * each reactor tick, e.g. for purposes of tracking in a CSV file.
-	 * 
-	 * @return true if this component produces output (such as EU or vented
-	 *         heat), false otherwise.
-	 */
-	public boolean producesOutput() {
-		return getVentCoolingCapacity() > 0 || getRodCount() > 0;
-	}
-
-	/**
-	 * Determines if this component needs input from a Reactor Coolant Injector.
-	 * Simply returns false for non-condensator items.
-	 * 
-	 * @return true if this is a condensator that has absorbed enough heat to
-	 *         require the appropriate item added to repair it, false otherwise.
-	 */
-	public boolean needsCoolantInjected() {
-		return false;
-	}
-
-	/**
-	 * Simulates having a coolant item added by a Reactor Coolant Injector.
-	 */
-	public void injectCoolant() {
-		// do nothing by default.
-	}
 
+    public static HashMap<String, ReactorItem> sComponentMap = new HashMap<String, ReactorItem>();
+    // Fundamental values, set at object instantiation, should never need to be
+    // changed.
+    public final int id;
+    public final String baseName; // this is the non-localized version, for
+    // internal program use
+    public final String name; // this is expected to be localized, for display
+    // usage.
+    protected double maxDamage;
+
+    public double getMaxDamage() {
+        return maxDamage;
+    }
+
+    protected double maxHeat;
+
+    public double getMaxHeat() {
+        return maxHeat;
+    }
+
+    public final String sourceMod; // for potentially adjusting controls based
+    // on whether the mod is in use, will be
+    // null to indicate the item is part of base
+    // IC2.
+    public final GT_ItemStack mItem;
+
+    // Simulation setting values
+    private double initialHeat = 0;
+
+    public double getInitialHeat() {
+        return initialHeat;
+    }
+
+    public void setInitialHeat(final double value) {
+        if (this.isHeatAcceptor() && value >= 0 && value < this.maxHeat) {
+            initialHeat = value;
+        }
+    }
+
+    private int automationThreshold = 9000;
+
+    public int getAutomationThreshold() {
+        return automationThreshold;
+    }
+
+    public void setAutomationThreshold(final int value) {
+        if (maxHeat > 1 || maxDamage > 1) {
+            automationThreshold = value;
+        }
+    }
+
+    private int reactorPause = 0;
+
+    public int getReactorPause() {
+        return reactorPause;
+    }
+
+    public void setReactorPause(final int value) {
+        if (maxHeat > 1 || maxDamage > 1) {
+            reactorPause = value;
+        }
+    }
+
+    // fields below here are not to be copied by the copy constructor.
+
+    // Parent reactor and position
+    protected Reactor parent = null;
+    protected int row = -10;
+    protected int col = -10;
+
+    // Special variable for holding information about this item from last
+    // simulation.
+    // Usage of StringBuffer instead of StringBuilder is deliberate - this may
+    // be accessed by
+    // both the simulation worker thread and the event dispatch thread.
+    public final StringBuffer info = new StringBuffer(1000);
+
+    // Calculated values - readable from outside, but only writable by
+    // subclasses.
+    protected double currentDamage = 0;
+
+    public double getCurrentDamage() {
+        return currentDamage;
+    }
+
+    protected double currentHeat = 0;
+
+    public double getCurrentHeat() {
+        return currentHeat;
+    }
+
+    protected double maxReachedHeat = 0;
+
+    public double getMaxReachedHeat() {
+        return maxReachedHeat;
+    }
+
+    protected double currentEUGenerated = 0;
+
+    public double getCurrentEUGenerated() {
+        return currentEUGenerated;
+    }
+
+    protected double minEUGenerated = Double.MAX_VALUE;
+
+    public double getMinEUGenerated() {
+        return minEUGenerated;
+    }
+
+    protected double maxEUGenerated = 0;
+
+    public double getMaxEUGenerated() {
+        return maxEUGenerated;
+    }
+
+    protected double currentHeatGenerated = 0;
+
+    public double getCurrentHeatGenerated() {
+        return currentHeatGenerated;
+    }
+
+    protected double minHeatGenerated = Double.MAX_VALUE;
+
+    public double getMinHeatGenerated() {
+        return minHeatGenerated;
+    }
+
+    protected double maxHeatGenerated = 0;
+
+    public double getMaxHeatGenerated() {
+        return maxHeatGenerated;
+    }
+
+    protected double currentHullHeating = 0;
+
+    public double getCurrentHullHeating() {
+        return currentHullHeating;
+    }
+
+    protected double currentComponentHeating = 0;
+
+    public double getCurrentComponentHeating() {
+        return currentComponentHeating;
+    }
+
+    protected double currentHullCooling = 0;
+
+    public double getCurrentHullCooling() {
+        return currentHullCooling;
+    }
+
+    protected double currentVentCooling = 0;
+
+    public double getCurrentVentCooling() {
+        return currentVentCooling;
+    }
+
+    protected double bestVentCooling = 0;
+
+    public double getBestVentCooling() {
+        return bestVentCooling;
+    }
+
+    protected double currentCellCooling = 0;
+
+    public double getCurrentCellCooling() {
+        return currentCellCooling;
+    }
+
+    protected double bestCellCooling = 0;
+
+    public double getBestCellCooling() {
+        return bestCellCooling;
+    }
+
+    protected double currentCondensatorCooling = 0;
+
+    public double getCurrentCondensatorCooling() {
+        return currentCondensatorCooling;
+    }
+
+    protected double bestCondensatorCooling = 0;
+
+    public double getBestCondensatorCooling() {
+        return bestCondensatorCooling;
+    }
+
+    protected double explosionPowerMultiplier = 1;
+
+    protected ReactorItem(
+            final int id,
+            final String baseName,
+            GT_ItemStack aItem,
+            final double maxDamage,
+            final double maxHeat,
+            String sourceMod) {
+        this.id = id;
+        this.baseName = baseName;
+        this.name = aItem.mItem.getItemStackDisplayName(aItem.toStack());
+        this.mItem = aItem;
+        this.maxDamage = maxDamage;
+        this.maxHeat = maxHeat;
+        if (maxHeat > 1) {
+            automationThreshold = (int) (maxHeat * 0.9);
+        } else if (maxDamage > 1) {
+            automationThreshold = (int) (maxDamage * 1.1);
+        }
+        if (sourceMod == null) {
+            sourceMod = "IC2";
+        }
+        this.sourceMod = sourceMod;
+        sComponentMap.put(sourceMod + "." + aItem.mItem.getUnlocalizedName() + "." + aItem.mMetaData, this);
+    }
+
+    // Protected copy constructor for use by subclasses. Generalized copying
+    // should be done with a method in ComponentFactory (which can check which
+    // subclass copy constructor to use).
+    protected ReactorItem(final ReactorItem other) {
+        this.id = other.id;
+        this.baseName = other.baseName;
+        this.name = other.name;
+        this.mItem = other.mItem;
+        this.maxDamage = other.maxDamage;
+        this.maxHeat = other.maxHeat;
+        this.initialHeat = other.initialHeat;
+        this.automationThreshold = other.automationThreshold;
+        this.reactorPause = other.reactorPause;
+        this.sourceMod = other.sourceMod;
+    }
+
+    /**
+     * Gets the name of the component, and the initial heat (if applicable).
+     *
+     * @return the name of this component, and potentially initial heat.
+     */
+    @Override
+    public String toString() {
+        String result = name;
+        if (initialHeat > 0) {
+            result += String.format("\u0020(initial heat: %,d)", (int) initialHeat);
+        }
+        return result;
+    }
+
+    /**
+     * Checks if this component can accept heat. (e.g. from adjacent fuel rods,
+     * or from an exchanger)
+     *
+     * @return true if this component can accept heat, false otherwise.
+     */
+    public boolean isHeatAcceptor() {
+        // maxHeat of 1 means this component never accepts heat (though it might
+        // take damage instead)
+        return maxHeat > 1 && !isBroken();
+    }
+
+    /**
+     * Determines if this component can be cooled down, such as by a component
+     * heat vent.
+     *
+     * @return true if this component can be cooled down, false otherwise.
+     */
+    public boolean isCoolable() {
+        return maxHeat > 1 && !(this instanceof Condensator);
+    }
+
+    /**
+     * Checks if this component acts as a neutron reflector, and boosts
+     * performance of adjacent fuel rods, either by being a "neutron reflector"
+     * item or by being a fuel rod.
+     *
+     * @return true if this component reflects neutrons, false otherwise.
+     */
+    public boolean isNeutronReflector() {
+        return false;
+    }
+
+    /**
+     * Prepare for a new reactor tick.
+     */
+    public void preReactorTick() {
+        currentHullHeating = 0.0;
+        currentComponentHeating = 0.0;
+        currentHullCooling = 0.0;
+        currentVentCooling = 0.0;
+        currentCellCooling = 0.0;
+        currentCondensatorCooling = 0.0;
+        currentEUGenerated = 0;
+        currentHeatGenerated = 0;
+    }
+
+    /**
+     * Generate heat if appropriate for component type, and spread to reactor or
+     * adjacent cells.
+     *
+     * @return the amount of heat generated by this component.
+     */
+    public double generateHeat() {
+        return 0.0;
+    }
+
+    /**
+     * Generate energy if appropriate for component type.
+     *
+     * @return the number of EU generated by this component during the current
+     *         reactor tick.
+     */
+    public double generateEnergy() {
+        return 0.0;
+    }
+
+    /**
+     * Dissipate (aka vent) heat if appropriate for component type.
+     *
+     * @return the amount of heat successfully vented during the current reactor
+     *         tick.
+     */
+    public double dissipate() {
+        return 0.0;
+    }
+
+    /**
+     * Transfer heat between component, neighbors, and/or reactor, if
+     * appropriate for component type.
+     */
+    public void transfer() {
+        // do nothing by default.
+    }
+
+    /**
+     * Adds this component to a new reactor, and applies changes to the reactor
+     * when adding this component if appropriate, such as for reactor plating.
+     *
+     * @param parent
+     *            the reactor to add this component to.
+     * @param row
+     *            the row this component will be in.
+     * @param col
+     *            the column this component will be in.
+     */
+    public void addToReactor(final Reactor parent, final int row, final int col) {
+        // call removeFromReactor first, in case it had previously been added to
+        // a different reactor (unlikely)
+        removeFromReactor();
+        this.parent = parent;
+        this.row = row;
+        this.col = col;
+    }
+
+    /**
+     * Removes this component from its reactor (if any), and applies changes to
+     * the reactor when removing this component if appropriate, such as for
+     * reactor plating.
+     */
+    public void removeFromReactor() {
+        parent = null;
+        this.row = -10;
+        this.col = -10;
+    }
+
+    /**
+     * Resets heat to 0 (used when resetting simulation).
+     */
+    public final void clearCurrentHeat() {
+        currentHeat = initialHeat;
+        bestVentCooling = 0.0;
+        bestCondensatorCooling = 0.0;
+        bestCellCooling = 0.0;
+        minEUGenerated = Double.MAX_VALUE;
+        maxEUGenerated = 0.0;
+        minHeatGenerated = Double.MAX_VALUE;
+        maxHeatGenerated = 0.0;
+        maxReachedHeat = initialHeat;
+    }
+
+    /**
+     * Adjusts the component heat up or down
+     *
+     * @param heat
+     *            the amount of heat to adjust by (positive to add heat,
+     *            negative to remove heat).
+     * @return the amount of heat adjustment refused. (e.g. due to going below
+     *         minimum heat, breaking due to excessive heat, or attempting to
+     *         remove heat from a condensator)
+     */
+    public double adjustCurrentHeat(final double heat) {
+        if (isHeatAcceptor()) {
+            double result = 0.0;
+            double tempHeat = getCurrentHeat();
+            tempHeat += heat;
+            if (tempHeat > getMaxHeat()) {
+                result = getMaxHeat() - tempHeat + 1;
+                tempHeat = getMaxHeat();
+            } else if (tempHeat < 0.0) {
+                result = tempHeat;
+                tempHeat = 0.0;
+            }
+            currentHeat = tempHeat;
+            maxReachedHeat = Math.max(maxReachedHeat, currentHeat);
+            return result;
+        }
+        return heat;
+    }
+
+    /**
+     * Clears the damage back to 0 (used when resetting simulation, or replacing
+     * the component in an automation simulation).
+     */
+    public final void clearDamage() {
+        currentDamage = 0.0;
+    }
+
+    /**
+     * Applies damage to the component, as opposed to heat. Mainly used for fuel
+     * rods and neutron reflectors that lose durability as the reactor runs, but
+     * can't recover it via cooling.
+     *
+     * @param damage
+     *            the damage to apply (only used if positive).
+     */
+    public final void applyDamage(final double damage) {
+        // maxDamage of 1 is treated as meaning the component doesn't accept
+        // damage (though it might accept heat instead)
+        // if someone actually writes a mod with such a flimsy component, I
+        // might have to rethink this.
+        if (maxDamage > 1 && damage > 0.0) {
+            currentDamage += damage;
+        }
+    }
+
+    /**
+     * Determines if this component is broken in the current tick of the
+     * simulation
+     *
+     * @return true if the component has broken either from damage (e.g. neutron
+     *         reflectors, fuel rods) or from heat (e.g. heat vents, coolant
+     *         cells), false otherwise.
+     */
+    public boolean isBroken() {
+        return currentHeat >= getMaxHeat() || currentDamage >= getMaxDamage();
+    }
+
+    /**
+     * The number of fuel rods in this component (0 for non-fuel-rod
+     * components).
+     *
+     * @return The number of fuel rods in this component, or 0 if this component
+     *         has no fuel rods.
+     */
+    public int getRodCount() {
+        return 0;
+    }
+
+    /**
+     * Gets a value added in the formula for calculating explosion power.
+     *
+     * @return the additive value for explosion power caused by this component,
+     *         or 0 if this component doesn't affect the addition part of the
+     *         explosion calculation.
+     */
+    public double getExplosionPowerOffset() {
+        if (!isBroken()) {
+            if (getRodCount() == 0 && isNeutronReflector()) {
+                return -1;
+            }
+            return 2 * getRodCount(); // all known fuel rods (including those
+            // from GT) use this formula, and
+            // non-rod components return 0 for
+            // getRodCount
+        }
+        return 0;
+    }
+
+    /**
+     * Gets a value multiplied in the formula for calculating explosion power.
+     *
+     * @return the multiplier value for explosion power caused by this
+     *         component, or 1 if this component doesn't affect the
+     *         multiplication part of the explosion calculation.
+     */
+    public double getExplosionPowerMultiplier() {
+        return explosionPowerMultiplier;
+    }
+
+    /**
+     * Finds the theoretical maximum venting of this component, regardless of
+     * whether this venting is from itself, directly from the reactor, or from
+     * adjacent components.
+     *
+     * @return the capacity of this component to vent heat.
+     */
+    public double getVentCoolingCapacity() {
+        return 0;
+    }
+
+    /**
+     * Finds the theoretical maximum hull cooling of this component.
+     *
+     * @return the capacity of this component to remove heat from the reactor
+     *         hull.
+     */
+    public double getHullCoolingCapacity() {
+        return 0;
+    }
+
+    /**
+     * Gets the current "output" of this component, presumably for writing to
+     * CSV data. What this "output" means may vary by component type or reactor
+     * type.
+     *
+     * @return the output of this component for the current reactor tick.
+     */
+    public double getCurrentOutput() {
+        return 0;
+    }
+
+    /**
+     * Determines whether this component expects to produces some sort of output
+     * each reactor tick, e.g. for purposes of tracking in a CSV file.
+     *
+     * @return true if this component produces output (such as EU or vented
+     *         heat), false otherwise.
+     */
+    public boolean producesOutput() {
+        return getVentCoolingCapacity() > 0 || getRodCount() > 0;
+    }
+
+    /**
+     * Determines if this component needs input from a Reactor Coolant Injector.
+     * Simply returns false for non-condensator items.
+     *
+     * @return true if this is a condensator that has absorbed enough heat to
+     *         require the appropriate item added to repair it, false otherwise.
+     */
+    public boolean needsCoolantInjected() {
+        return false;
+    }
+
+    /**
+     * Simulates having a coolant item added by a Reactor Coolant Injector.
+     */
+    public void injectCoolant() {
+        // do nothing by default.
+    }
 }