5a0fd88182
Most of it is working just need some more work before can be call Updated. Still have to fix model rotations, Add new steam engine, Add Eletric motor block, Add crank Shaft, Fix all models to fit to pipes, Re do pipes to look nicer. Most likely i need to fix both steam engine and boiler's share resources methods, and Generation methods
540 lines
15 KiB
Java
540 lines
15 KiB
Java
package EUI.SteamPower.boiler;
|
|
import com.google.common.io.ByteArrayDataInput;
|
|
|
|
import universalelectricity.network.IPacketReceiver;
|
|
import EUI.BasicPipes.pipes.api.ILiquidConsumer;
|
|
import EUI.BasicPipes.pipes.api.ILiquidProducer;
|
|
import EUI.SteamPower.SteamPower;
|
|
import EUI.SteamPower.TileEntityMachine;
|
|
import EUI.SteamPower.burner.TileEntityFireBox;
|
|
import net.minecraft.src.*;
|
|
import net.minecraftforge.common.ForgeDirection;
|
|
import net.minecraftforge.common.ISidedInventory;
|
|
|
|
public class TileEntityBoiler extends TileEntityMachine implements IPacketReceiver, IInventory, ISidedInventory,ILiquidProducer, ILiquidConsumer
|
|
{
|
|
|
|
/**
|
|
* The ItemStacks that hold the items currently being used in the furnace
|
|
*/
|
|
private ItemStack[] furnaceItemStacks = new ItemStack[1];
|
|
|
|
/** The number of ticks that the boiler will keep burning */
|
|
public int RunTime = 0;
|
|
/** The ammount of energy stored before being add to run Timer */
|
|
public int energyStore = 0;
|
|
/** The ammount of water stored */
|
|
public int waterStored = 0;
|
|
/** The ammount of steam stored */
|
|
public int steamStored = 0;
|
|
/** The ammount of heat stored */
|
|
public int heatStored = 0;
|
|
public int heatMax = 10000;
|
|
/** The ammount of heat stored */
|
|
public int hullHeat = 0;
|
|
public int hullHeatMax = 10000;
|
|
private int heatTick = 0;
|
|
int count = 0;
|
|
boolean hullHeated = false;
|
|
TileEntity[] connectedBlocks = {null, null, null, null, null, null};
|
|
int steamMax = 140;
|
|
public boolean isBeingHeated = false;
|
|
/**
|
|
* Returns the number of slots in the inventory.
|
|
*/
|
|
public int getSizeInventory()
|
|
{
|
|
return this.furnaceItemStacks.length;
|
|
}
|
|
|
|
/**
|
|
* Returns the stack in slot i
|
|
*/
|
|
public ItemStack getStackInSlot(int par1)
|
|
{
|
|
return this.furnaceItemStacks[par1];
|
|
}
|
|
|
|
public ItemStack decrStackSize(int par1, int par2)
|
|
{
|
|
if (this.furnaceItemStacks[par1] != null)
|
|
{
|
|
ItemStack var3;
|
|
|
|
if (this.furnaceItemStacks[par1].stackSize <= par2)
|
|
{
|
|
var3 = this.furnaceItemStacks[par1];
|
|
this.furnaceItemStacks[par1] = null;
|
|
return var3;
|
|
}
|
|
else
|
|
{
|
|
var3 = this.furnaceItemStacks[par1].splitStack(par2);
|
|
|
|
if (this.furnaceItemStacks[par1].stackSize == 0)
|
|
{
|
|
this.furnaceItemStacks[par1] = null;
|
|
}
|
|
|
|
return var3;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* When some containers are closed they call this on each slot, then drop whatever it returns as an EntityItem -
|
|
* like when you close a workbench GUI.
|
|
*/
|
|
public ItemStack getStackInSlotOnClosing(int par1)
|
|
{
|
|
if (this.furnaceItemStacks[par1] != null)
|
|
{
|
|
ItemStack var2 = this.furnaceItemStacks[par1];
|
|
this.furnaceItemStacks[par1] = null;
|
|
return var2;
|
|
}
|
|
else
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the given item stack to the specified slot in the inventory (can be crafting or armor sections).
|
|
*/
|
|
public void setInventorySlotContents(int par1, ItemStack par2ItemStack)
|
|
{
|
|
this.furnaceItemStacks[par1] = par2ItemStack;
|
|
|
|
if (par2ItemStack != null && par2ItemStack.stackSize > this.getInventoryStackLimit())
|
|
{
|
|
par2ItemStack.stackSize = this.getInventoryStackLimit();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the name of the inventory.
|
|
*/
|
|
public String getInvName()
|
|
{
|
|
return "container.boiler";
|
|
}
|
|
|
|
/**
|
|
* Reads a tile entity from NBT.
|
|
*/
|
|
public void readFromNBT(NBTTagCompound par1NBTTagCompound)
|
|
{
|
|
super.readFromNBT(par1NBTTagCompound);
|
|
NBTTagList var2 = par1NBTTagCompound.getTagList("Items");
|
|
this.furnaceItemStacks = new ItemStack[this.getSizeInventory()];
|
|
|
|
for (int var3 = 0; var3 < var2.tagCount(); ++var3)
|
|
{
|
|
NBTTagCompound var4 = (NBTTagCompound)var2.tagAt(var3);
|
|
byte var5 = var4.getByte("Slot");
|
|
|
|
if (var5 >= 0 && var5 < this.furnaceItemStacks.length)
|
|
{
|
|
this.furnaceItemStacks[var5] = ItemStack.loadItemStackFromNBT(var4);
|
|
}
|
|
}
|
|
|
|
this.RunTime = par1NBTTagCompound.getShort("BurnTime");
|
|
this.energyStore = par1NBTTagCompound.getInteger("energyStore");
|
|
this.steamStored = par1NBTTagCompound.getInteger("steamStore");
|
|
this.heatStored = par1NBTTagCompound.getInteger("heatStore");
|
|
this.waterStored = par1NBTTagCompound.getInteger("waterStore");
|
|
this.hullHeat = par1NBTTagCompound.getInteger("hullHeat");
|
|
}
|
|
|
|
/**
|
|
* Writes a tile entity to NBT.
|
|
*/
|
|
public void writeToNBT(NBTTagCompound par1NBTTagCompound)
|
|
{
|
|
super.writeToNBT(par1NBTTagCompound);
|
|
par1NBTTagCompound.setShort("BurnTime", (short)this.RunTime);
|
|
par1NBTTagCompound.setInteger("energyStore", (int)this.energyStore);
|
|
par1NBTTagCompound.setInteger("steamStore", (int)this.steamStored);
|
|
par1NBTTagCompound.setInteger("heatStore", (int)this.heatStored);
|
|
par1NBTTagCompound.setInteger("waterStore", (int)this.waterStored);
|
|
par1NBTTagCompound.setInteger("hullHeat", (int)this.hullHeat);
|
|
NBTTagList var2 = new NBTTagList();
|
|
|
|
for (int var3 = 0; var3 < this.furnaceItemStacks.length; ++var3)
|
|
{
|
|
if (this.furnaceItemStacks[var3] != null)
|
|
{
|
|
NBTTagCompound var4 = new NBTTagCompound();
|
|
var4.setByte("Slot", (byte)var3);
|
|
this.furnaceItemStacks[var3].writeToNBT(var4);
|
|
var2.appendTag(var4);
|
|
}
|
|
}
|
|
|
|
par1NBTTagCompound.setTag("Items", var2);
|
|
}
|
|
|
|
/**
|
|
* Returns the maximum stack size for a inventory slot. Seems to always be 64, possibly will be extended. *Isn't
|
|
* this more of a set than a get?*
|
|
*/
|
|
public int getInventoryStackLimit()
|
|
{
|
|
return 64;
|
|
}
|
|
|
|
/**
|
|
* Allows the entity to update its state. Overridden in most subclasses, e.g. the mob spawner uses this to count
|
|
* ticks and creates a new spawn inside its implementation.
|
|
*/
|
|
private boolean getIsHeated() {
|
|
TileEntity blockEntity = worldObj.getBlockTileEntity(this.xCoord, this.yCoord - 1, this.zCoord);
|
|
if(blockEntity instanceof TileEntityFireBox)
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
@Override
|
|
public void updateEntity(){
|
|
count++;
|
|
if(count >= 20){
|
|
isBeingHeated = getIsHeated();
|
|
addWater();//adds water from container slot
|
|
shareWater();
|
|
count = 0;
|
|
}
|
|
|
|
//changed hullHeat max depending on contents of boiler
|
|
if(waterStored > 0)
|
|
{
|
|
hullHeatMax = 4700;
|
|
if(hullHeat > hullHeatMax)
|
|
{
|
|
hullHeat = 4700;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hullHeatMax = 10000;
|
|
}
|
|
//Checks if the hull is heated
|
|
if(hullHeat >= hullHeatMax)
|
|
{
|
|
hullHeated = true;
|
|
}
|
|
else
|
|
{
|
|
hullHeat = Math.min(hullHeat + heatStored, hullHeatMax);
|
|
}
|
|
//checks if heat level hit max
|
|
if(hullHeat >= 10000)
|
|
{
|
|
if(heatTick >= 1200)
|
|
{
|
|
// TODO remove block and set fire
|
|
heatTick = 0;
|
|
}
|
|
else
|
|
{
|
|
heatTick += 1;
|
|
}
|
|
}
|
|
|
|
|
|
int heatNeeded = SteamPower.boilerHeat; // kilo joules
|
|
//if hull heated do work
|
|
if(hullHeated)
|
|
{
|
|
if(heatStored > SteamPower.fireOutput)
|
|
{
|
|
if(waterStored >= 1){
|
|
if(heatStored >= heatNeeded)
|
|
{
|
|
heatStored = Math.max(heatStored - heatNeeded, 0);
|
|
--waterStored;
|
|
steamStored = Math.min(steamStored + SteamPower.steamOutBoiler,this.steamMax);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
heatStored = 0;
|
|
}
|
|
}
|
|
}
|
|
TileEntity blockE = worldObj.getBlockTileEntity(xCoord, yCoord -1, zCoord);
|
|
if(blockE instanceof TileEntityFireBox)
|
|
{
|
|
if(!hullHeated || waterStored > 0)
|
|
{
|
|
heatStored = (int) Math.min((heatStored + ((TileEntityFireBox)blockE).onProduceHeat(SteamPower.fireOutput, 1)), heatMax);
|
|
}
|
|
}
|
|
|
|
}
|
|
public void shareWater()
|
|
{
|
|
int wSum = getStoredLiquid(1); //pre-sets the sum to the first tanks current volume
|
|
int tankCount = 1; //amount of tanks around this tank, used to get avarage liquid ammount
|
|
boolean bottom = false; // whether or not this tanks need to worry about what is bellow it
|
|
TileEntity entityBellow = worldObj.getBlockTileEntity(this.xCoord,this.yCoord-1, this.zCoord);
|
|
TileEntity entityAbove = worldObj.getBlockTileEntity(this.xCoord,this.yCoord+1, this.zCoord);
|
|
//checks wether or not the block bellow it is a tank to move liquid too
|
|
if(entityBellow instanceof TileEntityBoiler)
|
|
{
|
|
int bWater = ((TileEntityBoiler) entityBellow).getStoredLiquid(1);
|
|
int bMax = ((TileEntityBoiler) entityBellow).getLiquidCapacity(1);
|
|
//checks if that tank has room to get liquid.
|
|
|
|
if(bWater < bMax)
|
|
{
|
|
int emptyVol = Math.max( bMax - bWater,0);
|
|
int tradeVol = Math.min(emptyVol, waterStored);
|
|
int rejected = ((TileEntityBoiler) entityBellow).onReceiveLiquid(1, tradeVol, ForgeDirection.getOrientation(1));
|
|
waterStored = Math.max(waterStored - rejected,0);
|
|
wSum -= rejected;
|
|
}
|
|
else
|
|
{
|
|
bottom = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//there was no tank bellow this tank
|
|
bottom = true;
|
|
}
|
|
//if this is the bottom tank or bottom tank is full then trade liquid with tanks around it.
|
|
if(bottom)
|
|
{
|
|
//get average water around center tank
|
|
for(int i = 0; i<4;i++)
|
|
{
|
|
int x = this.xCoord;
|
|
int z = this.zCoord;
|
|
//switch to check each side TODO rewrite for side values
|
|
switch(i)
|
|
{
|
|
case 0: --x;
|
|
case 1: ++x;
|
|
case 2: --z;
|
|
case 3: ++z;
|
|
}
|
|
TileEntity entity = worldObj.getBlockTileEntity(x,this.yCoord, z);
|
|
if(entity instanceof TileEntityBoiler)
|
|
{
|
|
//if is a tank add to the sum
|
|
wSum += ((TileEntityBoiler) entity).getStoredLiquid(1);
|
|
tankCount += 1;
|
|
}
|
|
}
|
|
}
|
|
//transfers water
|
|
for(int i = 0; i<4;i++)
|
|
{
|
|
int average = wSum / tankCount;// takes the sum and makes it an average
|
|
int x2 = this.xCoord;
|
|
int z2 = this.zCoord;
|
|
int tradeSum = 0;
|
|
//switch to check each side TODO rewrite for side values
|
|
switch(i)
|
|
{
|
|
case 0: --x2;
|
|
case 1: ++x2;
|
|
case 2: --z2;
|
|
case 3: ++z2;
|
|
}
|
|
TileEntity entity = worldObj.getBlockTileEntity(x2,this.yCoord, z2);
|
|
if(entity instanceof TileEntityBoiler)
|
|
{
|
|
int targetW = ((TileEntityBoiler) entity).getStoredLiquid(1);
|
|
if(targetW < average)
|
|
{
|
|
tradeSum = Math.min(average, waterStored); //gets the ammount to give to the target tank
|
|
int rejectedAm = ((TileEntityBoiler) entity).onReceiveLiquid(1, tradeSum, ForgeDirection.getOrientation(i)); //send that ammount with safty incase some comes back
|
|
waterStored =rejectedAm + waterStored - tradeSum; //counts up current water sum after trade
|
|
}
|
|
}
|
|
}
|
|
if(entityAbove instanceof TileEntityBoiler)
|
|
{
|
|
int bWater = ((TileEntityBoiler) entityAbove).getStoredLiquid(1);
|
|
int bMax = ((TileEntityBoiler) entityAbove).getLiquidCapacity(1);
|
|
if(bottom && waterStored > 0)
|
|
{
|
|
if(bWater < bMax)
|
|
{
|
|
int emptyVolS = Math.max( bMax - bWater,0);
|
|
int tradeVolS = Math.min(emptyVolS, steamStored);
|
|
int rejectedS = ((TileEntityBoiler) entityAbove).addSteam(tradeVolS);
|
|
waterStored = Math.max(waterStored - rejectedS,0);
|
|
wSum -= rejectedS;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
public int addSteam(int watt) {
|
|
int rejectedElectricity = Math.max((this.steamStored + watt) - steamMax, 0);
|
|
this.steamStored += watt - rejectedElectricity;
|
|
return rejectedElectricity;
|
|
}
|
|
private void addWater() {
|
|
if (this.furnaceItemStacks[0] != null)
|
|
{
|
|
if(this.furnaceItemStacks[0].isItemEqual(new ItemStack(Item.bucketWater,1)))
|
|
{
|
|
if((int)waterStored < getLiquidCapacity(1))
|
|
{
|
|
++waterStored;
|
|
this.furnaceItemStacks[0] = new ItemStack(Item.bucketEmpty,1);
|
|
this.onInventoryChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Do not make give this method the name canInteractWith because it clashes with Container
|
|
*/
|
|
public boolean isUseableByPlayer(EntityPlayer par1EntityPlayer)
|
|
{
|
|
return this.worldObj.getBlockTileEntity(this.xCoord, this.yCoord, this.zCoord) != this ? false : par1EntityPlayer.getDistanceSq((double)this.xCoord + 0.5D, (double)this.yCoord + 0.5D, (double)this.zCoord + 0.5D) <= 64.0D;
|
|
}
|
|
|
|
public void openChest() {}
|
|
|
|
public void closeChest() {}
|
|
|
|
public int precentHeated() {
|
|
int var1;
|
|
if(hullHeat < 100)
|
|
{
|
|
var1 = (int)(100 *(hullHeat/100));
|
|
}
|
|
else
|
|
{
|
|
var1 = 100;
|
|
}
|
|
return var1;
|
|
}
|
|
@Override
|
|
public int onReceiveLiquid(int type, int vol, ForgeDirection side) {
|
|
if(type == 1)
|
|
{
|
|
int rejectedElectricity = Math.max((this.waterStored + vol) - this.getLiquidCapacity(1), 0);
|
|
this.waterStored += vol - rejectedElectricity;
|
|
return rejectedElectricity;
|
|
}
|
|
return vol;
|
|
}
|
|
|
|
@Override
|
|
public boolean canRecieveLiquid(int type,ForgeDirection side) {
|
|
if(type == 1)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public int getStoredLiquid(int type) {
|
|
if(type == 1)
|
|
{
|
|
return this.waterStored;
|
|
}
|
|
if(type == 0)
|
|
{
|
|
return this.steamStored;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public int getLiquidCapacity(int type) {
|
|
if(type ==1)
|
|
{
|
|
return 14;
|
|
}
|
|
if(type == 0)
|
|
{
|
|
return steamMax;
|
|
}
|
|
return 0;
|
|
}
|
|
@Override
|
|
public int onProduceLiquid(int type, int maxVol, ForgeDirection side) {
|
|
if(type == 0)
|
|
{
|
|
if(steamStored > 1)
|
|
{
|
|
this.steamStored -= 1;
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public boolean canProduceLiquid(int type, ForgeDirection side) {
|
|
if(type == 0)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public int getStartInventorySide(ForgeDirection side) {
|
|
// TODO Auto-generated method stub
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public int getSizeInventorySide(ForgeDirection side) {
|
|
// TODO Auto-generated method stub
|
|
return 0;
|
|
}
|
|
public Object[] getSendData()
|
|
{
|
|
return new Object[]{(int)facing,(int)RunTime,(int)energyStore,(int)waterStored,
|
|
(int)steamStored,(int)heatStored,(int)hullHeat,(int)heatTick};
|
|
}
|
|
|
|
@Override
|
|
public void handlePacketData(NetworkManager network,
|
|
Packet250CustomPayload packet, EntityPlayer player,
|
|
ByteArrayDataInput dataStream) {
|
|
try{
|
|
facing = dataStream.readInt();
|
|
RunTime = dataStream.readInt();
|
|
energyStore = dataStream.readInt();
|
|
waterStored = dataStream.readInt();
|
|
steamStored = dataStream.readInt();
|
|
heatStored = dataStream.readInt();
|
|
hullHeat = dataStream.readInt();
|
|
heatTick = dataStream.readInt();
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
e.printStackTrace();
|
|
}
|
|
|
|
}
|
|
|
|
}
|