diff --git a/src/main/java/mekanism/common/block/BlockBasic.java b/src/main/java/mekanism/common/block/BlockBasic.java index dc07463c8..9ef140c17 100644 --- a/src/main/java/mekanism/common/block/BlockBasic.java +++ b/src/main/java/mekanism/common/block/BlockBasic.java @@ -31,7 +31,6 @@ import mekanism.common.tile.TileEntityInductionCasing; import mekanism.common.tile.TileEntityInductionCell; import mekanism.common.tile.TileEntityInductionPort; import mekanism.common.tile.TileEntityInductionProvider; -import mekanism.common.tile.TileEntityMultiblock; import mekanism.common.tile.TileEntitySolarEvaporationBlock; import mekanism.common.tile.TileEntitySolarEvaporationController; import mekanism.common.tile.TileEntitySolarEvaporationValve; @@ -130,9 +129,9 @@ public class BlockBasic extends Block implements IBlockCTM, ICustomBlockIcon { TileEntity tileEntity = world.getTileEntity(x, y, z); - if(block == this && tileEntity instanceof TileEntityMultiblock) + if(block == this && tileEntity instanceof IMultiblock) { - ((TileEntityMultiblock)tileEntity).update(); + ((IMultiblock)tileEntity).update(); } if(tileEntity instanceof TileEntityBasicBlock) @@ -886,9 +885,9 @@ public class BlockBasic extends Block implements IBlockCTM, ICustomBlockIcon { TileEntity tileEntity = world.getTileEntity(x, y, z); - if(tileEntity instanceof TileEntityMultiblock) + if(tileEntity instanceof IMultiblock) { - ((TileEntityMultiblock)tileEntity).update(); + ((IMultiblock)tileEntity).update(); } if(tileEntity instanceof IStructuralMultiblock) diff --git a/src/main/java/mekanism/common/content/tank/DynamicFluidTank.java b/src/main/java/mekanism/common/content/tank/DynamicFluidTank.java index 173739a37..994d2ed5f 100644 --- a/src/main/java/mekanism/common/content/tank/DynamicFluidTank.java +++ b/src/main/java/mekanism/common/content/tank/DynamicFluidTank.java @@ -154,7 +154,7 @@ public class DynamicFluidTank implements IFluidTank dynamicTank.structure.fluidStored.amount -= used; } - FluidStack drained = new FluidStack(dynamicTank.structure.fluidStored.getFluidID(), used); + FluidStack drained = new FluidStack(dynamicTank.structure.fluidStored.getFluid(), used); if(dynamicTank.structure.fluidStored.amount <= 0) { diff --git a/src/main/java/mekanism/common/tile/TileEntityDynamicTank.java b/src/main/java/mekanism/common/tile/TileEntityDynamicTank.java index 490e07163..0a07c889f 100644 --- a/src/main/java/mekanism/common/tile/TileEntityDynamicTank.java +++ b/src/main/java/mekanism/common/tile/TileEntityDynamicTank.java @@ -23,6 +23,7 @@ import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; import net.minecraftforge.common.util.ForgeDirection; import net.minecraftforge.fluids.FluidContainerRegistry; +import net.minecraftforge.fluids.FluidRegistry; import net.minecraftforge.fluids.FluidStack; import net.minecraftforge.fluids.IFluidContainerItem; @@ -384,7 +385,7 @@ public class TileEntityDynamicTank extends TileEntityMultiblock cachedFluids = new HashMap(); + + private Fluid STEAM = FluidRegistry.getFluid("steam"); + + @Override + public void renderTileEntityAt(TileEntity tileEntity, double x, double y, double z, float partialTick) + { + renderAModelAt((TileEntityTurbineCasing)tileEntity, x, y, z, partialTick); + } + + public void renderAModelAt(TileEntityTurbineCasing tileEntity, double x, double y, double z, float partialTick) + { + if(tileEntity.clientHasStructure && tileEntity.isRendering && tileEntity.structure != null /* && there is fluid */) + { + RenderData data = new RenderData(); + + data.location = tileEntity.structure.renderLocation; + data.height = tileEntity.structure.lowerVolume/(tileEntity.structure.volLength*tileEntity.structure.volWidth); + data.length = tileEntity.structure.volLength; + data.width = tileEntity.structure.volWidth; + + bindTexture(MekanismRenderer.getBlocksTexture()); + } + } + + 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 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; + } + + private DisplayInteger[] getListAndRender(RenderData data, World world) + { + if(cachedFluids.containsKey(data)) + { + return cachedFluids.get(data); + } + + Model3D toReturn = new Model3D(); + toReturn.baseBlock = Blocks.water; + toReturn.setTexture(STEAM.getIcon()); + + final int stages = getStages(data.height); + DisplayInteger[] displays = new DisplayInteger[stages]; + + cachedFluids.put(data, displays); + + for(int i = 0; i < stages; i++) + { + displays[i] = DisplayInteger.createAndStart(); + + if(STEAM.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; + } + + public static void resetDisplayInts() + { + cachedFluids.clear(); + } +} diff --git a/src/main/java/mekanism/generators/common/block/BlockGenerator.java b/src/main/java/mekanism/generators/common/block/BlockGenerator.java index 6d69b141c..6bdfbcd92 100644 --- a/src/main/java/mekanism/generators/common/block/BlockGenerator.java +++ b/src/main/java/mekanism/generators/common/block/BlockGenerator.java @@ -16,6 +16,7 @@ import mekanism.common.base.ISpecialBounds; import mekanism.common.base.ISustainedData; import mekanism.common.base.ISustainedInventory; import mekanism.common.base.ISustainedTank; +import mekanism.common.multiblock.IMultiblock; import mekanism.common.tile.TileEntityBasicBlock; import mekanism.common.tile.TileEntityContainerBlock; import mekanism.common.tile.TileEntityElectricBlock; @@ -169,6 +170,11 @@ public class BlockGenerator extends BlockContainer implements ISpecialBounds, IB if(!world.isRemote) { TileEntity tileEntity = world.getTileEntity(x, y, z); + + if(tileEntity instanceof IMultiblock) + { + ((IMultiblock)tileEntity).update(); + } if(tileEntity instanceof TileEntityBasicBlock) { @@ -216,6 +222,11 @@ public class BlockGenerator extends BlockContainer implements ISpecialBounds, IB { ((IBoundingBlock)tileEntity).onPlace(); } + + if(!world.isRemote && tileEntity instanceof IMultiblock) + { + ((IMultiblock)tileEntity).update(); + } } @Override @@ -450,6 +461,11 @@ public class BlockGenerator extends BlockContainer implements ISpecialBounds, IB } } + if(metadata == GeneratorType.TURBINE_CASING.meta || metadata == GeneratorType.TURBINE_VALVE.meta || metadata == GeneratorType.TURBINE_VENT.meta) + { + return ((IMultiblock)world.getTileEntity(x, y, z)).onActivate(entityplayer); + } + if(metadata == GeneratorType.TURBINE_ROTOR.meta) { TileEntityTurbineRotor rod = (TileEntityTurbineRotor)tileEntity; 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 b2d228906..64075c799 100644 --- a/src/main/java/mekanism/generators/common/content/turbine/SynchronizedTurbineData.java +++ b/src/main/java/mekanism/generators/common/content/turbine/SynchronizedTurbineData.java @@ -1,12 +1,40 @@ package mekanism.generators.common.content.turbine; import mekanism.common.multiblock.SynchronizedData; +import net.minecraftforge.fluids.FluidStack; public class SynchronizedTurbineData extends SynchronizedData { + public FluidStack fluidStored; + + public FluidStack prevFluid; + public int blades; public int vents; public int coils; public int lowerVolume; + + public int getFluidCapacity() + { + return lowerVolume*TurbineUpdateProtocol.FLUID_PER_TANK; + } + + public boolean needsRenderUpdate() + { + if((fluidStored == null && prevFluid != null) || (fluidStored != null && prevFluid == null)) + { + return true; + } + + if(fluidStored != null && prevFluid != null) + { + if((fluidStored.getFluid() != prevFluid.getFluid()) || (fluidStored.amount != prevFluid.amount)) + { + return true; + } + } + + return false; + } } diff --git a/src/main/java/mekanism/generators/common/content/turbine/TurbineCache.java b/src/main/java/mekanism/generators/common/content/turbine/TurbineCache.java index 424828601..8e25712c6 100644 --- a/src/main/java/mekanism/generators/common/content/turbine/TurbineCache.java +++ b/src/main/java/mekanism/generators/common/content/turbine/TurbineCache.java @@ -1,31 +1,40 @@ package mekanism.generators.common.content.turbine; -import net.minecraft.nbt.NBTTagCompound; import mekanism.common.multiblock.MultiblockCache; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.fluids.FluidStack; public class TurbineCache extends MultiblockCache { + public FluidStack fluid; + @Override public void apply(SynchronizedTurbineData data) { - + data.fluidStored = fluid; } @Override public void sync(SynchronizedTurbineData data) { - + fluid = data.fluidStored; } @Override public void load(NBTTagCompound nbtTags) { - + if(nbtTags.hasKey("cachedFluid")) + { + fluid = FluidStack.loadFluidStackFromNBT(nbtTags.getCompoundTag("cachedFluid")); + } } @Override public void save(NBTTagCompound nbtTags) { - + if(fluid != null) + { + nbtTags.setTag("cachedFluid", fluid.writeToNBT(new NBTTagCompound())); + } } } diff --git a/src/main/java/mekanism/generators/common/content/turbine/TurbineFluidTank.java b/src/main/java/mekanism/generators/common/content/turbine/TurbineFluidTank.java new file mode 100644 index 000000000..c66b5b5d7 --- /dev/null +++ b/src/main/java/mekanism/generators/common/content/turbine/TurbineFluidTank.java @@ -0,0 +1,177 @@ +package mekanism.generators.common.content.turbine; + +import mekanism.common.util.MekanismUtils; +import mekanism.generators.common.tile.turbine.TileEntityTurbineCasing; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.FluidTankInfo; +import net.minecraftforge.fluids.IFluidTank; + +public class TurbineFluidTank implements IFluidTank +{ + public TileEntityTurbineCasing turbine; + + public TurbineFluidTank(TileEntityTurbineCasing tileEntity) + { + turbine = tileEntity; + } + + @Override + public FluidStack getFluid() + { + return turbine.structure != null ? turbine.structure.fluidStored : null; + } + + @Override + public int getCapacity() + { + return turbine.structure != null ? turbine.structure.getFluidCapacity() : 0; + } + + @Override + public int fill(FluidStack resource, boolean doFill) + { + if(turbine.structure != null && !turbine.getWorldObj().isRemote) + { + if(resource == null || resource.getFluidID() <= 0) + { + return 0; + } + + if(turbine.structure.fluidStored != null && !turbine.structure.fluidStored.isFluidEqual(resource)) + { + return 0; + } + + if(turbine.structure.fluidStored == null || turbine.structure.fluidStored.getFluidID() <= 0) + { + if(resource.amount <= getCapacity()) + { + if(doFill) + { + turbine.structure.fluidStored = resource.copy(); + + if(resource.amount > 0) + { + MekanismUtils.saveChunk(turbine); + } + } + + return resource.amount; + } + else { + if(doFill) + { + turbine.structure.fluidStored = resource.copy(); + turbine.structure.fluidStored.amount = getCapacity(); + + if(getCapacity() > 0) + { + MekanismUtils.saveChunk(turbine); + } + } + + return getCapacity(); + } + } + else if(resource.amount <= getNeeded()) + { + if(doFill) + { + turbine.structure.fluidStored.amount += resource.amount; + + if(resource.amount > 0) + { + MekanismUtils.saveChunk(turbine); + } + } + + return resource.amount; + } + else { + int prevNeeded = getNeeded(); + + if(doFill) + { + turbine.structure.fluidStored.amount = getCapacity(); + + if(prevNeeded > 0) + { + MekanismUtils.saveChunk(turbine); + } + } + + return prevNeeded; + } + } + + return 0; + } + + @Override + public FluidStack drain(int maxDrain, boolean doDrain) + { + if(turbine.structure != null && !turbine.getWorldObj().isRemote) + { + if(turbine.structure.fluidStored == null || turbine.structure.fluidStored.getFluidID() <= 0) + { + return null; + } + + if(turbine.structure.fluidStored.amount <= 0) + { + return null; + } + + int used = maxDrain; + + if(turbine.structure.fluidStored.amount < used) + { + used = turbine.structure.fluidStored.amount; + } + + if(doDrain) + { + turbine.structure.fluidStored.amount -= used; + } + + FluidStack drained = new FluidStack(turbine.structure.fluidStored.getFluid(), used); + + if(turbine.structure.fluidStored.amount <= 0) + { + turbine.structure.fluidStored = null; + } + + if(drained.amount > 0 && doDrain) + { + MekanismUtils.saveChunk(turbine); + turbine.sendPacketToRenderer(); + } + + return drained; + } + + return null; + } + + public int getNeeded() + { + return getCapacity()-getFluidAmount(); + } + + @Override + public int getFluidAmount() + { + if(turbine.structure != null) + { + return turbine.structure.fluidStored.amount; + } + + return 0; + } + + @Override + public FluidTankInfo getInfo() + { + return new FluidTankInfo(this); + } +} 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 502bfd700..51b9dd411 100644 --- a/src/main/java/mekanism/generators/common/content/turbine/TurbineUpdateProtocol.java +++ b/src/main/java/mekanism/generators/common/content/turbine/TurbineUpdateProtocol.java @@ -5,6 +5,7 @@ import java.util.List; import java.util.Set; import mekanism.api.Coord4D; +import mekanism.common.content.tank.TankUpdateProtocol; import mekanism.common.multiblock.MultiblockCache; import mekanism.common.multiblock.MultiblockManager; import mekanism.common.multiblock.UpdateProtocol; @@ -23,6 +24,8 @@ import net.minecraftforge.common.util.ForgeDirection; public class TurbineUpdateProtocol extends UpdateProtocol { + public static final int FLUID_PER_TANK = TankUpdateProtocol.FLUID_PER_TANK; + public TurbineUpdateProtocol(TileEntityTurbineCasing tileEntity) { super(tileEntity); @@ -31,9 +34,8 @@ public class TurbineUpdateProtocol extends UpdateProtocol rejectedItems, MultiblockCache cache, MultiblockCache merge) { - + if(((TurbineCache)cache).fluid == null) + { + ((TurbineCache)cache).fluid = ((TurbineCache)merge).fluid; + } + else if(((TurbineCache)merge).fluid != null && ((TurbineCache)cache).fluid.isFluidEqual(((TurbineCache)merge).fluid)) + { + ((TurbineCache)cache).fluid.amount += ((TurbineCache)merge).fluid.amount; + } + } + + @Override + protected void onFormed() + { + if(structureFound.fluidStored != null) + { + structureFound.fluidStored.amount = Math.min(structureFound.fluidStored.amount, structureFound.getFluidCapacity()); + } } public class CoilCounter diff --git a/src/main/java/mekanism/generators/common/tile/turbine/TileEntityTurbineCasing.java b/src/main/java/mekanism/generators/common/tile/turbine/TileEntityTurbineCasing.java index 862606378..7e272e76a 100644 --- a/src/main/java/mekanism/generators/common/tile/turbine/TileEntityTurbineCasing.java +++ b/src/main/java/mekanism/generators/common/tile/turbine/TileEntityTurbineCasing.java @@ -1,16 +1,32 @@ package mekanism.generators.common.tile.turbine; +import io.netty.buffer.ByteBuf; + +import java.util.ArrayList; + +import mekanism.api.Coord4D; +import mekanism.api.Range4D; +import mekanism.common.Mekanism; +import mekanism.common.content.tank.TankUpdateProtocol; import mekanism.common.multiblock.MultiblockCache; import mekanism.common.multiblock.MultiblockManager; import mekanism.common.multiblock.UpdateProtocol; +import mekanism.common.network.PacketTileEntity.TileEntityMessage; import mekanism.common.tile.TileEntityMultiblock; import mekanism.generators.common.MekanismGenerators; import mekanism.generators.common.content.turbine.SynchronizedTurbineData; import mekanism.generators.common.content.turbine.TurbineCache; import mekanism.generators.common.content.turbine.TurbineUpdateProtocol; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; public class TileEntityTurbineCasing extends TileEntityMultiblock { + public int clientCapacity; + + public float prevScale; + public TileEntityTurbineCasing() { this("TurbineCasing"); @@ -20,6 +36,113 @@ public class TileEntityTurbineCasing extends TileEntityMultiblock 0.01) + { + prevScale = (9*prevScale + targetScale)/10; + } + } + } + + if(!worldObj.isRemote) + { + if(structure != null) + { + if(structure.fluidStored != null && structure.fluidStored.amount <= 0) + { + structure.fluidStored = null; + markDirty(); + } + + if(isRendering) + { + if(structure.needsRenderUpdate()) + { + sendPacketToRenderer(); + } + + structure.prevFluid = structure.fluidStored; + } + } + } + } + + @Override + public boolean onActivate(EntityPlayer player) + { + if(!player.isSneaking() && structure != null) + { + Mekanism.packetHandler.sendToReceivers(new TileEntityMessage(Coord4D.get(this), getNetworkedData(new ArrayList())), new Range4D(Coord4D.get(this))); + //player.openGui(Mekanism.instance, 49, worldObj, xCoord, yCoord, zCoord); + + return true; + } + + return false; + } + + public int getScaledFluidLevel(int i) + { + if(clientCapacity == 0 || structure.fluidStored == null) + { + return 0; + } + + return structure.fluidStored.amount*i / clientCapacity; + } + + @Override + public ArrayList getNetworkedData(ArrayList data) + { + super.getNetworkedData(data); + + if(structure != null) + { + data.add(structure.getFluidCapacity()); + + if(structure.fluidStored != null) + { + data.add(1); + data.add(structure.fluidStored.getFluidID()); + data.add(structure.fluidStored.amount); + } + else { + data.add(0); + } + } + + return data; + } + + @Override + public void handlePacketData(ByteBuf dataStream) + { + super.handlePacketData(dataStream); + + if(clientHasStructure) + { + clientCapacity = dataStream.readInt(); + + if(dataStream.readInt() == 1) + { + structure.fluidStored = new FluidStack(FluidRegistry.getFluid(dataStream.readInt()), dataStream.readInt()); + } + else { + structure.fluidStored = null; + } + } + } @Override protected SynchronizedTurbineData getNewStructure() diff --git a/src/main/java/mekanism/generators/common/tile/turbine/TileEntityTurbineValve.java b/src/main/java/mekanism/generators/common/tile/turbine/TileEntityTurbineValve.java index 34d3f7000..6058a8b03 100644 --- a/src/main/java/mekanism/generators/common/tile/turbine/TileEntityTurbineValve.java +++ b/src/main/java/mekanism/generators/common/tile/turbine/TileEntityTurbineValve.java @@ -1,9 +1,82 @@ package mekanism.generators.common.tile.turbine; -public class TileEntityTurbineValve extends TileEntityTurbineCasing +import mekanism.common.util.LangUtils; +import mekanism.common.util.PipeUtils; +import mekanism.generators.common.content.turbine.TurbineFluidTank; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.FluidTankInfo; +import net.minecraftforge.fluids.IFluidHandler; + +public class TileEntityTurbineValve extends TileEntityTurbineCasing implements IFluidHandler { + public TurbineFluidTank fluidTank; + public TileEntityTurbineValve() { super("TurbineValve"); + fluidTank = new TurbineFluidTank(this); + } + + @Override + public FluidTankInfo[] getTankInfo(ForgeDirection from) + { + return ((!worldObj.isRemote && structure != null) || (worldObj.isRemote && clientHasStructure)) ? new FluidTankInfo[] {fluidTank.getInfo()} : PipeUtils.EMPTY; + } + + @Override + public int fill(ForgeDirection from, FluidStack resource, boolean doFill) + { + return fluidTank.fill(resource, doFill); + } + + @Override + public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain) + { + if(structure != null && structure.fluidStored != null) + { + if(resource.getFluid() == structure.fluidStored.getFluid()) + { + return fluidTank.drain(resource.amount, doDrain); + } + } + + return null; + } + + @Override + public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain) + { + if(structure != null) + { + return fluidTank.drain(maxDrain, doDrain); + } + + return null; + } + + @Override + public boolean canFill(ForgeDirection from, Fluid fluid) + { + if(fluid == FluidRegistry.getFluid("steam")) + { + return ((!worldObj.isRemote && structure != null) || (worldObj.isRemote && clientHasStructure)); + } + + return false; + } + + @Override + public boolean canDrain(ForgeDirection from, Fluid fluid) + { + return ((!worldObj.isRemote && structure != null) || (worldObj.isRemote && clientHasStructure)); + } + + @Override + public String getInventoryName() + { + return LangUtils.localize("gui.industrialTurbine"); } } diff --git a/src/main/resources/assets/mekanism/lang/en_US.lang b/src/main/resources/assets/mekanism/lang/en_US.lang index a80dfd238..5365c1287 100644 --- a/src/main/resources/assets/mekanism/lang/en_US.lang +++ b/src/main/resources/assets/mekanism/lang/en_US.lang @@ -449,6 +449,7 @@ gui.cells=cells gui.providers=providers gui.structure=Structure gui.dynamicTank=Dynamic Tank +gui.industrialTurbine=Industrial Turbine gui.visuals=Visuals gui.noEject=Can't Eject gui.undefined=Undefined