mirror of
https://github.com/GTNewHorizons/ForestryMC.git
synced 2026-11-18 11:19:28 +00:00
375 lines
9.3 KiB
Java
Executable File
375 lines
9.3 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 forestry.plugins.PluginManager;
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.inventory.Container;
|
|
import net.minecraft.inventory.ICrafting;
|
|
import net.minecraft.inventory.IInventory;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
|
|
import ic2.api.energy.prefab.BasicSink;
|
|
|
|
import forestry.api.circuits.ChipsetManager;
|
|
import forestry.api.circuits.ICircuitBoard;
|
|
import forestry.api.core.ForestryAPI;
|
|
import forestry.core.EnumErrorCode;
|
|
import forestry.core.TemperatureState;
|
|
import forestry.core.config.Config;
|
|
import forestry.core.config.Defaults;
|
|
import forestry.core.gadgets.Engine;
|
|
import forestry.core.gadgets.TileBase;
|
|
import forestry.core.interfaces.ISocketable;
|
|
import forestry.core.network.GuiId;
|
|
import forestry.core.utils.DelayTimer;
|
|
import forestry.core.utils.EnumTankLevel;
|
|
import forestry.core.utils.InventoryAdapter;
|
|
import forestry.plugins.PluginIC2;
|
|
|
|
public class EngineTin extends Engine implements ISocketable, IInventory {
|
|
|
|
protected static class EuConfig {
|
|
public int euForCycle;
|
|
public int mjPerCycle;
|
|
public int euStorage;
|
|
public int euMaxAccept = 512;
|
|
|
|
public EuConfig(int euForCycle, int mjPerCycle, int euStorage) {
|
|
this.euForCycle = euForCycle;
|
|
this.mjPerCycle = mjPerCycle;
|
|
this.euStorage = euStorage;
|
|
}
|
|
}
|
|
|
|
private final short batterySlot = 0;
|
|
private final InventoryAdapter inventory = new InventoryAdapter(1, "electrical");
|
|
private final InventoryAdapter sockets = new InventoryAdapter(1, "sockets");
|
|
private final EuConfig euConfig = new EuConfig(Defaults.ENGINE_TIN_EU_FOR_CYCLE, Defaults.ENGINE_TIN_ENERGY_PER_CYCLE, Defaults.ENGINE_TIN_MAX_EU_STORED);
|
|
|
|
protected BasicSink ic2EnergySink;
|
|
|
|
private final DelayTimer delayUpdateTimer = new DelayTimer();
|
|
|
|
public EngineTin() {
|
|
super(Defaults.ENGINE_TIN_HEAT_MAX, 10000, 400);
|
|
setHints(Config.hints.get("engine.tin"));
|
|
|
|
if (PluginManager.isModuleLoaded(PluginIC2.class))
|
|
ic2EnergySink = new BasicSink(this, euConfig.euStorage, 3);
|
|
}
|
|
|
|
@Override
|
|
public void openGui(EntityPlayer player, TileBase tile) {
|
|
player.openGui(ForestryAPI.instance, GuiId.EngineTinGUI.ordinal(), player.worldObj, xCoord, yCoord, zCoord);
|
|
}
|
|
|
|
// / SAVING / LOADING
|
|
@Override
|
|
public void readFromNBT(NBTTagCompound nbttagcompound) {
|
|
super.readFromNBT(nbttagcompound);
|
|
|
|
if (ic2EnergySink != null) ic2EnergySink.readFromNBT(nbttagcompound);
|
|
inventory.readFromNBT(nbttagcompound);
|
|
sockets.readFromNBT(nbttagcompound);
|
|
|
|
ItemStack chip = sockets.getStackInSlot(0);
|
|
if (chip != null) {
|
|
ICircuitBoard chipset = ChipsetManager.circuitRegistry.getCircuitboard(chip);
|
|
if (chipset != null)
|
|
chipset.onLoad(this);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void writeToNBT(NBTTagCompound nbttagcompound) {
|
|
super.writeToNBT(nbttagcompound);
|
|
|
|
if (ic2EnergySink != null) ic2EnergySink.writeToNBT(nbttagcompound);
|
|
inventory.writeToNBT(nbttagcompound);
|
|
sockets.writeToNBT(nbttagcompound);
|
|
}
|
|
|
|
@Override
|
|
public void onChunkUnload() {
|
|
if (ic2EnergySink != null) ic2EnergySink.onChunkUnload();
|
|
|
|
super.onChunkUnload();
|
|
}
|
|
|
|
@Override
|
|
public void invalidate() {
|
|
if (ic2EnergySink != null) ic2EnergySink.invalidate();
|
|
|
|
super.invalidate();
|
|
}
|
|
|
|
// / HEAT MANAGMENT
|
|
@Override
|
|
public int dissipateHeat() {
|
|
if (heat <= 0)
|
|
return 0;
|
|
|
|
int loss = 0;
|
|
|
|
if (!isBurning() || !isActivated())
|
|
loss += 1;
|
|
|
|
TemperatureState tempState = getTemperatureState();
|
|
if (tempState == TemperatureState.OVERHEATING || tempState == TemperatureState.OPERATING_TEMPERATURE)
|
|
loss += 1;
|
|
|
|
heat -= loss;
|
|
return loss;
|
|
}
|
|
|
|
@Override
|
|
public int generateHeat() {
|
|
|
|
int gain = 0;
|
|
if (isActivated() && isBurning()) {
|
|
gain++;
|
|
if (((double) storedEnergy / (double) maxEnergy) > 0.5)
|
|
gain++;
|
|
}
|
|
|
|
addHeat(gain);
|
|
return gain;
|
|
}
|
|
|
|
// / WORK
|
|
@Override
|
|
public void updateServerSide() {
|
|
// No work to be done if IC2 is unavailable.
|
|
if (ic2EnergySink == null) {
|
|
setErrorState(EnumErrorCode.NOENERGYNET);
|
|
return;
|
|
}
|
|
|
|
ic2EnergySink.updateEntity();
|
|
|
|
super.updateServerSide();
|
|
|
|
if (forceCooldown) {
|
|
setErrorState(EnumErrorCode.FORCEDCOOLDOWN);
|
|
return;
|
|
}
|
|
|
|
if (inventory.getStackInSlot(batterySlot) != null)
|
|
replenishFromBattery(batterySlot);
|
|
|
|
// Updating of gui delayed to prevent it from going crazy
|
|
if (!delayUpdateTimer.delayPassed(worldObj, 80))
|
|
return;
|
|
|
|
if (currentOutput <= 0 && getErrorState() == EnumErrorCode.OK)
|
|
setErrorState(EnumErrorCode.NOFUEL);
|
|
else
|
|
setErrorState(EnumErrorCode.OK);
|
|
}
|
|
|
|
@Override
|
|
public void burn() {
|
|
|
|
currentOutput = 0;
|
|
|
|
if (!isActivated())
|
|
return;
|
|
|
|
if (ic2EnergySink.useEnergy(euConfig.euForCycle)) {
|
|
currentOutput = euConfig.mjPerCycle;
|
|
addEnergy(euConfig.mjPerCycle);
|
|
}
|
|
|
|
}
|
|
|
|
private void replenishFromBattery(int slot) {
|
|
if (!isActivated())
|
|
return;
|
|
|
|
ic2EnergySink.discharge(inventory.getStackInSlot(slot), euConfig.euForCycle * 3);
|
|
}
|
|
|
|
// / STATE INFORMATION
|
|
@Override
|
|
public boolean isBurning() {
|
|
return mayBurn() && ic2EnergySink != null && ic2EnergySink.canUseEnergy(euConfig.euForCycle);
|
|
}
|
|
|
|
public int getStorageScaled(int i) {
|
|
if (ic2EnergySink == null) return 0;
|
|
|
|
return Math.min(i, (int) (ic2EnergySink.getEnergyStored() * i) / ic2EnergySink.getCapacity());
|
|
}
|
|
|
|
public EnumTankLevel rateLevel(int scaled) {
|
|
|
|
if (scaled < 5)
|
|
return EnumTankLevel.EMPTY;
|
|
else if (scaled < 30)
|
|
return EnumTankLevel.LOW;
|
|
else if (scaled < 60)
|
|
return EnumTankLevel.MEDIUM;
|
|
else if (scaled < 90)
|
|
return EnumTankLevel.HIGH;
|
|
else
|
|
return EnumTankLevel.MAXIMUM;
|
|
}
|
|
|
|
// / SMP GUI
|
|
@Override
|
|
public void getGUINetworkData(int i, int j) {
|
|
|
|
switch (i) {
|
|
|
|
case 0:
|
|
currentOutput = j;
|
|
break;
|
|
case 1:
|
|
storedEnergy = j;
|
|
break;
|
|
case 2:
|
|
heat = j;
|
|
break;
|
|
case 3:
|
|
if (ic2EnergySink != null) ic2EnergySink.setEnergyStored(j);
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
@Override
|
|
public void sendGUINetworkData(Container containerEngine, ICrafting iCrafting) {
|
|
iCrafting.sendProgressBarUpdate(containerEngine, 0, currentOutput);
|
|
iCrafting.sendProgressBarUpdate(containerEngine, 1, (int)storedEnergy);
|
|
iCrafting.sendProgressBarUpdate(containerEngine, 2, heat);
|
|
if (ic2EnergySink != null) {
|
|
iCrafting.sendProgressBarUpdate(containerEngine, 3, (short) ic2EnergySink.getEnergyStored());
|
|
}
|
|
}
|
|
|
|
// / ENERGY CONFIG CHANGE
|
|
public void changeEnergyConfig(int euChange, int mjChange, int storageChange) {
|
|
euConfig.euForCycle += euChange;
|
|
euConfig.mjPerCycle += mjChange;
|
|
euConfig.euStorage += storageChange;
|
|
|
|
if (ic2EnergySink != null) ic2EnergySink.setCapacity(euConfig.euStorage);
|
|
}
|
|
|
|
/* IINVENTORY */
|
|
@Override
|
|
public int getSizeInventory() {
|
|
return inventory.getSizeInventory();
|
|
}
|
|
|
|
@Override
|
|
public ItemStack getStackInSlot(int i) {
|
|
return inventory.getStackInSlot(i);
|
|
}
|
|
|
|
@Override
|
|
public ItemStack decrStackSize(int i, int j) {
|
|
return inventory.decrStackSize(i, j);
|
|
}
|
|
|
|
@Override
|
|
public void setInventorySlotContents(int i, ItemStack itemstack) {
|
|
inventory.setInventorySlotContents(i, itemstack);
|
|
}
|
|
|
|
@Override
|
|
public int getInventoryStackLimit() {
|
|
return inventory.getInventoryStackLimit();
|
|
}
|
|
|
|
@Override
|
|
public ItemStack getStackInSlotOnClosing(int slot) {
|
|
return inventory.getStackInSlotOnClosing(slot);
|
|
}
|
|
|
|
@Override
|
|
public void openInventory() {
|
|
}
|
|
|
|
@Override
|
|
public void closeInventory() {
|
|
}
|
|
|
|
/**
|
|
* TODO: just a specialsource workaround
|
|
*/
|
|
@Override
|
|
public boolean isUseableByPlayer(EntityPlayer player) {
|
|
return super.isUseableByPlayer(player);
|
|
}
|
|
|
|
@Override
|
|
public String getInventoryName() {
|
|
return getUnlocalizedName();
|
|
}
|
|
|
|
/**
|
|
* TODO: just a specialsource workaround
|
|
*/
|
|
@Override
|
|
public boolean hasCustomInventoryName() {
|
|
return super.hasCustomInventoryName();
|
|
}
|
|
|
|
/**
|
|
* TODO: just a specialsource workaround
|
|
*/
|
|
@Override
|
|
public boolean isItemValidForSlot(int slotIndex, ItemStack itemstack) {
|
|
return super.isItemValidForSlot(slotIndex, itemstack);
|
|
}
|
|
|
|
/* ISOCKETABLE */
|
|
@Override
|
|
public int getSocketCount() {
|
|
return sockets.getSizeInventory();
|
|
}
|
|
|
|
@Override
|
|
public ItemStack getSocket(int slot) {
|
|
return sockets.getStackInSlot(slot);
|
|
}
|
|
|
|
@Override
|
|
public void setSocket(int slot, ItemStack stack) {
|
|
|
|
if (stack != null && !ChipsetManager.circuitRegistry.isChipset(stack))
|
|
return;
|
|
|
|
// Dispose correctly of old chipsets
|
|
if (sockets.getStackInSlot(slot) != null)
|
|
if (ChipsetManager.circuitRegistry.isChipset(sockets.getStackInSlot(slot))) {
|
|
ICircuitBoard chipset = ChipsetManager.circuitRegistry.getCircuitboard(sockets.getStackInSlot(slot));
|
|
if (chipset != null)
|
|
chipset.onRemoval(this);
|
|
}
|
|
|
|
if (stack == null) {
|
|
sockets.setInventorySlotContents(slot, stack);
|
|
return;
|
|
}
|
|
|
|
sockets.setInventorySlotContents(slot, stack);
|
|
|
|
ICircuitBoard chipset = ChipsetManager.circuitRegistry.getCircuitboard(stack);
|
|
if (chipset != null)
|
|
chipset.onInsertion(this);
|
|
}
|
|
|
|
}
|