diff --git a/src/main/java/mekanism/client/ClientProxy.java b/src/main/java/mekanism/client/ClientProxy.java index 7404a1112..7c2869019 100644 --- a/src/main/java/mekanism/client/ClientProxy.java +++ b/src/main/java/mekanism/client/ClientProxy.java @@ -57,6 +57,7 @@ import mekanism.client.gui.GuiSideConfiguration; import mekanism.client.gui.GuiSolarNeutronActivator; import mekanism.client.gui.GuiTeleporter; import mekanism.client.gui.GuiThermalEvaporationController; +import mekanism.client.gui.GuiThermoelectricBoiler; import mekanism.client.gui.GuiTransporterConfig; import mekanism.client.gui.GuiUpgradeManagement; import mekanism.client.render.MekanismRenderer; @@ -523,6 +524,8 @@ public class ClientProxy extends CommonProxy return new GuiOredictionificator(player.inventory, (TileEntityOredictionificator)tileEntity); case 53: return new GuiResistiveHeater(player.inventory, (TileEntityResistiveHeater)tileEntity); + case 54: + return new GuiThermoelectricBoiler(player.inventory, (TileEntityBoilerCasing)tileEntity); } return null; diff --git a/src/main/java/mekanism/client/gui/GuiThermoelectricBoiler.java b/src/main/java/mekanism/client/gui/GuiThermoelectricBoiler.java index b48c2421d..a514bc9d4 100644 --- a/src/main/java/mekanism/client/gui/GuiThermoelectricBoiler.java +++ b/src/main/java/mekanism/client/gui/GuiThermoelectricBoiler.java @@ -1,9 +1,171 @@ package mekanism.client.gui; +import java.util.List; + +import mekanism.api.MekanismConfig.general; +import mekanism.api.util.ListUtils; +import mekanism.api.util.UnitDisplayUtils; +import mekanism.api.util.UnitDisplayUtils.TemperatureUnit; +import mekanism.client.gui.element.GuiBoilerTab; +import mekanism.client.gui.element.GuiElement.IInfoHandler; +import mekanism.client.gui.element.GuiHeatInfo; +import mekanism.client.gui.element.GuiRateBar; +import mekanism.client.gui.element.GuiRateBar.IRateInfoHandler; +import mekanism.client.render.MekanismRenderer; +import mekanism.common.inventory.container.ContainerFilter; +import mekanism.common.tile.TileEntityBoilerCasing; +import mekanism.common.util.LangUtils; +import mekanism.common.util.MekanismUtils; +import mekanism.common.util.MekanismUtils.ResourceType; +import mekanism.generators.client.gui.element.GuiTurbineTab.BoilerTab; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraftforge.fluids.FluidStack; + +import org.lwjgl.opengl.GL11; + import cpw.mods.fml.relauncher.Side; import cpw.mods.fml.relauncher.SideOnly; @SideOnly(Side.CLIENT) -public class GuiThermoelectricBoiler { +public class GuiThermoelectricBoiler extends GuiMekanism +{ + public TileEntityBoilerCasing tileEntity; + public GuiThermoelectricBoiler(InventoryPlayer inventory, TileEntityBoilerCasing tentity) + { + super(tentity, new ContainerFilter(inventory, tentity)); + tileEntity = tentity; + guiElements.add(new GuiBoilerTab(this, tileEntity, BoilerTab.STAT, 6, MekanismUtils.getResource(ResourceType.GUI, "GuiThermoelectricBoiler.png"))); + guiElements.add(new GuiRateBar(this, new IRateInfoHandler() + { + @Override + public String getTooltip() + { + return LangUtils.localize("gui.boilRate") + ": " + tileEntity.structure.lastBoilRate + " mB/t"; + } + + @Override + public double getLevel() + { + double max = (int)Math.floor(tileEntity.structure.getHeatAvailable() / tileEntity.structure.enthalpyOfVaporization); + + return (double)tileEntity.structure.lastBoilRate/max; + } + }, MekanismUtils.getResource(ResourceType.GUI, "GuiThermoelectricBoiler.png"), 24, 13)); + guiElements.add(new GuiRateBar(this, new IRateInfoHandler() + { + @Override + public String getTooltip() + { + double max = (int)Math.floor(tileEntity.structure.getHeatAvailable() / tileEntity.structure.enthalpyOfVaporization); + double cap = tileEntity.structure.superheatingElements*general.superheatingHeatTransfer; + return LangUtils.localize("gui.maxBoil") + ": " + tileEntity.structure.lastBoilRate + " mB/t"; + } + + @Override + public double getLevel() + { + double max = (int)Math.floor(tileEntity.structure.getHeatAvailable() / tileEntity.structure.enthalpyOfVaporization); + + return (double)tileEntity.structure.lastBoilRate/max; + } + }, MekanismUtils.getResource(ResourceType.GUI, "GuiThermoelectricBoiler.png"), 142, 13)); + guiElements.add(new GuiHeatInfo(new IInfoHandler() { + @Override + public List getInfo() + { + String loss = UnitDisplayUtils.getDisplayShort(tileEntity.structure.lastEnvironmentLoss, TemperatureUnit.KELVIN); + return ListUtils.asList(LangUtils.localize("gui.dissipated") + ": " + loss + "/t"); + } + }, this, MekanismUtils.getResource(ResourceType.GUI, "GuiThermoelectricBoiler.png"))); + } + + @Override + protected void drawGuiContainerForegroundLayer(int mouseX, int mouseY) + { + int xAxis = (mouseX - (width - xSize) / 2); + int yAxis = (mouseY - (height - ySize) / 2); + + fontRendererObj.drawString(tileEntity.getInventoryName(), (xSize/2)-(fontRendererObj.getStringWidth(tileEntity.getInventoryName())/2), 5, 0x404040); + + double max = (int)Math.floor(tileEntity.structure.getHeatAvailable() / tileEntity.structure.enthalpyOfVaporization); + + renderScaledText(LangUtils.localize("gui.temp") + ": " + MekanismUtils.getTemperatureDisplay(tileEntity.structure.temperature, TemperatureUnit.AMBIENT), 43, 30, 0x00CD00, 90); + renderScaledText(LangUtils.localize("gui.boilRate") + ": " + tileEntity.structure.lastBoilRate + " mB/t", 43, 39, 0x00CD00, 90); + renderScaledText(LangUtils.localize("gui.maxBoil") + ": " + max + " mB/t", 43, 48, 0x00CD00, 90); + + if(xAxis >= 7 && xAxis <= 23 && yAxis >= 14 && yAxis <= 72) + { + drawCreativeTabHoveringText(tileEntity.structure.waterStored != null ? LangUtils.localizeFluidStack(tileEntity.structure.waterStored) + ": " + tileEntity.structure.waterStored.amount + "mB" : LangUtils.localize("gui.empty"), xAxis, yAxis); + } + + if(xAxis >= 153 && xAxis <= 169 && yAxis >= 14 && yAxis <= 72) + { + drawCreativeTabHoveringText(tileEntity.structure.steamStored != null ? LangUtils.localizeFluidStack(tileEntity.structure.steamStored) + ": " + tileEntity.structure.steamStored.amount + "mB" : LangUtils.localize("gui.empty"), xAxis, yAxis); + } + + super.drawGuiContainerForegroundLayer(mouseX, mouseY); + } + + @Override + protected void drawGuiContainerBackgroundLayer(float partialTick, int mouseX, int mouseY) + { + mc.renderEngine.bindTexture(MekanismUtils.getResource(ResourceType.GUI, "GuiThermoelectricBoiler.png")); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + int guiWidth = (width - xSize) / 2; + int guiHeight = (height - ySize) / 2; + drawTexturedModalRect(guiWidth, guiHeight, 0, 0, xSize, ySize); + + if(tileEntity.getScaledWaterLevel(58) > 0) + { + displayGauge(7, 14, tileEntity.getScaledWaterLevel(58), tileEntity.structure.waterStored); + } + + if(tileEntity.getScaledSteamLevel(58) > 0) + { + displayGauge(153, 14, tileEntity.getScaledSteamLevel(58), tileEntity.structure.steamStored); + } + + super.drawGuiContainerBackgroundLayer(partialTick, mouseX, mouseY); + } + + public void displayGauge(int xPos, int yPos, int scale, FluidStack fluid) + { + if(fluid == null) + { + return; + } + + int guiWidth = (width - xSize) / 2; + int guiHeight = (height - ySize) / 2; + + int start = 0; + + while(true) + { + int renderRemaining = 0; + + if(scale > 16) + { + renderRemaining = 16; + scale -= 16; + } + else { + renderRemaining = scale; + scale = 0; + } + + mc.renderEngine.bindTexture(MekanismRenderer.getBlocksTexture()); + drawTexturedModelRectFromIcon(guiWidth + xPos, guiHeight + yPos + 58 - renderRemaining - start, fluid.getFluid().getIcon(), 16, 16 - (16 - renderRemaining)); + start+=16; + + if(renderRemaining == 0 || scale == 0) + { + break; + } + } + + mc.renderEngine.bindTexture(MekanismUtils.getResource(ResourceType.GUI, "GuiIndustrialTurbine.png")); + drawTexturedModalRect(guiWidth + xPos, guiHeight + yPos, 176, 0, 16, 54); + } } diff --git a/src/main/java/mekanism/client/gui/element/GuiBoilerTab.java b/src/main/java/mekanism/client/gui/element/GuiBoilerTab.java new file mode 100644 index 000000000..1105a70e7 --- /dev/null +++ b/src/main/java/mekanism/client/gui/element/GuiBoilerTab.java @@ -0,0 +1,118 @@ +package mekanism.client.gui.element; + +import mekanism.api.Coord4D; +import mekanism.client.gui.IGuiWrapper; +import mekanism.client.sound.SoundHandler; +import mekanism.common.Mekanism; +import mekanism.common.network.PacketSimpleGui.SimpleGuiMessage; +import mekanism.common.util.LangUtils; +import mekanism.common.util.MekanismUtils; +import mekanism.common.util.MekanismUtils.ResourceType; +import mekanism.generators.client.gui.element.GuiTurbineTab.BoilerTab; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.ResourceLocation; +import codechicken.lib.vec.Rectangle4i; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; + +@SideOnly(Side.CLIENT) +public class GuiBoilerTab extends GuiElement +{ + private TileEntity tileEntity; + private BoilerTab tabType; + private int yPos; + + public GuiBoilerTab(IGuiWrapper gui, TileEntity tile, BoilerTab type, int y, ResourceLocation def) + { + super(type.getResource(), gui, def); + + tileEntity = tile; + tabType = type; + yPos = y; + } + + @Override + public Rectangle4i getBounds(int guiWidth, int guiHeight) + { + return new Rectangle4i(guiWidth - 26, guiHeight + yPos, 26, 26); + } + + @Override + public void renderBackground(int xAxis, int yAxis, int guiWidth, int guiHeight) + { + mc.renderEngine.bindTexture(RESOURCE); + + guiObj.drawTexturedRect(guiWidth - 26, guiHeight + yPos, 0, 0, 26, 26); + + if(xAxis >= -21 && xAxis <= -3 && yAxis >= yPos+4 && yAxis <= yPos+22) + { + guiObj.drawTexturedRect(guiWidth - 21, guiHeight + yPos+4, 26, 0, 18, 18); + } + else { + guiObj.drawTexturedRect(guiWidth - 21, guiHeight + yPos+4, 26, 18, 18, 18); + } + + mc.renderEngine.bindTexture(defaultLocation); + } + + @Override + public void renderForeground(int xAxis, int yAxis) + { + mc.renderEngine.bindTexture(RESOURCE); + + if(xAxis >= -21 && xAxis <= -3 && yAxis >= yPos+4 && yAxis <= yPos+22) + { + displayTooltip(tabType.getDesc(), xAxis, yAxis); + } + + mc.renderEngine.bindTexture(defaultLocation); + } + + @Override + public void preMouseClicked(int xAxis, int yAxis, int button) {} + + @Override + public void mouseClicked(int xAxis, int yAxis, int button) + { + if(button == 0) + { + if(xAxis >= -21 && xAxis <= -3 && yAxis >= yPos+4 && yAxis <= yPos+22) + { + tabType.openGui(tileEntity); + SoundHandler.playSound("gui.button.press"); + } + } + } + + public static enum TurbineTab + { + MAIN("GuiGasesTab.png", 54, "gui.main"), + STAT("GuiStatsTab.png", 55, "gui.stats"); + + private String path; + private int guiId; + private String desc; + + private TurbineTab(String s, int id, String s1) + { + path = s; + guiId = id; + desc = s1; + } + + public ResourceLocation getResource() + { + return MekanismUtils.getResource(ResourceType.GUI_ELEMENT, path); + } + + public void openGui(TileEntity tile) + { + Mekanism.packetHandler.sendToServer(new SimpleGuiMessage(Coord4D.get(tile), 1, guiId)); + } + + public String getDesc() + { + return LangUtils.localize(desc); + } + } +} \ No newline at end of file diff --git a/src/main/java/mekanism/client/render/MekanismRenderer.java b/src/main/java/mekanism/client/render/MekanismRenderer.java index 96ec19050..4cf2f83c6 100644 --- a/src/main/java/mekanism/client/render/MekanismRenderer.java +++ b/src/main/java/mekanism/client/render/MekanismRenderer.java @@ -111,7 +111,6 @@ public class MekanismRenderer GasRegistry.getGas("deuterium").setIcon(event.map.registerIcon("mekanism:LiquidDeuterium")); GasRegistry.getGas("tritium").setIcon(event.map.registerIcon("mekanism:LiquidTritium")); GasRegistry.getGas("fusionFuelDT").setIcon(event.map.registerIcon("mekanism:LiquidDT")); - GasRegistry.getGas("steam").setIcon(event.map.registerIcon("mekanism:LiquidSteam")); GasRegistry.getGas("lithium").setIcon(event.map.registerIcon("mekanism:LiquidLithium")); for(Gas gas : GasRegistry.getRegisteredGasses()) diff --git a/src/main/java/mekanism/client/render/tileentity/RenderThermoelectricBoiler.java b/src/main/java/mekanism/client/render/tileentity/RenderThermoelectricBoiler.java index 2068093d0..7b7f02170 100644 --- a/src/main/java/mekanism/client/render/tileentity/RenderThermoelectricBoiler.java +++ b/src/main/java/mekanism/client/render/tileentity/RenderThermoelectricBoiler.java @@ -3,12 +3,24 @@ package mekanism.client.render.tileentity; import java.util.HashMap; import java.util.Map; +import mekanism.client.render.MekanismRenderer; import mekanism.client.render.MekanismRenderer.DisplayInteger; +import mekanism.client.render.MekanismRenderer.Model3D; import mekanism.client.render.tileentity.RenderDynamicTank.RenderData; import mekanism.client.render.tileentity.RenderDynamicTank.ValveRenderData; +import mekanism.common.content.tank.SynchronizedTankData.ValveData; +import mekanism.common.content.tank.TankUpdateProtocol; import mekanism.common.tile.TileEntityBoilerCasing; +import net.minecraft.client.renderer.tileentity.TileEntityRendererDispatcher; import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer; +import net.minecraft.init.Blocks; import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidRegistry; + +import org.lwjgl.opengl.GL11; + import cpw.mods.fml.relauncher.Side; import cpw.mods.fml.relauncher.SideOnly; @@ -19,6 +31,9 @@ public class RenderThermoelectricBoiler extends TileEntitySpecialRenderer private static Map cachedUpperFluids = new HashMap(); private static Map cachedValveFluids = new HashMap(); + private Fluid STEAM = FluidRegistry.getFluid("steam"); + private Fluid WATER = FluidRegistry.WATER; + @Override public void renderTileEntityAt(TileEntity tileEntity, double x, double y, double z, float partialTick) { @@ -31,16 +46,271 @@ public class RenderThermoelectricBoiler extends TileEntitySpecialRenderer { if(tileEntity.structure.waterStored != null && tileEntity.structure.waterStored.amount != 0) { + RenderData data = new RenderData(); + + data.location = tileEntity.structure.renderLocation; + data.height = tileEntity.structure.volHeight; + data.length = tileEntity.structure.volLength; + data.width = tileEntity.structure.volWidth; + + bindTexture(MekanismRenderer.getBlocksTexture()); + if(data.location != null && tileEntity.structure.waterStored.getFluid() != null) + { + push(); + + GL11.glTranslated(getX(data.location.xCoord), getY(data.location.yCoord), getZ(data.location.zCoord)); + + MekanismRenderer.glowOn(tileEntity.structure.waterStored.getFluid().getLuminosity()); + MekanismRenderer.colorFluid(tileEntity.structure.waterStored.getFluid()); + + DisplayInteger[] displayList = getListAndRender(data, tileEntity.structure.waterStored.getFluid(), tileEntity.getWorldObj(), cachedLowerFluids); + + if(tileEntity.structure.waterStored.getFluid().isGaseous()) + { + GL11.glColor4f(1F, 1F, 1F, Math.min(1, ((float)tileEntity.structure.waterStored.amount / (float)tileEntity.clientWaterCapacity)+0.3F)); + displayList[getStages(data.height)-1].render(); + } + else { + displayList[Math.min(getStages(data.height)-1, (int)(tileEntity.prevWaterScale*((float)getStages(data.height)-1)))].render(); + } + + MekanismRenderer.glowOff(); + MekanismRenderer.resetColor(); + + pop(); + + for(ValveData valveData : tileEntity.valveViewing) + { + push(); + + GL11.glTranslated(getX(valveData.location.xCoord), getY(valveData.location.yCoord), getZ(valveData.location.zCoord)); + + MekanismRenderer.glowOn(tileEntity.structure.waterStored.getFluid().getLuminosity()); + + getValveDisplay(ValveRenderData.get(data, valveData), tileEntity.structure.waterStored.getFluid(), tileEntity.getWorldObj()).render(); + + MekanismRenderer.glowOff(); + MekanismRenderer.resetColor(); + + pop(); + } + } } if(tileEntity.structure.steamStored != null && tileEntity.structure.steamStored.amount != 0) { + RenderData data = new RenderData(); + + data.location = tileEntity.structure.upperRenderLocation; + data.height = tileEntity.structure.volHeight; + data.length = tileEntity.structure.volLength; + data.width = tileEntity.structure.volWidth; + + bindTexture(MekanismRenderer.getBlocksTexture()); + if(data.location != null && tileEntity.structure.steamStored.getFluid() != null) + { + push(); + + GL11.glTranslated(getX(data.location.xCoord), getY(data.location.yCoord), getZ(data.location.zCoord)); + + MekanismRenderer.glowOn(tileEntity.structure.steamStored.getFluid().getLuminosity()); + MekanismRenderer.colorFluid(tileEntity.structure.steamStored.getFluid()); + + DisplayInteger[] displayList = getListAndRender(data, tileEntity.structure.waterStored.getFluid(), tileEntity.getWorldObj(), cachedUpperFluids); + + GL11.glColor4f(1F, 1F, 1F, Math.min(1, ((float)tileEntity.structure.steamStored.amount / (float)tileEntity.clientSteamCapacity)+0.3F)); + displayList[getStages(data.height+1)-1].render(); + + MekanismRenderer.glowOff(); + MekanismRenderer.resetColor(); + + pop(); + } } } } + private void pop() + { + GL11.glPopAttrib(); + GL11.glPopMatrix(); + } + + private void push() + { + GL11.glPushMatrix(); + GL11.glPushAttrib(GL11.GL_ENABLE_BIT); + GL11.glEnable(GL11.GL_CULL_FACE); + GL11.glEnable(GL11.GL_BLEND); + GL11.glDisable(GL11.GL_LIGHTING); + GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA); + } + + private DisplayInteger[] getListAndRender(RenderData data, Fluid fluid, World world, Map map) + { + if(map.containsKey(data)) + { + return map.get(data); + } + + Model3D toReturn = new Model3D(); + toReturn.baseBlock = Blocks.water; + toReturn.setTexture(fluid.getIcon()); + + final int stages = getStages(data.height); + DisplayInteger[] displays = new DisplayInteger[stages]; + + map.put(data, displays); + + for(int i = 0; i < stages; i++) + { + displays[i] = DisplayInteger.createAndStart(); + + if(fluid.getIcon() != null) + { + toReturn.minX = 0 + .01; + toReturn.minY = 0 + .01; + toReturn.minZ = 0 + .01; + + toReturn.maxX = data.length - .01; + toReturn.maxY = ((float)i/(float)stages)*(data.height-2) - .01; + toReturn.maxZ = data.width - .01; + + MekanismRenderer.renderObject(toReturn); + } + + GL11.glEndList(); + } + + return displays; + } + + private DisplayInteger getValveDisplay(ValveRenderData data, Fluid fluid, World world) + { + if(cachedValveFluids.containsKey(data)) + { + return cachedValveFluids.get(data); + } + + Model3D toReturn = new Model3D(); + toReturn.baseBlock = Blocks.water; + toReturn.setTexture(fluid.getFlowingIcon()); + + DisplayInteger display = DisplayInteger.createAndStart(); + + cachedValveFluids.put(data, display); + + switch(data.side) + { + case DOWN: + { + toReturn.minX = .3; + toReturn.minY = 1 + .01; + toReturn.minZ = .3; + + toReturn.maxX = .7; + toReturn.maxY = 1.4 + .1; + toReturn.maxZ = .7; + break; + } + case UP: + { + toReturn.minX = .3; + toReturn.minY = -(data.height-2) - .01; + toReturn.minZ = .3; + + toReturn.maxX = .7; + toReturn.maxY = -.01; + toReturn.maxZ = .7; + break; + } + case NORTH: + { + toReturn.minX = .3; + toReturn.minY = -(getValveFluidHeight(data)) + .01; + toReturn.minZ = 1 + .02; + + toReturn.maxX = .7; + toReturn.maxY = .7; + toReturn.maxZ = 1.4; + break; + } + case SOUTH: + { + toReturn.minX = .3; + toReturn.minY = -(getValveFluidHeight(data)) + .01; + toReturn.minZ = -.4; + + toReturn.maxX = .7; + toReturn.maxY = .7; + toReturn.maxZ = -.02; + break; + } + case WEST: + { + toReturn.minX = 1 + .02; + toReturn.minY = -(getValveFluidHeight(data)) + .01; + toReturn.minZ = .3; + + toReturn.maxX = 1.4; + toReturn.maxY = .7; + toReturn.maxZ = .7; + break; + } + case EAST: + { + toReturn.minX = -.4; + toReturn.minY = -(getValveFluidHeight(data)) + .01; + toReturn.minZ = .3; + + toReturn.maxX = -.02; + toReturn.maxY = .7; + toReturn.maxZ = .7; + break; + } + default: + { + break; + } + } + + if(fluid.getFlowingIcon() != null) + { + MekanismRenderer.renderObject(toReturn); + } + + display.endList(); + + return display; + } + + private int getValveFluidHeight(ValveRenderData data) + { + return data.valveLocation.yCoord - data.location.yCoord; + } + + private int getStages(int height) + { + return (height-2)*(TankUpdateProtocol.FLUID_PER_TANK/10); + } + + private double getX(int x) + { + return x - TileEntityRendererDispatcher.staticPlayerX; + } + + private double getY(int y) + { + return y - TileEntityRendererDispatcher.staticPlayerY; + } + + private double getZ(int z) + { + return z - TileEntityRendererDispatcher.staticPlayerZ; + } + public static void resetDisplayInts() { cachedLowerFluids.clear(); diff --git a/src/main/java/mekanism/common/CommonProxy.java b/src/main/java/mekanism/common/CommonProxy.java index 8e9cccd0f..81966ca01 100644 --- a/src/main/java/mekanism/common/CommonProxy.java +++ b/src/main/java/mekanism/common/CommonProxy.java @@ -541,6 +541,8 @@ public class CommonProxy implements IGuiProvider return new ContainerOredictionificator(player.inventory, (TileEntityOredictionificator)tileEntity); case 53: return new ContainerResistiveHeater(player.inventory, (TileEntityResistiveHeater)tileEntity); + case 54: + return new ContainerFilter(player.inventory, (TileEntityContainerBlock)tileEntity); } return null; diff --git a/src/main/java/mekanism/common/Mekanism.java b/src/main/java/mekanism/common/Mekanism.java index 7050d6db1..2137b0af8 100644 --- a/src/main/java/mekanism/common/Mekanism.java +++ b/src/main/java/mekanism/common/Mekanism.java @@ -72,8 +72,6 @@ import mekanism.common.recipe.inputs.ItemStackInput; import mekanism.common.recipe.machines.SmeltingRecipe; import mekanism.common.recipe.outputs.ItemStackOutput; import mekanism.common.tile.TileEntityAdvancedBoundingBlock; -import mekanism.common.tile.TileEntityBoilerCasing; -import mekanism.common.tile.TileEntityBoilerValve; import mekanism.common.tile.TileEntityBoundingBlock; import mekanism.common.tile.TileEntityCardboardBox; import mekanism.common.tile.TileEntityElectricBlock; @@ -1204,7 +1202,6 @@ public class Mekanism GasRegistry.register(new Gas("deuterium")).registerFluid(); GasRegistry.register(new Gas("tritium")).registerFluid(); GasRegistry.register(new Gas("fusionFuelDT")).registerFluid(); - GasRegistry.register(new Gas("steam")).registerFluid(); GasRegistry.register(new Gas("lithium")).registerFluid(); FluidRegistry.registerFluid(new Fluid("heavyWater")); diff --git a/src/main/java/mekanism/common/content/boiler/BoilerTank.java b/src/main/java/mekanism/common/content/boiler/BoilerTank.java index d313536cc..284926bb7 100644 --- a/src/main/java/mekanism/common/content/boiler/BoilerTank.java +++ b/src/main/java/mekanism/common/content/boiler/BoilerTank.java @@ -1,7 +1,7 @@ package mekanism.common.content.boiler; import mekanism.api.Coord4D; -import mekanism.common.content.boiler.SynchronizedBoilerData.ValveData; +import mekanism.common.content.tank.SynchronizedTankData.ValveData; import mekanism.common.tile.TileEntityBoilerCasing; import mekanism.common.util.MekanismUtils; import net.minecraftforge.fluids.FluidStack; diff --git a/src/main/java/mekanism/common/content/boiler/BoilerUpdateProtocol.java b/src/main/java/mekanism/common/content/boiler/BoilerUpdateProtocol.java index 821444a4c..ea584b75b 100644 --- a/src/main/java/mekanism/common/content/boiler/BoilerUpdateProtocol.java +++ b/src/main/java/mekanism/common/content/boiler/BoilerUpdateProtocol.java @@ -8,7 +8,7 @@ import mekanism.api.Coord4D; import mekanism.api.util.StackUtils; import mekanism.common.Mekanism; import mekanism.common.block.BlockBasic.BasicType; -import mekanism.common.content.boiler.SynchronizedBoilerData.ValveData; +import mekanism.common.content.tank.SynchronizedTankData.ValveData; import mekanism.common.multiblock.MultiblockCache; import mekanism.common.multiblock.MultiblockManager; import mekanism.common.multiblock.UpdateProtocol; @@ -108,13 +108,16 @@ public class BoilerUpdateProtocol extends UpdateProtocol return false; } - structure.superheatingElements = new NodeCounter(new NodeChecker() { - @Override - public boolean isValid(Coord4D coord) - { - return coord.getTileEntity(pointer.getWorldObj()) instanceof TileEntitySuperheatingElement; - } - }).calculate(elements.iterator().next()); + if(elements.size() > 0) + { + structure.superheatingElements = new NodeCounter(new NodeChecker() { + @Override + public boolean isValid(Coord4D coord) + { + return coord.getTileEntity(pointer.getWorldObj()) instanceof TileEntitySuperheatingElement; + } + }).calculate(elements.iterator().next()); + } if(elements.size() > structure.superheatingElements) { @@ -154,9 +157,9 @@ public class BoilerUpdateProtocol extends UpdateProtocol @Override public boolean isValid(Coord4D coord) { - return coord.yCoord >= structure.renderLocation.yCoord && coord.yCoord < initDisperser.yCoord && - coord.xCoord >= structure.renderLocation.xCoord && coord.xCoord <= structure.renderLocation.xCoord+structure.volLength && - coord.zCoord >= structure.renderLocation.zCoord && coord.zCoord <= structure.renderLocation.zCoord+structure.volWidth && + return coord.yCoord >= structure.renderLocation.yCoord-1 && coord.yCoord < initDisperser.yCoord && + coord.xCoord >= structure.renderLocation.xCoord && coord.xCoord < structure.renderLocation.xCoord+structure.volLength && + coord.zCoord >= structure.renderLocation.zCoord && coord.zCoord < structure.renderLocation.zCoord+structure.volWidth && (coord.isAirBlock(pointer.getWorldObj()) || isViableNode(coord.xCoord, coord.yCoord, coord.zCoord)); } }).calculate(initAir); @@ -168,7 +171,7 @@ public class BoilerUpdateProtocol extends UpdateProtocol return false; } - int steamHeight = (structure.renderLocation.yCoord+structure.volHeight)-initDisperser.yCoord; + int steamHeight = (structure.renderLocation.yCoord+structure.volHeight-2)-initDisperser.yCoord; structure.steamVolume = structure.volWidth*structure.volLength*steamHeight; structure.upperRenderLocation = new Coord4D(structure.renderLocation.xCoord, structure.renderLocation.zCoord, initDisperser.yCoord+1); diff --git a/src/main/java/mekanism/common/content/boiler/SynchronizedBoilerData.java b/src/main/java/mekanism/common/content/boiler/SynchronizedBoilerData.java index 771187726..a6ab23f2b 100644 --- a/src/main/java/mekanism/common/content/boiler/SynchronizedBoilerData.java +++ b/src/main/java/mekanism/common/content/boiler/SynchronizedBoilerData.java @@ -5,6 +5,8 @@ import java.util.Set; import mekanism.api.Coord4D; import mekanism.api.IHeatTransfer; +import mekanism.api.MekanismConfig.general; +import mekanism.common.content.tank.SynchronizedTankData.ValveData; import mekanism.common.multiblock.SynchronizedData; import mekanism.common.util.FluidContainerUtils.ContainerEditMode; import net.minecraft.item.ItemStack; @@ -21,6 +23,9 @@ public class SynchronizedBoilerData extends SynchronizedData valves = new HashSet(); + public double getHeatAvailable() + { + double heatAvailable = (temperature-100)*locations.size(); + return Math.min(heatAvailable, superheatingElements*general.superheatingHeatTransfer); + } + public boolean needsRenderUpdate() { if((waterStored == null && prevWater != null) || (waterStored != null && prevWater == null)) @@ -135,33 +146,4 @@ public class SynchronizedBoilerData extends SynchronizedData= 100 && structure.waterStored != null) { - double heatAvailable = (structure.temperature-100)*structure.locations.size(); - heatAvailable = Math.min(heatAvailable, structure.superheatingElements*general.superheatingHeatTransfer); + int steamAmount = structure.steamStored != null ? structure.steamStored.amount : 0; + double heatAvailable = structure.getHeatAvailable(); int amountToBoil = Math.min((int)Math.floor(heatAvailable / structure.enthalpyOfVaporization), structure.waterStored.amount); + amountToBoil = Math.min(amountToBoil, (structure.steamVolume*BoilerUpdateProtocol.STEAM_PER_TANK)-steamAmount); structure.waterStored.amount -= amountToBoil; if(structure.steamStored == null) @@ -137,6 +139,11 @@ public class TileEntityBoilerCasing extends TileEntityMultiblock