Readded vanilla electric furnace but it's DISABLED by default

common/mekanism/induction/common/MekanismInduction.java

@@ -15,6 +15,8 @@ import mekanism.induction.common.block.BlockEMContractor;
 import mekanism.induction.common.block.BlockMultimeter;
 import mekanism.induction.common.block.BlockTesla;
 import mekanism.induction.common.block.BlockWire;
+import mekanism.induction.common.furnace.BlockAdvancedFurnace;
+import mekanism.induction.common.furnace.TileEntityAdvancedFurnace;
 import mekanism.induction.common.item.ItemBlockContractor;
 import mekanism.induction.common.item.ItemBlockMultimeter;
 import mekanism.induction.common.item.ItemBlockWire;
@@ -63,7 +65,6 @@ public class MekanismInduction implements IModule
 	public static Version versionNumber = new Version(5, 6, 0);
 
 	/**
-	 * Directory Information
 	 */
 	public static final String DOMAIN = "mekanism";
 	public static final String PREFIX = DOMAIN + ":";
@@ -77,11 +78,11 @@ public class MekanismInduction implements IModule
 	/**
 	 * Settings
 	 */
-	public static float FURNACE_WATTAGE = 10;
+	public static float FURNACE_WATTAGE = 0.5f;
 	public static boolean SOUND_FXS = true;
 	public static boolean LO_FI_INSULATION = false;
 	public static boolean SHINY_SILVER = true;
-	public static boolean REPLACE_FURNACE = true;
+	public static boolean ENABLE_ADVANCED_FURNACE = false;
 
 	/** Block ID by Jyzarc */
 	private static final int BLOCK_ID_PREFIX = 3200;
@@ -126,12 +127,12 @@ public class MekanismInduction implements IModule
 		Mekanism.configuration.load();
 
 		// Config
-		FURNACE_WATTAGE = (float) Mekanism.configuration.get(Configuration.CATEGORY_GENERAL, "Furnace Wattage", FURNACE_WATTAGE).getDouble(FURNACE_WATTAGE) / 20;
+		FURNACE_WATTAGE = (float) Mekanism.configuration.get(Configuration.CATEGORY_GENERAL, "Furnace Wattage", FURNACE_WATTAGE).getDouble(FURNACE_WATTAGE);
 		SOUND_FXS = Mekanism.configuration.get(Configuration.CATEGORY_GENERAL, "Tesla Sound FXs", SOUND_FXS).getBoolean(SOUND_FXS);
 		LO_FI_INSULATION = Mekanism.configuration.get(Configuration.CATEGORY_GENERAL, "Use lo-fi insulation texture", LO_FI_INSULATION).getBoolean(LO_FI_INSULATION);
 		SHINY_SILVER = Mekanism.configuration.get(Configuration.CATEGORY_GENERAL, "Shiny silver wires", SHINY_SILVER).getBoolean(SHINY_SILVER);
 		MAX_CONTRACTOR_DISTANCE = Mekanism.configuration.get(Configuration.CATEGORY_GENERAL, "Max EM Contractor Path", MAX_CONTRACTOR_DISTANCE).getInt(MAX_CONTRACTOR_DISTANCE);
-		REPLACE_FURNACE = Mekanism.configuration.get(Configuration.CATEGORY_GENERAL, "Replace vanilla furnace", REPLACE_FURNACE).getBoolean(REPLACE_FURNACE);
+		ENABLE_ADVANCED_FURNACE = Mekanism.configuration.get(Configuration.CATEGORY_GENERAL, "Enable Vanilla Electric Furnace", ENABLE_ADVANCED_FURNACE).getBoolean(ENABLE_ADVANCED_FURNACE);
 
 		TileEntityEMContractor.ACCELERATION = Mekanism.configuration.get(Configuration.CATEGORY_GENERAL, "Contractor Item Acceleration", TileEntityEMContractor.ACCELERATION).getDouble(TileEntityEMContractor.ACCELERATION);
 		TileEntityEMContractor.MAX_REACH = Mekanism.configuration.get(Configuration.CATEGORY_GENERAL, "Contractor Max Item Reach", TileEntityEMContractor.MAX_REACH).getInt(TileEntityEMContractor.MAX_REACH);
@@ -164,7 +165,7 @@ public class MekanismInduction implements IModule
 			blockWire = new BlockWire(getNextBlockID());
 		}
 
-		if (REPLACE_FURNACE)
+		if (ENABLE_ADVANCED_FURNACE)
 		{
 			blockAdvancedFurnaceIdle = BlockAdvancedFurnace.createNew(false);
 			blockAdvancedFurnaceBurning = BlockAdvancedFurnace.createNew(true);
@@ -288,7 +289,7 @@ public class MekanismInduction implements IModule
 			GameRegistry.addRecipe(new ShapelessOreRecipe(EnumWireMaterial.COPPER.getWire(), "universalCable"));
 		}
 
