diff --git a/src/main/java/mekanism/common/tile/TileEntityInductionPort.java b/src/main/java/mekanism/common/tile/TileEntityInductionPort.java index 8e5cf4f58..4f3f52b16 100644 --- a/src/main/java/mekanism/common/tile/TileEntityInductionPort.java +++ b/src/main/java/mekanism/common/tile/TileEntityInductionPort.java @@ -15,7 +15,6 @@ import mekanism.api.EnumColor; import mekanism.api.IConfigurable; import mekanism.api.MekanismConfig.general; import mekanism.api.Range4D; -import mekanism.api.transmitters.IGridTransmitter; import mekanism.api.transmitters.ITransmitterTile; import mekanism.common.Mekanism; import mekanism.common.base.IActiveState; @@ -108,12 +107,6 @@ public class TileEntityInductionPort extends TileEntityInductionCasing implement return EnumSet.noneOf(ForgeDirection.class); } - @Override - public boolean canUpdate() - { - return true; - } - @Method(modid = "IC2") public void register() { diff --git a/src/main/java/mekanism/generators/client/GeneratorsClientProxy.java b/src/main/java/mekanism/generators/client/GeneratorsClientProxy.java index 2af6fd21c..c6ec4af8a 100644 --- a/src/main/java/mekanism/generators/client/GeneratorsClientProxy.java +++ b/src/main/java/mekanism/generators/client/GeneratorsClientProxy.java @@ -3,6 +3,7 @@ package mekanism.generators.client; import mekanism.generators.client.gui.GuiBioGenerator; import mekanism.generators.client.gui.GuiGasGenerator; import mekanism.generators.client.gui.GuiHeatGenerator; +import mekanism.generators.client.gui.GuiIndustrialTurbine; import mekanism.generators.client.gui.GuiNeutronCapture; import mekanism.generators.client.gui.GuiReactorController; import mekanism.generators.client.gui.GuiReactorFuel; @@ -102,6 +103,8 @@ public class GeneratorsClientProxy extends GeneratorsCommonProxy return new GuiBioGenerator(player.inventory, (TileEntityBioGenerator)tileEntity); case 5: return new GuiWindGenerator(player.inventory, (TileEntityWindGenerator)tileEntity); + case 6: + return new GuiIndustrialTurbine(player.inventory, (TileEntityTurbineCasing)tileEntity); case 10: return new GuiReactorController(player.inventory, (TileEntityReactorController)tileEntity); case 11: diff --git a/src/main/java/mekanism/generators/client/gui/GuiIndustrialTurbine.java b/src/main/java/mekanism/generators/client/gui/GuiIndustrialTurbine.java new file mode 100644 index 000000000..4915e7c84 --- /dev/null +++ b/src/main/java/mekanism/generators/client/gui/GuiIndustrialTurbine.java @@ -0,0 +1,20 @@ +package mekanism.generators.client.gui; + +import mekanism.client.gui.GuiMekanism; +import mekanism.common.inventory.container.ContainerFilter; +import mekanism.generators.common.tile.turbine.TileEntityTurbineCasing; +import net.minecraft.entity.player.InventoryPlayer; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; + +@SideOnly(Side.CLIENT) +public class GuiIndustrialTurbine extends GuiMekanism +{ + public TileEntityTurbineCasing tileEntity; + + public GuiIndustrialTurbine(InventoryPlayer inventory, TileEntityTurbineCasing tentity) + { + super(tentity, new ContainerFilter(inventory, tentity)); + tileEntity = tentity; + } +} diff --git a/src/main/java/mekanism/generators/client/render/RenderIndustrialTurbine.java b/src/main/java/mekanism/generators/client/render/RenderIndustrialTurbine.java index e8020ab47..d18e93929 100644 --- a/src/main/java/mekanism/generators/client/render/RenderIndustrialTurbine.java +++ b/src/main/java/mekanism/generators/client/render/RenderIndustrialTurbine.java @@ -33,7 +33,7 @@ public class RenderIndustrialTurbine extends TileEntitySpecialRenderer public void renderAModelAt(TileEntityTurbineCasing tileEntity, double x, double y, double z, float partialTick) { - if(tileEntity.clientHasStructure && tileEntity.isRendering && tileEntity.structure != null /* && there is fluid */) + if(tileEntity.clientHasStructure && tileEntity.isRendering && tileEntity.structure != null && tileEntity.structure.fluidStored != null && tileEntity.structure.fluidStored.amount != 0) { RenderData data = new RenderData(); @@ -43,6 +43,26 @@ public class RenderIndustrialTurbine extends TileEntitySpecialRenderer data.width = tileEntity.structure.volWidth; bindTexture(MekanismRenderer.getBlocksTexture()); + + if(data.location != null && data.height >= 3 && tileEntity.structure.fluidStored.getFluid() != null) + { + push(); + + GL11.glTranslated(getX(data.location.xCoord), getY(data.location.yCoord), getZ(data.location.zCoord)); + + MekanismRenderer.glowOn(tileEntity.structure.fluidStored.getFluid().getLuminosity()); + MekanismRenderer.colorFluid(tileEntity.structure.fluidStored.getFluid()); + + DisplayInteger[] displayList = getListAndRender(data, tileEntity.getWorldObj()); + + GL11.glColor4f(1F, 1F, 1F, Math.min(1, ((float)tileEntity.structure.fluidStored.amount / (float)tileEntity.structure.getFluidCapacity())+0.3F)); + displayList[getStages(data.height)-1].render(); + + MekanismRenderer.glowOff(); + MekanismRenderer.resetColor(); + + pop(); + } } } diff --git a/src/main/java/mekanism/generators/common/GeneratorsCommonProxy.java b/src/main/java/mekanism/generators/common/GeneratorsCommonProxy.java index 977b4f358..2e0756e8e 100644 --- a/src/main/java/mekanism/generators/common/GeneratorsCommonProxy.java +++ b/src/main/java/mekanism/generators/common/GeneratorsCommonProxy.java @@ -2,6 +2,7 @@ package mekanism.generators.common; import mekanism.api.MekanismConfig.generators; import mekanism.common.Mekanism; +import mekanism.common.inventory.container.ContainerFilter; import mekanism.common.inventory.container.ContainerNull; import mekanism.common.tile.TileEntityContainerBlock; import mekanism.generators.common.inventory.container.ContainerBioGenerator; @@ -172,6 +173,8 @@ public class GeneratorsCommonProxy return new ContainerBioGenerator(player.inventory, (TileEntityBioGenerator)tileEntity); case 5: return new ContainerWindGenerator(player.inventory, (TileEntityWindGenerator)tileEntity); + case 6: + return new ContainerFilter(player.inventory, (TileEntityTurbineCasing)tileEntity); case 10: return new ContainerReactorController(player.inventory, (TileEntityReactorController)tileEntity); case 11: diff --git a/src/main/java/mekanism/generators/common/content/turbine/SynchronizedTurbineData.java b/src/main/java/mekanism/generators/common/content/turbine/SynchronizedTurbineData.java index 64075c799..e6f7a4ba3 100644 --- a/src/main/java/mekanism/generators/common/content/turbine/SynchronizedTurbineData.java +++ b/src/main/java/mekanism/generators/common/content/turbine/SynchronizedTurbineData.java @@ -9,6 +9,8 @@ public class SynchronizedTurbineData extends SynchronizedData { public FluidStack fluid; + public double electricity; @Override public void apply(SynchronizedTurbineData data) { data.fluidStored = fluid; + data.electricityStored = electricity; } @Override public void sync(SynchronizedTurbineData data) { fluid = data.fluidStored; + electricity = data.electricityStored; } @Override @@ -27,6 +30,8 @@ public class TurbineCache extends MultiblockCache { fluid = FluidStack.loadFluidStackFromNBT(nbtTags.getCompoundTag("cachedFluid")); } + + electricity = nbtTags.getDouble("electricity"); } @Override @@ -36,5 +41,7 @@ public class TurbineCache extends MultiblockCache { nbtTags.setTag("cachedFluid", fluid.writeToNBT(new NBTTagCompound())); } + + nbtTags.setDouble("electricity", electricity); } } diff --git a/src/main/java/mekanism/generators/common/content/turbine/TurbineUpdateProtocol.java b/src/main/java/mekanism/generators/common/content/turbine/TurbineUpdateProtocol.java index 51b9dd411..8d20ccd46 100644 --- a/src/main/java/mekanism/generators/common/content/turbine/TurbineUpdateProtocol.java +++ b/src/main/java/mekanism/generators/common/content/turbine/TurbineUpdateProtocol.java @@ -255,6 +255,8 @@ public class TurbineUpdateProtocol extends UpdateProtocol +public class TileEntityTurbineCasing extends TileEntityMultiblock implements IStrictEnergyStorage { - public int clientCapacity; - public float prevScale; public TileEntityTurbineCasing() @@ -46,7 +45,7 @@ public class TileEntityTurbineCasing extends TileEntityMultiblock 0.01) { @@ -84,7 +83,7 @@ public class TileEntityTurbineCasing extends TileEntityMultiblock getOutputtingSides() + { + if(structure != null) + { + EnumSet set = EnumSet.allOf(ForgeDirection.class); + set.remove(ForgeDirection.UNKNOWN); + + for(ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) + { + if(structure.locations.contains(Coord4D.get(this).getFromSide(side))) + { + set.remove(side); + } + } + + return set; + } + + return EnumSet.noneOf(ForgeDirection.class); + } + + @Override + public EnumSet getConsumingSides() + { + return EnumSet.noneOf(ForgeDirection.class); + } + + @Override + public boolean canUpdate() + { + return true; + } + + @Method(modid = "IC2") + public void register() + { + if(!worldObj.isRemote) + { + TileEntity registered = EnergyNet.instance.getTileEntity(worldObj, xCoord, yCoord, zCoord); + + if(registered != this) + { + if(registered instanceof IEnergyTile) + { + MinecraftForge.EVENT_BUS.post(new EnergyTileUnloadEvent((IEnergyTile)registered)); + } + else if(registered == null) + { + MinecraftForge.EVENT_BUS.post(new EnergyTileLoadEvent(this)); + ic2Registered = true; + } + } + } + } + + @Method(modid = "IC2") + public void deregister() + { + if(!worldObj.isRemote) + { + TileEntity registered = EnergyNet.instance.getTileEntity(worldObj, xCoord, yCoord, zCoord); + + if(registered instanceof IEnergyTile) + { + MinecraftForge.EVENT_BUS.post(new EnergyTileUnloadEvent((IEnergyTile)registered)); + } + } + } + + @Override + public double getMaxOutput() + { + return structure != null ? structure.getEnergyCapacity() : 0; + } + + @Override + public void onAdded() + { + super.onAdded(); + + if(MekanismUtils.useIC2()) + { + register(); + } + } + + @Override + public void onChunkUnload() + { + if(MekanismUtils.useIC2()) + { + deregister(); + } + + super.onChunkUnload(); + } + + @Override + public void invalidate() + { + super.invalidate(); + + if(MekanismUtils.useIC2()) + { + deregister(); + } + } + + @Override + @Method(modid = "CoFHCore") + public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate) + { + return 0; + } + + @Override + @Method(modid = "CoFHCore") + public int extractEnergy(ForgeDirection from, int maxExtract, boolean simulate) + { + if(getOutputtingSides().contains(from)) + { + double toSend = Math.min(getEnergy(), Math.min(getMaxOutput(), maxExtract*general.FROM_TE)); + + if(!simulate) + { + setEnergy(getEnergy() - toSend); + } + + return (int)Math.round(toSend*general.TO_TE); + } + + return 0; + } + + @Override + @Method(modid = "CoFHCore") + public boolean canConnectEnergy(ForgeDirection from) + { + return structure != null; + } + + @Override + @Method(modid = "CoFHCore") + public int getEnergyStored(ForgeDirection from) + { + return (int)Math.round(getEnergy()*general.TO_TE); + } + + @Override + @Method(modid = "CoFHCore") + public int getMaxEnergyStored(ForgeDirection from) + { + return (int)Math.round(getMaxEnergy()*general.TO_TE); + } + + @Override + @Method(modid = "IC2") + public int getSinkTier() + { + return 4; + } + + @Override + @Method(modid = "IC2") + public int getSourceTier() + { + return 4; + } + + @Override + @Method(modid = "IC2") + public void setStored(int energy) + { + setEnergy(energy*general.FROM_IC2); + } + + @Override + @Method(modid = "IC2") + public int addEnergy(int amount) + { + return (int)Math.round(getEnergy()*general.TO_IC2); + } + + @Override + @Method(modid = "IC2") + public boolean isTeleporterCompatible(ForgeDirection side) + { + return canOutputTo(side); + } + + @Override + public boolean canOutputTo(ForgeDirection side) + { + return getOutputtingSides().contains(side); + } + + @Override + @Method(modid = "IC2") + public boolean acceptsEnergyFrom(TileEntity emitter, ForgeDirection direction) + { + return false; + } + + @Override + @Method(modid = "IC2") + public boolean emitsEnergyTo(TileEntity receiver, ForgeDirection direction) + { + return getOutputtingSides().contains(direction) && receiver instanceof IEnergyConductor; + } + + @Override + @Method(modid = "IC2") + public int getStored() + { + return (int)Math.round(getEnergy()*general.TO_IC2); + } + + @Override + @Method(modid = "IC2") + public int getCapacity() + { + return (int)Math.round(getMaxEnergy()*general.TO_IC2); + } + + @Override + @Method(modid = "IC2") + public int getOutput() + { + return (int)Math.round(getMaxOutput()*general.TO_IC2); + } + + @Override + @Method(modid = "IC2") + public double getDemandedEnergy() + { + return 0; + } + + @Override + @Method(modid = "IC2") + public double getOfferedEnergy() + { + return Math.min(getEnergy(), getMaxOutput())*general.TO_IC2; + } + + @Override + public boolean canReceiveEnergy(ForgeDirection side) + { + return false; + } + + @Override + @Method(modid = "IC2") + public double getOutputEnergyUnitsPerTick() + { + return getMaxOutput()*general.TO_IC2; + } + + @Override + @Method(modid = "IC2") + public double injectEnergy(ForgeDirection direction, double amount, double voltage) + { + return amount; + } + + @Override + @Method(modid = "IC2") + public void drawEnergy(double amount) + { + if(structure != null) + { + double toDraw = Math.min(amount*general.FROM_IC2, getMaxOutput()); + setEnergy(Math.max(getEnergy() - toDraw, 0)); + } + } + + @Override + public double transferEnergyToAcceptor(ForgeDirection side, double amount) + { + return 0; + } @Override public FluidTankInfo[] getTankInfo(ForgeDirection from)