mirror of
https://github.com/GTNewHorizons/ForestryMC.git
synced 2026-11-19 03:39:09 +00:00
The fix kind of grew out of control because I had to add a new EnumErrorCode and didn't want to keep breaking the API every time I did that. So I needed to decouple the ErrorStates from EnumErrorCode.
537 lines
14 KiB
Java
Executable File
537 lines
14 KiB
Java
Executable File
/*******************************************************************************
|
|
* Copyright (c) 2011-2014 SirSengir.
|
|
* All rights reserved. This program and the accompanying materials
|
|
* are made available under the terms of the GNU Lesser Public License v3
|
|
* which accompanies this distribution, and is available at
|
|
* http://www.gnu.org/licenses/lgpl-3.0.txt
|
|
*
|
|
* Various Contributors including, but not limited to:
|
|
* SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
|
|
******************************************************************************/
|
|
package forestry.energy.gadgets;
|
|
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.inventory.Container;
|
|
import net.minecraft.inventory.ICrafting;
|
|
import net.minecraft.inventory.ISidedInventory;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
|
|
import net.minecraftforge.common.util.ForgeDirection;
|
|
import net.minecraftforge.fluids.Fluid;
|
|
import net.minecraftforge.fluids.FluidContainerRegistry.FluidContainerData;
|
|
import net.minecraftforge.fluids.FluidRegistry;
|
|
import net.minecraftforge.fluids.FluidStack;
|
|
import net.minecraftforge.fluids.FluidTankInfo;
|
|
|
|
import forestry.core.EnumErrorCode;
|
|
import forestry.api.core.ForestryAPI;
|
|
import forestry.api.fuels.EngineBronzeFuel;
|
|
import forestry.api.fuels.FuelManager;
|
|
import forestry.core.config.Config;
|
|
import forestry.core.config.Defaults;
|
|
import forestry.core.fluids.FluidHelper;
|
|
import forestry.core.fluids.Fluids;
|
|
import forestry.core.fluids.TankManager;
|
|
import forestry.core.fluids.tanks.FilteredTank;
|
|
import forestry.core.fluids.tanks.StandardTank;
|
|
import forestry.core.gadgets.Engine;
|
|
import forestry.core.gadgets.TileBase;
|
|
import forestry.core.interfaces.ILiquidTankContainer;
|
|
import forestry.core.network.GuiId;
|
|
import forestry.core.network.PacketPayload;
|
|
import forestry.core.utils.TileInventoryAdapter;
|
|
|
|
public class EngineBronze extends Engine implements ISidedInventory, ILiquidTankContainer {
|
|
|
|
/* CONSTANTS */
|
|
public static final short SLOT_CAN = 0;
|
|
|
|
/* NETWORK */
|
|
@Override
|
|
public PacketPayload getPacketPayload() {
|
|
PacketPayload payload = super.getPacketPayload();
|
|
|
|
if (shutdown)
|
|
payload.append(new int[]{1});
|
|
else
|
|
payload.append(new int[]{0});
|
|
|
|
return payload;
|
|
}
|
|
|
|
@Override
|
|
public void fromPacketPayload(PacketPayload payload) {
|
|
super.fromPacketPayload(payload);
|
|
|
|
if (payload.intPayload[3] > 0)
|
|
shutdown = true;
|
|
else
|
|
shutdown = false;
|
|
}
|
|
public FilteredTank fuelTank;
|
|
public FilteredTank heatingTank;
|
|
private final TankManager tankManager;
|
|
private final TileInventoryAdapter inventory;
|
|
public int burnTime;
|
|
public int totalTime;
|
|
public int currentFluidId = -1;
|
|
/**
|
|
* true if the engine is too cold and needs to warm itself up.
|
|
*/
|
|
private boolean shutdown;
|
|
|
|
public EngineBronze() {
|
|
super(Defaults.ENGINE_BRONZE_HEAT_MAX, 300000, 5000);
|
|
setHints(Config.hints.get("engine.bronze"));
|
|
|
|
inventory = new TileInventoryAdapter(this, 1, "Items");
|
|
|
|
fuelTank = new FilteredTank(Defaults.ENGINE_TANK_CAPACITY, FuelManager.bronzeEngineFuel.keySet());
|
|
fuelTank.tankMode = StandardTank.TankMode.INPUT;
|
|
heatingTank = new FilteredTank(Defaults.ENGINE_TANK_CAPACITY, FluidRegistry.LAVA);
|
|
heatingTank.tankMode = StandardTank.TankMode.INPUT;
|
|
this.tankManager = new TankManager(fuelTank, heatingTank);
|
|
}
|
|
|
|
@Override
|
|
public TankManager getTankManager() {
|
|
return tankManager;
|
|
}
|
|
|
|
@Override
|
|
public void openGui(EntityPlayer player, TileBase tile) {
|
|
player.openGui(ForestryAPI.instance, GuiId.EngineBronzeGUI.ordinal(), player.worldObj, xCoord, yCoord, zCoord);
|
|
}
|
|
|
|
@Override
|
|
public void updateServerSide() {
|
|
|
|
super.updateServerSide();
|
|
|
|
if (worldObj.getTotalWorldTime() % 20 * 10 != 0)
|
|
return;
|
|
|
|
// Check if we have suitable items waiting in the item slot
|
|
if (inventory.getStackInSlot(SLOT_CAN) != null) {
|
|
FluidHelper.drainContainers(tankManager, inventory, SLOT_CAN);
|
|
}
|
|
|
|
if (getHeatLevel() <= 0.2 && heatingTank.getFluidAmount() <= 0)
|
|
setErrorState(EnumErrorCode.NOHEAT);
|
|
else if (burnTime <= 0 && fuelTank.getFluidAmount() <= 0)
|
|
setErrorState(EnumErrorCode.NOFUEL);
|
|
else
|
|
setErrorState(EnumErrorCode.OK);
|
|
}
|
|
|
|
/**
|
|
* Burns fuel increasing stored energy
|
|
*/
|
|
@Override
|
|
public void burn() {
|
|
|
|
currentOutput = 0;
|
|
|
|
if (isActivated() && (fuelTank.getFluidAmount() >= Defaults.BUCKET_VOLUME || burnTime > 0)) {
|
|
|
|
double heatStage = getHeatLevel();
|
|
|
|
// If we have reached a safe temperature, we reenable energy
|
|
// transfer
|
|
if (heatStage > 0.25 && shutdown)
|
|
shutdown(false);
|
|
else if (shutdown)
|
|
|
|
if (heatingTank.getFluidAmount() > 0 && Fluids.LAVA.is(heatingTank.getFluid())) {
|
|
addHeat(Defaults.ENGINE_HEAT_VALUE_LAVA);
|
|
heatingTank.drain(1, true);
|
|
}
|
|
|
|
// We need a minimum temperature to generate energy
|
|
if (heatStage > 0.2)
|
|
|
|
if (burnTime > 0) {
|
|
burnTime--;
|
|
currentOutput = determineFuelValue(FluidRegistry.getFluid(currentFluidId));
|
|
energyManager.generateEnergy(currentOutput);
|
|
} else {
|
|
burnTime = totalTime = this.determineBurnTime(fuelTank.getFluid().getFluid());
|
|
currentFluidId = fuelTank.getFluid().getFluid().getID();
|
|
fuelTank.drain(Defaults.BUCKET_VOLUME, true);
|
|
}
|
|
else
|
|
shutdown(true);
|
|
}
|
|
|
|
if (burnTime <= 0)
|
|
currentFluidId = -1;
|
|
}
|
|
|
|
private void shutdown(boolean val) {
|
|
shutdown = val;
|
|
}
|
|
|
|
@Override
|
|
public int dissipateHeat() {
|
|
if (heat <= 0)
|
|
return 0;
|
|
|
|
int loss = 1; // Basic loss even when running
|
|
|
|
if (!isBurning())
|
|
loss++;
|
|
|
|
double heatStage = getHeatLevel();
|
|
if (heatStage > 0.55)
|
|
loss++;
|
|
|
|
// Lose extra heat when using water as fuel.
|
|
if (fuelTank.getFluidAmount() > 0) {
|
|
FluidStack fuelFluidStack = fuelTank.getFluid();
|
|
EngineBronzeFuel fuel = FuelManager.bronzeEngineFuel.get(fuelFluidStack.getFluid());
|
|
if (fuel != null)
|
|
loss = loss * fuel.dissipationMultiplier;
|
|
}
|
|
|
|
heat -= loss;
|
|
return loss;
|
|
}
|
|
|
|
@Override
|
|
public int generateHeat() {
|
|
|
|
int generate = 0;
|
|
|
|
if (isActivated() && burnTime > 0) {
|
|
double heatStage = getHeatLevel();
|
|
if (heatStage >= 0.75)
|
|
generate += Defaults.ENGINE_BRONZE_HEAT_GENERATION_ENERGY * 3;
|
|
else if (heatStage > 0.24)
|
|
generate += Defaults.ENGINE_BRONZE_HEAT_GENERATION_ENERGY * 2;
|
|
else if (heatStage > 0.2)
|
|
generate += Defaults.ENGINE_BRONZE_HEAT_GENERATION_ENERGY;
|
|
}
|
|
|
|
heat += generate;
|
|
return generate;
|
|
|
|
}
|
|
|
|
/**
|
|
* Returns the fuel value (power per cycle) an item of the passed ItemStack
|
|
* provides
|
|
*
|
|
* @param fluid
|
|
* @return
|
|
*/
|
|
private int determineFuelValue(Fluid fluid) {
|
|
if (FuelManager.bronzeEngineFuel.containsKey(fluid))
|
|
return FuelManager.bronzeEngineFuel.get(fluid).powerPerCycle;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param fluid
|
|
* @return Duration of burn cycle of one bucket
|
|
*/
|
|
private int determineBurnTime(Fluid fluid) {
|
|
if (FuelManager.bronzeEngineFuel.containsKey(fluid))
|
|
return FuelManager.bronzeEngineFuel.get(fluid).burnDuration;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
protected ItemStack replenishByContainer(ItemStack inventoryStack, FluidContainerData container, StandardTank tank) {
|
|
if (container == null)
|
|
return inventoryStack;
|
|
|
|
if (tank.fill(container.fluid, false) >= container.fluid.amount) {
|
|
tank.fill(container.fluid, true);
|
|
if (container.filledContainer != null && container.filledContainer.getItem().hasContainerItem(container.filledContainer))
|
|
inventoryStack = container.emptyContainer.copy();
|
|
else
|
|
inventoryStack.stackSize--;
|
|
}
|
|
|
|
return inventoryStack;
|
|
}
|
|
|
|
// / STATE INFORMATION
|
|
@Override
|
|
public boolean isBurning() {
|
|
return mayBurn() && burnTime > 0;
|
|
}
|
|
|
|
@Override
|
|
public int getBurnTimeRemainingScaled(int i) {
|
|
if (totalTime == 0)
|
|
return 0;
|
|
|
|
return (burnTime * i) / totalTime;
|
|
}
|
|
|
|
public int getOperatingTemperatureScaled(int i) {
|
|
return (int) Math.round((heat * i) / (maxHeat * 0.2));
|
|
}
|
|
|
|
public int getFuelScaled(int i) {
|
|
return (fuelTank.getFluidAmount() * i) / Defaults.ENGINE_TANK_CAPACITY;
|
|
}
|
|
|
|
public int getHeatingFuelScaled(int i) {
|
|
return (heatingTank.getFluidAmount() * i) / Defaults.ENGINE_TANK_CAPACITY;
|
|
}
|
|
|
|
/**
|
|
* Reads saved data
|
|
* @param nbt
|
|
*/
|
|
@Override
|
|
public void readFromNBT(NBTTagCompound nbt) {
|
|
|
|
super.readFromNBT(nbt);
|
|
|
|
burnTime = nbt.getInteger("EngineBurnTime");
|
|
totalTime = nbt.getInteger("EngineTotalTime");
|
|
|
|
if (nbt.hasKey("currentFluid")) {
|
|
Fluid fluid = FluidRegistry.getFluid(nbt.getString("currentFluid"));
|
|
if (fluid != null)
|
|
currentFluidId = fluid.getID();
|
|
}
|
|
|
|
tankManager.readTanksFromNBT(nbt);
|
|
inventory.readFromNBT(nbt);
|
|
|
|
}
|
|
|
|
/**
|
|
* Writes data to save
|
|
* @param nbt
|
|
*/
|
|
@Override
|
|
public void writeToNBT(NBTTagCompound nbt) {
|
|
|
|
super.writeToNBT(nbt);
|
|
|
|
nbt.setInteger("EngineBurnTime", burnTime);
|
|
nbt.setInteger("EngineTotalTime", totalTime);
|
|
|
|
Fluid fluid = FluidRegistry.getFluid(currentFluidId);
|
|
if (fluid != null)
|
|
nbt.setString("currentFluid", fluid.getName());
|
|
|
|
tankManager.writeTanksToNBT(nbt);
|
|
inventory.writeToNBT(nbt);
|
|
}
|
|
|
|
/* GUI */
|
|
@Override
|
|
public void getGUINetworkData(int id, int data) {
|
|
id -= tankManager.maxMessageId() + 1;
|
|
|
|
switch (id) {
|
|
case 0:
|
|
burnTime = data;
|
|
break;
|
|
case 1:
|
|
totalTime = data;
|
|
break;
|
|
case 2:
|
|
currentOutput = data;
|
|
break;
|
|
case 3:
|
|
energyManager.fromPacketInt(data);
|
|
break;
|
|
case 4:
|
|
heat = data;
|
|
break;
|
|
case 5:
|
|
currentFluidId = data;
|
|
break;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void sendGUINetworkData(Container containerEngine, ICrafting iCrafting) {
|
|
int i = tankManager.maxMessageId() + 1;
|
|
iCrafting.sendProgressBarUpdate(containerEngine, i, burnTime);
|
|
iCrafting.sendProgressBarUpdate(containerEngine, i + 1, totalTime);
|
|
iCrafting.sendProgressBarUpdate(containerEngine, i + 2, currentOutput);
|
|
iCrafting.sendProgressBarUpdate(containerEngine, i + 3, energyManager.toPacketInt());
|
|
iCrafting.sendProgressBarUpdate(containerEngine, i + 4, heat);
|
|
iCrafting.sendProgressBarUpdate(containerEngine, i + 5, currentFluidId);
|
|
}
|
|
|
|
/* IINVENTORY */
|
|
@Override
|
|
public int getSizeInventory() {
|
|
return inventory.getSizeInventory();
|
|
}
|
|
|
|
@Override
|
|
public ItemStack getStackInSlot(int i) {
|
|
return inventory.getStackInSlot(i);
|
|
}
|
|
|
|
@Override
|
|
public void setInventorySlotContents(int i, ItemStack itemstack) {
|
|
inventory.setInventorySlotContents(i, itemstack);
|
|
}
|
|
|
|
@Override
|
|
public ItemStack decrStackSize(int i, int j) {
|
|
return inventory.decrStackSize(i, j);
|
|
}
|
|
|
|
@Override
|
|
public ItemStack getStackInSlotOnClosing(int slot) {
|
|
return inventory.getStackInSlotOnClosing(slot);
|
|
}
|
|
|
|
@Override
|
|
public int getInventoryStackLimit() {
|
|
return inventory.getInventoryStackLimit();
|
|
}
|
|
|
|
@Override
|
|
public void openInventory() {
|
|
}
|
|
|
|
@Override
|
|
public void closeInventory() {
|
|
}
|
|
|
|
/**
|
|
* TODO: just a specialsource workaround
|
|
* @param player
|
|
* @return
|
|
*/
|
|
@Override
|
|
public boolean isUseableByPlayer(EntityPlayer player) {
|
|
return super.isUseableByPlayer(player);
|
|
}
|
|
|
|
@Override
|
|
public String getInventoryName() {
|
|
return getUnlocalizedName();
|
|
}
|
|
|
|
/**
|
|
* TODO: just a specialsource workaround
|
|
* @return
|
|
*/
|
|
@Override
|
|
public boolean hasCustomInventoryName() {
|
|
return super.hasCustomInventoryName();
|
|
}
|
|
|
|
/**
|
|
* TODO: just a specialsource workaround
|
|
* @param slotIndex
|
|
* @param itemstack
|
|
* @return
|
|
*/
|
|
@Override
|
|
public boolean isItemValidForSlot(int slotIndex, ItemStack itemstack) {
|
|
if (slotIndex == SLOT_CAN) {
|
|
FluidStack fluid = FluidHelper.getFluidStackInContainer(itemstack);
|
|
if (fluid == null || fluid.amount <= 0)
|
|
return false;
|
|
return fuelTank.accepts(fluid.getFluid()) || heatingTank.accepts(fluid.getFluid());
|
|
}
|
|
|
|
return super.isItemValidForSlot(slotIndex, itemstack);
|
|
}
|
|
|
|
/* ISIDEDINVENTORY */
|
|
@Override
|
|
protected boolean canTakeStackFromSide(int slotIndex, ItemStack stack, int side) {
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
protected boolean canPutStackFromSide(int slotIndex, ItemStack stack, int side) {
|
|
if (!super.canTakeStackFromSide(slotIndex, stack, side))
|
|
return false;
|
|
|
|
return FluidHelper.isContainer(stack);
|
|
}
|
|
|
|
/**
|
|
* TODO: just a specialsource workaround
|
|
* @return
|
|
*/
|
|
@Override
|
|
public boolean canExtractItem(int i, ItemStack itemstack, int j) {
|
|
return super.canExtractItem(i, itemstack, j);
|
|
}
|
|
|
|
/**
|
|
* TODO: just a specialsource workaround
|
|
* @return
|
|
*/
|
|
@Override
|
|
public boolean canInsertItem(int i, ItemStack itemstack, int j) {
|
|
return super.canInsertItem(i, itemstack, j);
|
|
}
|
|
|
|
/**
|
|
* TODO: just a specialsource workaround
|
|
* @return
|
|
*/
|
|
@Override
|
|
public int[] getAccessibleSlotsFromSide(int side) {
|
|
return super.getAccessibleSlotsFromSide(side); //To change body of generated methods, choose Tools | Templates.
|
|
}
|
|
|
|
/* ISPECIALINVENTORY */
|
|
// @Override
|
|
// public int addItem(ItemStack stack, boolean doAdd, ForgeDirection from) {
|
|
// FluidContainerData container = LiquidHelper.getLiquidContainer(stack);
|
|
// if (container == null)
|
|
// return 0;
|
|
//
|
|
// return inventory.addStack(stack, false, doAdd);
|
|
// }
|
|
//
|
|
// @Override
|
|
// public ItemStack[] extractItem(boolean doRemove, ForgeDirection from, int maxItemCount) {
|
|
// return null;
|
|
// }
|
|
// IFluidHandler
|
|
@Override
|
|
public int fill(ForgeDirection from, FluidStack resource, boolean doFill) {
|
|
return tankManager.fill(from, resource, doFill);
|
|
}
|
|
|
|
@Override
|
|
public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain) {
|
|
return tankManager.drain(from, resource, doDrain);
|
|
}
|
|
|
|
@Override
|
|
public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain) {
|
|
return tankManager.drain(from, maxDrain, doDrain);
|
|
}
|
|
|
|
@Override
|
|
public boolean canFill(ForgeDirection from, Fluid fluid) {
|
|
return tankManager.canFill(from, fluid);
|
|
}
|
|
|
|
@Override
|
|
public boolean canDrain(ForgeDirection from, Fluid fluid) {
|
|
return tankManager.canDrain(from, fluid);
|
|
}
|
|
|
|
@Override
|
|
public FluidTankInfo[] getTankInfo(ForgeDirection from) {
|
|
return tankManager.getTankInfo(from);
|
|
}
|
|
|
|
}
|