-		if (REPLACE_FURNACE)
+		if (ENABLE_ADVANCED_FURNACE)
 		{
 			/** Inject new furnace tile class */
 			replaceTileEntity(TileEntityFurnace.class, TileEntityAdvancedFurnace.class);

common/mekanism/induction/common/furnace/BlockAdvancedFurnace.java

@@ -0,0 +1,59 @@
+package mekanism.induction.common.furnace;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockFurnace;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.item.Item;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.World;
+
+/**
+ * @author Calclavia
+ * 
+ */
+public class BlockAdvancedFurnace extends BlockFurnace
+{
+	protected BlockAdvancedFurnace(int id, boolean isBurning)
+	{
+		super(id, isBurning);
+		this.setHardness(3.5F);
+		this.setStepSound(soundStoneFootstep);
+		this.setUnlocalizedName("furnace");
+
+		if (isBurning)
+		{
+			this.setLightValue(0.875F);
+		}
+		else
+		{
+			this.setCreativeTab(CreativeTabs.tabDecorations);
+		}
+	}
+
+	public static BlockAdvancedFurnace createNew(boolean isBurning)
+	{
+		int id = Block.furnaceIdle.blockID;
+
+		if (isBurning)
+		{
+			id = Block.furnaceBurning.blockID;
+		}
+
+		Block.blocksList[id] = null;
+		Item.itemsList[id] = null;
+		return new BlockAdvancedFurnace(id, isBurning);
+	}
+
+	@Override
+	public void onNeighborBlockChange(World world, int x, int y, int z, int newID)
+	{
+		super.onNeighborBlockChange(world, x, y, z, newID);
+		((TileEntityAdvancedFurnace)world.getBlockTileEntity(x, y, z)).checkProduce();
+	}
+
+	@Override
+	public TileEntity createNewTileEntity(World par1World)
+	{
+		return new TileEntityAdvancedFurnace();
+	}
+}

common/mekanism/induction/common/furnace/TileEntityAdvancedFurnace.java

@@ -0,0 +1,246 @@
+package mekanism.induction.common.furnace;
+
+import mekanism.induction.common.MekanismInduction;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.crafting.FurnaceRecipes;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.tileentity.TileEntityFurnace;
+import net.minecraftforge.common.ForgeDirection;
+import universalelectricity.core.block.IConductor;
+import universalelectricity.core.block.IElectrical;
+import universalelectricity.core.electricity.ElectricityHelper;
+import universalelectricity.core.electricity.ElectricityPack;
+import universalelectricity.core.grid.IElectricityNetwork;
+import universalelectricity.core.vector.Vector3;
+import universalelectricity.core.vector.VectorHelper;
+
+/**
+ * Meant to replace the furnace class.
+ * 
+ * @author Calclavia
+ * 
+ */
+public class TileEntityAdvancedFurnace extends TileEntityFurnace implements IElectrical
+{
+	private static final float WATTAGE = 5;
+	private boolean doProduce = false;
+	private boolean init = true;
+	private float energyBuffer = 0;
+
+	@Override
+	public void updateEntity()
+	{
+		if (this.init)
+		{
+			this.checkProduce();
+			this.init = false;
+		}
+
+		if (this.energyBuffer >= MekanismInduction.FURNACE_WATTAGE / 20)
+		{
+			this.furnaceCookTime++;
+
+			if (this.furnaceCookTime == 200)
+			{
+				this.furnaceCookTime = 0;
+				this.smeltItem();
+				this.onInventoryChanged();
+			}
+
+			this.energyBuffer = 0;
+		}
+		else
+		{
+			super.updateEntity();
+
+			if (this.doProduce)
+			{
+				if (this.getStackInSlot(0) == null)
+				{
+					boolean hasRequest = false;
+
+					for (ForgeDirection direction : ForgeDirection.VALID_DIRECTIONS)
+					{
+						TileEntity tileEntity = new Vector3(this).modifyPositionFromSide(direction).getTileEntity(this.worldObj);
+
+						if (tileEntity instanceof IConductor)
+						{
+							if (((IConductor) tileEntity).getNetwork().getRequest(this).getWatts() > 0)
+							{
+								if (this.furnaceBurnTime > 0)
+								{
+									this.produceUE(direction);
+								}
+
+								hasRequest = true;
+								break;
+							}
+						}
+					}
+
+					if (hasRequest)
+					{
+						/**
+						 * Steal power from furnace.
+						 */
+						boolean doBlockStateUpdate = this.furnaceBurnTime > 0;
+
+						if (this.furnaceBurnTime == 0)
+						{
+							int burnTime = TileEntityFurnace.getItemBurnTime(this.getStackInSlot(1));
+							this.decrStackSize(1, 1);
+							this.furnaceBurnTime = burnTime;
+						}
+
+						if (doBlockStateUpdate != this.furnaceBurnTime > 0)
+						{
+							// BlockFurnace.updateFurnaceBlockState(this.furnaceBurnTime > 0,
+							// this.worldObj, this.xCoord, this.yCoord, this.zCoord);
+							this.refreshConductors();
+						}
+					}
+				}
+			}
+		}
+	}
+
+	/**
+	 * Checks if the furnace should produce power.
+	 */
+	public void checkProduce()
+	{
+		for (ForgeDirection direction : ForgeDirection.VALID_DIRECTIONS)
+		{
+			TileEntity tileEntity = new Vector3(this).modifyPositionFromSide(direction).getTileEntity(this.worldObj);
+
+			if (tileEntity instanceof IConductor)
+			{
+				this.doProduce = true;
+				return;
+			}
+		}
+
+		this.doProduce = false;
+	}
+
+	public void refreshConductors()
+	{
+		for (ForgeDirection direction : ForgeDirection.VALID_DIRECTIONS)
+		{
+			TileEntity tileEntity = new Vector3(this).modifyPositionFromSide(direction).getTileEntity(this.worldObj);
+
+			if (tileEntity instanceof IConductor)
+			{
+				((IConductor) tileEntity).refresh();
+			}
+		}
+	}
+
+	/**
+	 * Produces UE power towards a specific direction.
+	 * 
+	 * @param outputDirection - The output direction.
+	 */
+	public boolean produceUE(ForgeDirection outputDirection)
+	{
+		if (!this.worldObj.isRemote && outputDirection != null && outputDirection != ForgeDirection.UNKNOWN)
+		{
+			float provide = this.getProvide(outputDirection);
+
+			if (provide > 0)
+			{
+				TileEntity outputTile = VectorHelper.getConnectorFromSide(this.worldObj, new Vector3(this), outputDirection);
+				IElectricityNetwork outputNetwork = ElectricityHelper.getNetworkFromTileEntity(outputTile, outputDirection);
+
+				if (outputNetwork != null)
+				{
+					ElectricityPack powerRequest = outputNetwork.getRequest(this);
+
+					if (powerRequest.getWatts() > 0)
+					{
+						ElectricityPack sendPack = ElectricityPack.getFromWatts(provide, this.getVoltage());
+						float rejectedPower = outputNetwork.produce(sendPack, this);
+						this.provideElectricity(outputDirection.getOpposite(), ElectricityPack.getFromWatts(sendPack.getWatts() - rejectedPower, this.getVoltage()), true);
+					}
+
+					return true;
+				}
+			}
+		}
+
+		return false;
+	}
+
+	@Override
+	public boolean canConnect(ForgeDirection direction)
+	{
+		return true;
+	}
+
+	private boolean canSmelt()
+	{
+		if (this.getStackInSlot(0) == null)
+		{
+			return false;
+		}
+		else
+		{
+			ItemStack itemstack = FurnaceRecipes.smelting().getSmeltingResult(this.getStackInSlot(0));
+			if (itemstack == null)
+				return false;
+			if (this.getStackInSlot(2) == null)
+				return true;
+			if (!this.getStackInSlot(2).isItemEqual(itemstack))
+				return false;
+			int result = getStackInSlot(2).stackSize + itemstack.stackSize;
+			return (result <= getInventoryStackLimit() && result <= itemstack.getMaxStackSize());
+		}
+	}
+
+	@Override
+	public float receiveElectricity(ForgeDirection from, ElectricityPack receive, boolean doReceive)
+	{
+		if (doReceive)
+		{
+			this.energyBuffer += receive.getWatts();
+			return 0;
+		}
+
+		return receive.getWatts();
+	}
+
+	@Override
+	public ElectricityPack provideElectricity(ForgeDirection from, ElectricityPack request, boolean doProvide)
+	{
+		return ElectricityPack.getFromWatts(MekanismInduction.FURNACE_WATTAGE / 20, this.getVoltage());
+	}
+
+	@Override
+	public float getRequest(ForgeDirection direction)
+	{
+		if (this.canSmelt() && this.getStackInSlot(1) == null && this.furnaceBurnTime == 0)
+		{
+			return MekanismInduction.FURNACE_WATTAGE / 20;
+		}
+
+		return 0;
+	}
+
+	@Override
+	public float getProvide(ForgeDirection direction)
+	{
+		if (this.furnaceBurnTime > 0)
+		{
+			return MekanismInduction.FURNACE_WATTAGE / 20;
+		}
+
+		return 0;
+	}
+
+	@Override
+	public float getVoltage()
+	{
+		return 0.12f;
+	}
+
+}