2012-10-02 20:39:40 +02:00
|
|
|
package net.uberkat.obsidian.common;
|
|
|
|
|
2012-10-24 22:13:24 +02:00
|
|
|
import java.io.ByteArrayOutputStream;
|
|
|
|
import java.io.DataOutputStream;
|
|
|
|
import java.io.IOException;
|
2012-10-02 20:39:40 +02:00
|
|
|
import java.util.List;
|
|
|
|
|
2012-10-14 03:48:29 +02:00
|
|
|
import obsidian.api.IEnergizedItem;
|
|
|
|
|
2012-10-25 23:55:32 +02:00
|
|
|
import universalelectricity.core.UniversalElectricity;
|
2012-10-24 03:16:16 +02:00
|
|
|
import universalelectricity.electricity.ElectricInfo;
|
2012-10-02 20:39:40 +02:00
|
|
|
import universalelectricity.implement.IItemElectric;
|
|
|
|
|
2012-10-24 22:13:24 +02:00
|
|
|
import buildcraft.api.power.IPowerProvider;
|
|
|
|
import buildcraft.api.power.PowerFramework;
|
|
|
|
|
2012-10-02 20:39:40 +02:00
|
|
|
import com.google.common.io.ByteArrayDataInput;
|
|
|
|
|
2012-10-09 22:27:10 +02:00
|
|
|
import dan200.computer.api.IComputerAccess;
|
|
|
|
|
2012-10-02 20:39:40 +02:00
|
|
|
import ic2.api.ElectricItem;
|
|
|
|
import ic2.api.EnergyNet;
|
|
|
|
import ic2.api.IElectricItem;
|
|
|
|
import ic2.api.IWrenchable;
|
|
|
|
import net.minecraft.src.*;
|
|
|
|
import net.minecraftforge.common.ForgeDirection;
|
|
|
|
import net.minecraftforge.common.ISidedInventory;
|
|
|
|
|
|
|
|
public abstract class TileEntityAdvancedElectricMachine extends TileEntityBasicMachine
|
|
|
|
{
|
|
|
|
/** How much secondary energy (fuel) this machine uses per tick. */
|
|
|
|
public int SECONDARY_ENERGY_PER_TICK;
|
|
|
|
|
|
|
|
/** Maximum amount of secondary energy (fuel) this machine can hold. */
|
|
|
|
public int MAX_SECONDARY_ENERGY;
|
|
|
|
|
|
|
|
/** How much secondary energy (fuel) is stored in this machine. */
|
|
|
|
public int secondaryEnergyStored = 0;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Advanced Electric Machine -- a machine like this has a total of 4 slots. Input slot (0), fuel slot (1), output slot (2),
|
2012-10-22 03:29:26 +02:00
|
|
|
* energy slot (3), and the upgrade slot (4). The machine will not run if it does not have enough electricity, or if it doesn't have enough
|
2012-10-02 20:39:40 +02:00
|
|
|
* fuel ticks.
|
|
|
|
*
|
2012-10-22 03:29:26 +02:00
|
|
|
* @param soundPath - location of the sound effect
|
2012-10-17 20:46:27 +02:00
|
|
|
* @param name - full name of this machine
|
|
|
|
* @param path - GUI texture path of this machine
|
2012-10-02 20:39:40 +02:00
|
|
|
* @param perTick - how much energy this machine uses per tick.
|
|
|
|
* @param secondaryPerTick - how much secondary energy (fuel) this machine uses per tick.
|
|
|
|
* @param ticksRequired - how many ticks it takes to smelt an item.
|
|
|
|
* @param maxEnergy - maximum amount of energy this machine can hold.
|
|
|
|
* @param maxSecondaryEnergy - maximum amount of secondary energy (fuel) this machine can hold.
|
|
|
|
*/
|
2012-10-22 03:29:26 +02:00
|
|
|
public TileEntityAdvancedElectricMachine(String soundPath, String name, String path, int perTick, int secondaryPerTick, int ticksRequired, int maxEnergy, int maxSecondaryEnergy)
|
2012-10-02 20:39:40 +02:00
|
|
|
{
|
2012-10-24 22:13:24 +02:00
|
|
|
super(soundPath, name, path, perTick, ticksRequired, maxEnergy);
|
|
|
|
inventory = new ItemStack[5];
|
2012-10-02 20:39:40 +02:00
|
|
|
SECONDARY_ENERGY_PER_TICK = secondaryPerTick;
|
|
|
|
MAX_SECONDARY_ENERGY = maxSecondaryEnergy;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Gets the amount of ticks the declared itemstack can fuel this machine.
|
|
|
|
* @param itemstack - itemstack to check with
|
|
|
|
* @return fuel ticks
|
|
|
|
*/
|
|
|
|
public abstract int getFuelTicks(ItemStack itemstack);
|
|
|
|
|
|
|
|
public void onUpdate()
|
|
|
|
{
|
|
|
|
boolean testActive = operatingTicks > 0;
|
|
|
|
|
|
|
|
if(inventory[3] != null)
|
|
|
|
{
|
2012-10-23 15:23:23 +02:00
|
|
|
if(energyStored < currentMaxEnergy)
|
2012-10-02 20:39:40 +02:00
|
|
|
{
|
|
|
|
if(inventory[3].getItem() instanceof IEnergizedItem)
|
|
|
|
{
|
|
|
|
int received = 0;
|
2012-10-23 15:23:23 +02:00
|
|
|
int energyNeeded = currentMaxEnergy - energyStored;
|
2012-10-02 20:39:40 +02:00
|
|
|
IEnergizedItem item = (IEnergizedItem)inventory[3].getItem();
|
|
|
|
if(item.getRate() <= energyNeeded)
|
|
|
|
{
|
|
|
|
received = item.discharge(inventory[3], item.getRate());
|
|
|
|
}
|
|
|
|
else if(item.getRate() > energyNeeded)
|
|
|
|
{
|
|
|
|
item.setEnergy(inventory[3], (item.getEnergy(inventory[3]) - energyNeeded));
|
|
|
|
received = energyNeeded;
|
|
|
|
}
|
|
|
|
|
|
|
|
setEnergy(energyStored + received);
|
|
|
|
}
|
|
|
|
else if(inventory[3].getItem() instanceof IItemElectric)
|
|
|
|
{
|
2012-10-25 23:55:32 +02:00
|
|
|
IItemElectric electricItem = (IItemElectric)inventory[3].getItem();
|
2012-10-24 03:16:16 +02:00
|
|
|
|
2012-10-24 22:13:24 +02:00
|
|
|
if (electricItem.canProduceElectricity())
|
|
|
|
{
|
|
|
|
double joulesReceived = electricItem.onUse(electricItem.getMaxJoules() * 0.005, inventory[3]);
|
|
|
|
setEnergy(energyStored + (int)(joulesReceived*UniversalElectricity.TO_IC2_RATIO));
|
|
|
|
}
|
2012-10-02 20:39:40 +02:00
|
|
|
}
|
|
|
|
else if(inventory[3].getItem() instanceof IElectricItem)
|
|
|
|
{
|
|
|
|
IElectricItem item = (IElectricItem)inventory[3].getItem();
|
|
|
|
if(item.canProvideEnergy())
|
|
|
|
{
|
2012-10-24 03:16:16 +02:00
|
|
|
int gain = ElectricItem.discharge(inventory[3], currentMaxEnergy - energyStored, 3, false, false);
|
2012-10-02 20:39:40 +02:00
|
|
|
setEnergy(energyStored + gain);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if(inventory[3].itemID == Item.redstone.shiftedIndex && energyStored <= (MAX_ENERGY-1000))
|
|
|
|
{
|
|
|
|
setEnergy(energyStored + 1000);
|
|
|
|
--inventory[3].stackSize;
|
|
|
|
|
|
|
|
if (inventory[3].stackSize <= 0)
|
|
|
|
{
|
|
|
|
inventory[3] = null;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-09 22:27:10 +02:00
|
|
|
if(inventory[1] != null && secondaryEnergyStored == 0)
|
2012-10-02 20:39:40 +02:00
|
|
|
{
|
|
|
|
int fuelTicks = getFuelTicks(inventory[1]);
|
|
|
|
if(fuelTicks > 0)
|
|
|
|
{
|
|
|
|
int energyNeeded = MAX_SECONDARY_ENERGY - secondaryEnergyStored;
|
|
|
|
if(fuelTicks <= energyNeeded)
|
|
|
|
{
|
|
|
|
setSecondaryEnergy(secondaryEnergyStored + fuelTicks);
|
|
|
|
}
|
|
|
|
else if(fuelTicks > energyNeeded)
|
|
|
|
{
|
|
|
|
setSecondaryEnergy(secondaryEnergyStored + energyNeeded);
|
|
|
|
}
|
|
|
|
--inventory[1].stackSize;
|
|
|
|
|
|
|
|
if(inventory[1].stackSize == 0)
|
|
|
|
{
|
|
|
|
inventory[1] = null;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-22 03:29:26 +02:00
|
|
|
if(inventory[4] != null)
|
|
|
|
{
|
|
|
|
int energyToAdd = 0;
|
|
|
|
int ticksToRemove = 0;
|
|
|
|
|
|
|
|
if(inventory[4].isItemEqual(new ItemStack(ObsidianIngots.SpeedUpgrade)))
|
|
|
|
{
|
|
|
|
if(currentTicksRequired == TICKS_REQUIRED)
|
|
|
|
{
|
|
|
|
ticksToRemove = 150;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if(inventory[4].isItemEqual(new ItemStack(ObsidianIngots.EnergyUpgrade)))
|
|
|
|
{
|
|
|
|
if(currentMaxEnergy == MAX_ENERGY)
|
|
|
|
{
|
|
|
|
energyToAdd = 600;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if(inventory[4].isItemEqual(new ItemStack(ObsidianIngots.UltimateUpgrade)))
|
|
|
|
{
|
|
|
|
if(currentTicksRequired == TICKS_REQUIRED)
|
|
|
|
{
|
|
|
|
ticksToRemove = 150;
|
|
|
|
}
|
|
|
|
if(currentMaxEnergy == MAX_ENERGY)
|
|
|
|
{
|
|
|
|
energyToAdd = 600;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
currentMaxEnergy += energyToAdd;
|
|
|
|
currentTicksRequired -= ticksToRemove;
|
|
|
|
}
|
|
|
|
else if(inventory[4] == null)
|
|
|
|
{
|
|
|
|
currentTicksRequired = TICKS_REQUIRED;
|
|
|
|
currentMaxEnergy = MAX_ENERGY;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(canOperate() && (operatingTicks+1) < currentTicksRequired && secondaryEnergyStored >= SECONDARY_ENERGY_PER_TICK)
|
2012-10-02 20:39:40 +02:00
|
|
|
{
|
|
|
|
++operatingTicks;
|
|
|
|
secondaryEnergyStored -= SECONDARY_ENERGY_PER_TICK;
|
|
|
|
energyStored -= ENERGY_PER_TICK;
|
|
|
|
}
|
2012-10-22 03:29:26 +02:00
|
|
|
else if((operatingTicks+1) >= currentTicksRequired)
|
2012-10-02 20:39:40 +02:00
|
|
|
{
|
|
|
|
if(!worldObj.isRemote)
|
|
|
|
{
|
|
|
|
operate();
|
|
|
|
}
|
|
|
|
operatingTicks = 0;
|
|
|
|
secondaryEnergyStored -= SECONDARY_ENERGY_PER_TICK;
|
|
|
|
energyStored -= ENERGY_PER_TICK;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(energyStored < 0)
|
|
|
|
{
|
|
|
|
energyStored = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(secondaryEnergyStored < 0)
|
|
|
|
{
|
|
|
|
secondaryEnergyStored = 0;
|
|
|
|
}
|
|
|
|
|
2012-10-22 03:29:26 +02:00
|
|
|
if(energyStored > currentMaxEnergy)
|
2012-10-02 20:39:40 +02:00
|
|
|
{
|
2012-10-22 03:29:26 +02:00
|
|
|
energyStored = currentMaxEnergy;
|
2012-10-02 20:39:40 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if(secondaryEnergyStored > MAX_SECONDARY_ENERGY)
|
|
|
|
{
|
|
|
|
secondaryEnergyStored = MAX_SECONDARY_ENERGY;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!canOperate())
|
|
|
|
{
|
|
|
|
operatingTicks = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!worldObj.isRemote)
|
|
|
|
{
|
|
|
|
if(testActive != operatingTicks > 0)
|
|
|
|
{
|
|
|
|
if(operatingTicks > 0)
|
|
|
|
{
|
|
|
|
setActive(true);
|
|
|
|
}
|
|
|
|
else if(!canOperate())
|
|
|
|
{
|
|
|
|
setActive(false);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void operate()
|
|
|
|
{
|
|
|
|
if (!canOperate())
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
ItemStack itemstack;
|
|
|
|
|
|
|
|
if (inventory[0].getItem().hasContainerItem())
|
|
|
|
{
|
|
|
|
itemstack = RecipeHandler.getOutput(inventory[0], false, getRecipes()).copy();
|
|
|
|
inventory[0] = new ItemStack(inventory[0].getItem().getContainerItem());
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
itemstack = RecipeHandler.getOutput(inventory[0], true, getRecipes()).copy();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (inventory[0].stackSize <= 0)
|
|
|
|
{
|
|
|
|
inventory[0] = null;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (inventory[2] == null)
|
|
|
|
{
|
|
|
|
inventory[2] = itemstack;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
inventory[2].stackSize += itemstack.stackSize;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public boolean canOperate()
|
|
|
|
{
|
|
|
|
if (inventory[0] == null)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(energyStored < ENERGY_PER_TICK)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
2012-10-09 22:27:10 +02:00
|
|
|
|
|
|
|
if(secondaryEnergyStored < SECONDARY_ENERGY_PER_TICK)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
2012-10-02 20:39:40 +02:00
|
|
|
|
|
|
|
ItemStack itemstack = RecipeHandler.getOutput(inventory[0], false, getRecipes());
|
|
|
|
|
|
|
|
if (itemstack == null)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (inventory[2] == null)
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!inventory[2].isItemEqual(itemstack))
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
return inventory[2].stackSize + itemstack.stackSize <= inventory[2].getMaxStackSize();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void sendPacket()
|
|
|
|
{
|
|
|
|
PacketHandler.sendAdvancedElectricMachinePacket(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
public void sendPacketWithRange()
|
|
|
|
{
|
|
|
|
PacketHandler.sendAdvancedElectricMachinePacketWithRange(this, 50);
|
|
|
|
}
|
|
|
|
|
2012-10-25 23:55:32 +02:00
|
|
|
public void handlePacketData(INetworkManager network, Packet250CustomPayload packet, EntityPlayer player, ByteArrayDataInput dataStream)
|
2012-10-02 20:39:40 +02:00
|
|
|
{
|
|
|
|
try {
|
|
|
|
facing = dataStream.readInt();
|
|
|
|
isActive = dataStream.readByte() != 0;
|
|
|
|
operatingTicks = dataStream.readInt();
|
|
|
|
energyStored = dataStream.readInt();
|
|
|
|
secondaryEnergyStored = dataStream.readInt();
|
2012-10-22 03:29:26 +02:00
|
|
|
currentMaxEnergy = dataStream.readInt();
|
|
|
|
currentTicksRequired = dataStream.readInt();
|
2012-10-02 20:39:40 +02:00
|
|
|
worldObj.markBlockAsNeedsUpdate(xCoord, yCoord, zCoord);
|
|
|
|
} catch (Exception e)
|
|
|
|
{
|
|
|
|
System.out.println("[ObsidianIngots] Error while handling tile entity packet.");
|
|
|
|
e.printStackTrace();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-17 20:46:27 +02:00
|
|
|
public void readFromNBT(NBTTagCompound nbtTags)
|
2012-10-02 20:39:40 +02:00
|
|
|
{
|
2012-10-17 20:46:27 +02:00
|
|
|
super.readFromNBT(nbtTags);
|
2012-10-24 22:13:24 +02:00
|
|
|
|
|
|
|
if(PowerFramework.currentFramework != null)
|
|
|
|
{
|
|
|
|
PowerFramework.currentFramework.loadPowerProvider(this, nbtTags);
|
|
|
|
}
|
|
|
|
|
2012-10-17 20:46:27 +02:00
|
|
|
NBTTagList tagList = nbtTags.getTagList("Items");
|
2012-10-02 20:39:40 +02:00
|
|
|
inventory = new ItemStack[getSizeInventory()];
|
|
|
|
|
2012-10-17 20:46:27 +02:00
|
|
|
for (int slots = 0; slots < tagList.tagCount(); ++slots)
|
2012-10-02 20:39:40 +02:00
|
|
|
{
|
2012-10-17 20:46:27 +02:00
|
|
|
NBTTagCompound tagCompound = (NBTTagCompound)tagList.tagAt(slots);
|
|
|
|
byte slotID = tagCompound.getByte("Slot");
|
2012-10-02 20:39:40 +02:00
|
|
|
|
2012-10-17 20:46:27 +02:00
|
|
|
if (slotID >= 0 && slotID < inventory.length)
|
2012-10-02 20:39:40 +02:00
|
|
|
{
|
2012-10-17 20:46:27 +02:00
|
|
|
inventory[slotID] = ItemStack.loadItemStackFromNBT(tagCompound);
|
2012-10-02 20:39:40 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-17 20:46:27 +02:00
|
|
|
operatingTicks = nbtTags.getInteger("operatingTicks");
|
|
|
|
energyStored = nbtTags.getInteger("energyStored");
|
|
|
|
secondaryEnergyStored = nbtTags.getInteger("secondaryEnergyStored");
|
|
|
|
prevActive = isActive = nbtTags.getBoolean("isActive");
|
|
|
|
facing = nbtTags.getInteger("facing");
|
2012-10-02 20:39:40 +02:00
|
|
|
}
|
|
|
|
|
2012-10-17 20:46:27 +02:00
|
|
|
public void writeToNBT(NBTTagCompound nbtTags)
|
2012-10-02 20:39:40 +02:00
|
|
|
{
|
2012-10-17 20:46:27 +02:00
|
|
|
super.writeToNBT(nbtTags);
|
2012-10-24 22:13:24 +02:00
|
|
|
|
|
|
|
if(PowerFramework.currentFramework != null)
|
|
|
|
{
|
|
|
|
PowerFramework.currentFramework.savePowerProvider(this, nbtTags);
|
|
|
|
}
|
|
|
|
|
2012-10-17 20:46:27 +02:00
|
|
|
nbtTags.setInteger("operatingTicks", operatingTicks);
|
|
|
|
nbtTags.setInteger("energyStored", energyStored);
|
|
|
|
nbtTags.setInteger("secondaryEnergyStored", secondaryEnergyStored);
|
|
|
|
nbtTags.setBoolean("isActive", isActive);
|
|
|
|
nbtTags.setInteger("facing", facing);
|
|
|
|
NBTTagList tagList = new NBTTagList();
|
|
|
|
|
|
|
|
for (int slots = 0; slots < inventory.length; ++slots)
|
2012-10-02 20:39:40 +02:00
|
|
|
{
|
2012-10-17 20:46:27 +02:00
|
|
|
if (inventory[slots] != null)
|
2012-10-02 20:39:40 +02:00
|
|
|
{
|
2012-10-17 20:46:27 +02:00
|
|
|
NBTTagCompound tagCompound = new NBTTagCompound();
|
|
|
|
tagCompound.setByte("Slot", (byte)slots);
|
|
|
|
inventory[slots].writeToNBT(tagCompound);
|
|
|
|
tagList.appendTag(tagCompound);
|
2012-10-02 20:39:40 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-17 20:46:27 +02:00
|
|
|
nbtTags.setTag("Items", tagList);
|
2012-10-02 20:39:40 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Sets the secondary energy to a new amount
|
|
|
|
* @param energy - amount to store
|
|
|
|
*/
|
|
|
|
public void setSecondaryEnergy(int energy)
|
|
|
|
{
|
|
|
|
secondaryEnergyStored = Math.max(Math.min(energy, getFuelTicks(inventory[1])), 0);
|
|
|
|
}
|
2012-10-23 15:23:23 +02:00
|
|
|
|
2012-10-28 23:18:23 +01:00
|
|
|
/**
|
|
|
|
* Gets the scaled secondary energy level for the GUI.
|
|
|
|
* @param i - multiplier
|
|
|
|
* @return scaled secondary energy
|
|
|
|
*/
|
2012-10-23 15:23:23 +02:00
|
|
|
public int getScaledSecondaryEnergyLevel(int i)
|
2012-10-02 20:39:40 +02:00
|
|
|
{
|
|
|
|
return secondaryEnergyStored*i / MAX_SECONDARY_ENERGY;
|
|
|
|
}
|
2012-10-09 22:27:10 +02:00
|
|
|
|
|
|
|
public String[] getMethodNames()
|
|
|
|
{
|
2012-10-25 23:55:32 +02:00
|
|
|
return new String[] {"getStored", "getSecondaryStored", "getProgress", "isActive", "facing", "canOperate", "getMaxEnergy", "getEnergyNeeded"};
|
2012-10-09 22:27:10 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
public Object[] callMethod(IComputerAccess computer, int method, Object[] arguments) throws Exception
|
|
|
|
{
|
|
|
|
switch(method)
|
|
|
|
{
|
|
|
|
case 0:
|
|
|
|
return new Object[] {energyStored};
|
|
|
|
case 1:
|
|
|
|
return new Object[] {secondaryEnergyStored};
|
|
|
|
case 2:
|
|
|
|
return new Object[] {operatingTicks};
|
|
|
|
case 3:
|
|
|
|
return new Object[] {isActive};
|
|
|
|
case 4:
|
|
|
|
return new Object[] {facing};
|
|
|
|
case 5:
|
|
|
|
return new Object[] {canOperate()};
|
2012-10-25 23:55:32 +02:00
|
|
|
case 6:
|
|
|
|
return new Object[] {currentMaxEnergy};
|
|
|
|
case 7:
|
|
|
|
return new Object[] {(currentMaxEnergy-energyStored)};
|
2012-10-09 22:27:10 +02:00
|
|
|
default:
|
|
|
|
System.err.println("[ObsidianIngots] Attempted to call unknown method with computer ID " + computer.getID());
|
2012-10-25 23:55:32 +02:00
|
|
|
return new Object[] {"Unknown command."};
|
2012-10-09 22:27:10 +02:00
|
|
|
}
|
|
|
|
}
|
2012-10-02 20:39:40 +02:00
|
|
|
}
|