tilera/Mekanism-tilera-Edition
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Multiblock protocol works, begin turbine tile code

Browse source
This commit is contained in:
aidancbrady 2016-01-22 23:46:16 -05:00
parent c341e6290b
commit 769a8fd480
13 changed files with 606 additions and 22 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
src/main/java/mekanism/common/block/BlockBasic.java
View file

@ -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)

2
src/main/java/mekanism/common/content/tank/DynamicFluidTank.java
View file

@ -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)
{

3
src/main/java/mekanism/common/tile/TileEntityDynamicTank.java
View file

@ -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<SynchronizedTank
if(dataStream.readInt() == 1)
{
structure.fluidStored = new FluidStack(dataStream.readInt(), dataStream.readInt());
structure.fluidStored = new FluidStack(FluidRegistry.getFluid(dataStream.readInt()), dataStream.readInt());
}
else {
structure.fluidStored = null;

19
src/main/java/mekanism/generators/client/GeneratorsClientProxy.java
View file

@ -15,6 +15,7 @@ import mekanism.generators.client.render.RenderAdvancedSolarGenerator;
import mekanism.generators.client.render.RenderBioGenerator;
import mekanism.generators.client.render.RenderGasGenerator;
import mekanism.generators.client.render.RenderHeatGenerator;
import mekanism.generators.client.render.RenderIndustrialTurbine;
import mekanism.generators.client.render.RenderReactor;
import mekanism.generators.client.render.RenderSolarGenerator;
import mekanism.generators.client.render.RenderTurbineRotor;
@ -41,9 +42,11 @@ import net.minecraft.item.Item;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;
import net.minecraftforge.client.MinecraftForgeClient;
import net.minecraftforge.client.event.TextureStitchEvent;
import net.minecraftforge.common.MinecraftForge;
import cpw.mods.fml.client.registry.ClientRegistry;
import cpw.mods.fml.client.registry.RenderingRegistry;
import cpw.mods.fml.common.registry.GameRegistry;
import cpw.mods.fml.common.eventhandler.SubscribeEvent;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
@ -61,9 +64,9 @@ public class GeneratorsClientProxy extends GeneratorsCommonProxy
ClientRegistry.registerTileEntity(TileEntityWindGenerator.class, "WindTurbine", new RenderWindTurbine());
ClientRegistry.registerTileEntity(TileEntityReactorController.class, "ReactorController", new RenderReactor());
ClientRegistry.registerTileEntity(TileEntityTurbineRotor.class, "TurbineRod", new RenderTurbineRotor());
GameRegistry.registerTileEntity(TileEntityTurbineCasing.class, "TurbineCasing"); //TODO turbine render
GameRegistry.registerTileEntity(TileEntityTurbineValve.class, "TurbineValve");
GameRegistry.registerTileEntity(TileEntityTurbineVent.class, "TurbineVent");
ClientRegistry.registerTileEntity(TileEntityTurbineCasing.class, "TurbineCasing", new RenderIndustrialTurbine());
ClientRegistry.registerTileEntity(TileEntityTurbineValve.class, "TurbineValve", new RenderIndustrialTurbine());
ClientRegistry.registerTileEntity(TileEntityTurbineVent.class, "TurbineVent", new RenderIndustrialTurbine());
}
@Override
@ -74,6 +77,8 @@ public class GeneratorsClientProxy extends GeneratorsCommonProxy
//Register item handler
GeneratorsItemRenderer handler = new GeneratorsItemRenderer();
MinecraftForge.EVENT_BUS.register(this);
MinecraftForgeClient.registerItemRenderer(Item.getItemFromBlock(GeneratorsBlocks.Generator), handler);
@ -113,4 +118,10 @@ public class GeneratorsClientProxy extends GeneratorsCommonProxy
return null;
}
@SubscribeEvent
public void onStitch(TextureStitchEvent.Pre event)
{
RenderIndustrialTurbine.resetDisplayInts();
}
}

128
src/main/java/mekanism/generators/client/render/RenderIndustrialTurbine.java Normal file
View file

@ -0,0 +1,128 @@
package mekanism.generators.client.render;
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.common.content.tank.TankUpdateProtocol;
import mekanism.generators.common.tile.turbine.TileEntityTurbineCasing;
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;
public class RenderIndustrialTurbine extends TileEntitySpecialRenderer
{
private static Map<RenderData, DisplayInteger[]> cachedFluids = new HashMap<RenderData, DisplayInteger[]>();
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();
}
}

16
src/main/java/mekanism/generators/common/block/BlockGenerator.java
View file

@ -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;

28
src/main/java/mekanism/generators/common/content/turbine/SynchronizedTurbineData.java
View file

@ -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<SynchronizedTurbineData>
{
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;
}
}

19
src/main/java/mekanism/generators/common/content/turbine/TurbineCache.java
View file

@ -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<SynchronizedTurbineData>
{
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()));
}
}
}

177
src/main/java/mekanism/generators/common/content/turbine/TurbineFluidTank.java Normal file
View file

@ -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);
}
}

28
src/main/java/mekanism/generators/common/content/turbine/TurbineUpdateProtocol.java
View file

@ -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<SynchronizedTurbineData>
{
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<SynchronizedTurbineDat
@Override
protected boolean isValidFrame(int x, int y, int z)
{
return false;
//return pointer.getWorldObj().getBlock(x, y, z) == GeneratorsBlocks.Generator &&
// GeneratorType.getFromMetadata(pointer.getWorldObj().getBlockMetadata(x, y, z)) == GeneratorType.TURBINE_CASING;
return pointer.getWorldObj().getBlock(x, y, z) == GeneratorsBlocks.Generator &&
GeneratorType.getFromMetadata(pointer.getWorldObj().getBlockMetadata(x, y, z)) == GeneratorType.TURBINE_CASING;
}
@Override
@ -43,7 +45,7 @@ public class TurbineUpdateProtocol extends UpdateProtocol<SynchronizedTurbineDat
{
return true;
}
TileEntity tile = pointer.getWorldObj().getTileEntity(x, y, z);
return tile instanceof TileEntityTurbineRotor || tile instanceof TileEntityRotationalComplex ||
@ -236,7 +238,23 @@ public class TurbineUpdateProtocol extends UpdateProtocol<SynchronizedTurbineDat
@Override
protected void mergeCaches(List<ItemStack> rejectedItems, MultiblockCache<SynchronizedTurbineData> cache, MultiblockCache<SynchronizedTurbineData> 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

123
src/main/java/mekanism/generators/common/tile/turbine/TileEntityTurbineCasing.java
View file

@ -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<SynchronizedTurbineData>
{
public int clientCapacity;
public float prevScale;
public TileEntityTurbineCasing()
{
this("TurbineCasing");
@ -20,6 +36,113 @@ public class TileEntityTurbineCasing extends TileEntityMultiblock<SynchronizedTu
{
super(name);
}
@Override
public void onUpdate()
{
super.onUpdate();
if(worldObj.isRemote)
{
if(structure != null && clientHasStructure && isRendering)
{
float targetScale = (float)(structure.fluidStored != null ? structure.fluidStored.amount : 0)/clientCapacity;
if(Math.abs(prevScale - targetScale) > 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()

75
src/main/java/mekanism/generators/common/tile/turbine/TileEntityTurbineValve.java
View file

@ -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");
}
}

1
src/main/resources/assets/mekanism/lang/en_US.lang
View file

@ -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