From 869c206c4fcc8001bd2e1d66f704290331813835 Mon Sep 17 00:00:00 2001 From: Draknyte1 Date: Wed, 20 Jan 2016 14:24:34 +1000 Subject: Initial Commit --- src/Java/binnie/core/machines/MachineUtil.java | 216 +++++++++++++++++++++++++ 1 file changed, 216 insertions(+) create mode 100644 src/Java/binnie/core/machines/MachineUtil.java (limited to 'src/Java/binnie/core/machines/MachineUtil.java') diff --git a/src/Java/binnie/core/machines/MachineUtil.java b/src/Java/binnie/core/machines/MachineUtil.java new file mode 100644 index 0000000000..97ff515061 --- /dev/null +++ b/src/Java/binnie/core/machines/MachineUtil.java @@ -0,0 +1,216 @@ +package binnie.core.machines; + +import binnie.core.BinnieCore; +import binnie.core.machines.inventory.IChargedSlots; +import binnie.core.machines.power.IPoweredMachine; +import binnie.core.machines.power.IProcess; +import binnie.core.machines.power.ITankMachine; +import binnie.core.machines.power.PowerInterface; +import binnie.core.machines.power.PowerSystem; +import binnie.core.proxy.BinnieProxy; +import binnie.core.util.ItemStackSet; +import java.util.ArrayList; +import java.util.List; +import java.util.Random; +import net.minecraft.inventory.IInventory; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.IFluidTank; + +public class MachineUtil +{ + private IMachine machine; + + public MachineUtil(IMachine machine) + { + this.machine = machine; + } + + public IInventory getInventory() + { + return (IInventory)this.machine.getInterface(IInventory.class); + } + + public ITankMachine getTankContainer() + { + return (ITankMachine)this.machine.getInterface(ITankMachine.class); + } + + public IPoweredMachine getPoweredMachine() + { + return (IPoweredMachine)this.machine.getInterface(IPoweredMachine.class); + } + + public boolean isSlotEmpty(int slot) + { + return getInventory().getStackInSlot(slot) == null; + } + + public IFluidTank getTank(int id) + { + return getTankContainer().getTanks()[id]; + } + + public boolean spaceInTank(int id, int amount) + { + IFluidTank tank = getTank(id); + int space = tank.getCapacity() - tank.getFluidAmount(); + return amount <= space; + } + + public ItemStack getStack(int slot) + { + return getInventory().getStackInSlot(slot); + } + + public void deleteStack(int slot) + { + setStack(slot, null); + } + + public ItemStack decreaseStack(int slotWood, int amount) + { + return getInventory().decrStackSize(slotWood, amount); + } + + public void setStack(int slot, ItemStack stack) + { + getInventory().setInventorySlotContents(slot, stack); + } + + public void fillTank(int id, FluidStack liquidStack) + { + IFluidTank tank = getTank(id); + tank.fill(liquidStack, true); + } + + public void addStack(int slot, ItemStack addition) + { + if (isSlotEmpty(slot)) + { + setStack(slot, addition); + } + else + { + ItemStack merge = getStack(slot); + if ((merge.isItemEqual(addition)) && (merge.stackSize + addition.stackSize <= merge.getMaxStackSize())) + { + merge.stackSize += addition.stackSize; + setStack(slot, merge); + } + } + } + + public FluidStack drainTank(int tank, int amount) + { + return getTank(tank).drain(amount, true); + } + + public boolean liquidInTank(int tank, int amount) + { + return (getTank(tank).drain(amount, false) != null) && (getTank(tank).drain(amount, false).amount == amount); + } + + public void damageItem(int slot, int damage) + { + ItemStack item = getStack(slot); + if (damage < 0) { + item.setItemDamage(Math.max(0, item.getItemDamage() + damage)); + } else if (item.attemptDamageItem(damage, new Random())) { + setStack(slot, null); + } + setStack(slot, item); + } + + public boolean isTankEmpty(int tankInput) + { + return getTank(tankInput).getFluidAmount() == 0; + } + + public FluidStack getFluid(int tankInput) + { + return getTank(tankInput).getFluid() == null ? null : getTank(tankInput).getFluid(); + } + + public ItemStack[] getStacks(int[] slotGrains) + { + ItemStack[] stacks = new ItemStack[slotGrains.length]; + for (int i = 0; i < slotGrains.length; i++) { + stacks[i] = getStack(slotGrains[i]); + } + return stacks; + } + + public ItemStack hasIngredients(int recipe, int[] inventory) + { + return null; + } + + public boolean hasIngredients(int[] recipe, int[] inventory) + { + ItemStackSet requiredStacks = new ItemStackSet(); + for (ItemStack stack : getStacks(recipe)) { + requiredStacks.add(stack); + } + ItemStackSet inventoryStacks = new ItemStackSet(); + for (ItemStack stack : getStacks(inventory)) { + inventoryStacks.add(stack); + } + requiredStacks.removeAll(inventoryStacks); + + return requiredStacks.isEmpty(); + } + + public void useEnergyMJ(float powerUsage) + { + getPoweredMachine().getInterface().useEnergy(PowerSystem.MJ, powerUsage, true); + } + + public boolean hasEnergyMJ(float powerUsage) + { + return getPoweredMachine().getInterface().useEnergy(PowerSystem.MJ, powerUsage, false) >= powerUsage; + } + + public float getSlotCharge(int slot) + { + return ((IChargedSlots)this.machine.getInterface(IChargedSlots.class)).getCharge(slot); + } + + public void useCharge(int slot, float loss) + { + ((IChargedSlots)this.machine.getInterface(IChargedSlots.class)).alterCharge(slot, -loss); + } + + public Random getRandom() + { + return new Random(); + } + + public void refreshBlock() + { + this.machine.getWorld().markBlockForUpdate(this.machine.getTileEntity().xCoord, this.machine.getTileEntity().yCoord, this.machine.getTileEntity().zCoord); + } + + public IProcess getProcess() + { + return (IProcess)this.machine.getInterface(IProcess.class); + } + + public List getNonNullStacks(int[] slotacclimatiser) + { + List stacks = new ArrayList(); + for (ItemStack stack : getStacks(slotacclimatiser)) { + if (stack != null) { + stacks.add(stack); + } + } + return stacks; + } + + public boolean isServer() + { + return BinnieCore.proxy.isSimulating(this.machine.getWorld()); + } +} -- cgit