@Override public void updateEntity() { super.updateEntity(); boolean powered = getWorldObj().getStrongestIndirectPower(xCoord, yCoord, zCoord) > 0; if (!powered && _steamTank.getFluid() != null && _steamTank.getFluid().getFluid() != null && _steamTank.getFluid().getFluid().getName() != null) { String fluidName = _steamTank.getFluid().getFluid().getName(); PowerSteam.SteamType steamType = powerSteam.getSteamType(fluidName); if (steamType != null && _steamTank.getFluidAmount() > 0) { lastSubtype = powerSteam.getSteamSubtype(steamType); int amount = Math.min(_steamTank.getFluidAmount(), powerSteam.getThrottleConsumer()); float energy = amount * steamType.energyPerInput; energy = (int) storeEnergy(energy, false); int toDrain; try { toDrain = (int) (amount - (energy / powerSteam.getInternalEnergyPerInput(this.blockMetadata))); } catch (ArithmeticException e) { toDrain = 0; } _steamTank.drain(toDrain, true); _mBLastTick = toDrain; } else { _mBLastTick = 0; } } else { _mBLastTick = 0; } }
@Override public int fill(ForgeDirection from, FluidStack resource, boolean doFill) { if (!formed) return 0; if (master() != null) { if (pos != 15 && pos != 19) return 0; return master().fill(from, resource, doFill); } else if (resource != null) { int fill = 0; if (resource.isFluidEqual(tank0.getFluid())) fill = tank0.fill(resource, doFill); else if (resource.isFluidEqual(tank1.getFluid())) fill = tank1.fill(resource, doFill); else if (tank0.getFluidAmount() <= 0 && tank1.getFluidAmount() <= 0) fill = (DieselHandler.findIncompleteRefineryRecipe(resource, null) != null ? tank0.fill(resource, doFill) : 0); else { if (tank0.getFluidAmount() > 0) fill = (DieselHandler.findIncompleteRefineryRecipe(resource, tank0.getFluid()) != null ? tank1.fill(resource, doFill) : 0); else if (tank1.getFluidAmount() > 0) fill = (DieselHandler.findIncompleteRefineryRecipe(resource, tank1.getFluid()) != null ? tank0.fill(resource, doFill) : 0); } markDirty(); worldObj.markBlockForUpdate(xCoord, yCoord, zCoord); return fill; } return 0; }
@Override public void updateEntity() { if (pos == 4 && !worldObj.isRemote && worldObj.isBlockIndirectlyGettingPowered(xCoord, yCoord, zCoord)) for (int i = 0; i < 6; i++) if (i != 1 && tank.getFluidAmount() > 0) { ForgeDirection f = ForgeDirection.getOrientation(i); int out = Math.min(144, tank.getFluidAmount()); TileEntity te = this.worldObj.getTileEntity( xCoord + (i == 4 ? -1 : i == 5 ? 1 : 0), yCoord + (i == 0 ? -1 : 0), zCoord + (i == 2 ? -1 : i == 3 ? 1 : 0)); if (te != null && te instanceof IFluidHandler && ((IFluidHandler) te).canFill(f.getOpposite(), tank.getFluid().getFluid())) { updateComparatorValuesPart1(); int accepted = ((IFluidHandler) te) .fill(f.getOpposite(), new FluidStack(tank.getFluid().getFluid(), out), false); FluidStack drained = this.tank.drain(accepted, true); ((IFluidHandler) te).fill(f.getOpposite(), drained, true); updateComparatorValuesPart2(); } } }
@Override public boolean isItemValidForSlot(int slot, ItemStack stack) { if (!formed) return false; if (master() != null) return master().isItemValidForSlot(slot, stack); if (slot == 1 || slot == 3 || slot == 5) return false; if (slot == 4) return (tank2.getFluidAmount() <= 0 ? FluidContainerRegistry.isEmptyContainer(stack) : FluidContainerRegistry.fillFluidContainer( tank2.getFluid(), Utils.copyStackWithAmount(stack, 1)) != null); FluidStack fs = FluidContainerRegistry.getFluidForFilledItem(stack); if (fs == null) return false; RefineryRecipe partialRecipe = DieselHandler.findIncompleteRefineryRecipe(fs, null); if (partialRecipe == null) return false; if (slot == 0) return (tank0.getFluidAmount() <= 0 || fs.isFluidEqual(tank0.getFluid())) && (tank1.getFluidAmount() <= 0 || DieselHandler.findIncompleteRefineryRecipe(fs, tank1.getFluid()) != null); if (slot == 2) return (tank1.getFluidAmount() <= 0 || fs.isFluidEqual(tank1.getFluid())) && (tank0.getFluidAmount() <= 0 || DieselHandler.findIncompleteRefineryRecipe(fs, tank0.getFluid()) != null); return false; }
private void updateComparatorValuesPart1() { oldComps = new int[4]; int vol = tank.getCapacity() / 4; for (int i = 0; i < 4; i++) { int filled = tank.getFluidAmount() - i * vol; oldComps[i] = Math.min(15, Math.max((15 * filled) / vol, 0)); } masterCompOld = (15 * tank.getFluidAmount()) / tank.getCapacity(); }
/* Fluid Management */ @Override public boolean canFill(EnumFacing from, Fluid fluid) { // can only fill if no output in the inventory if (isStackInSlot(1)) { return false; } // can only fill if same fluid or empty and recipe present if (tank.getFluidAmount() > 0) { // if we have a fluid we also have a recipe return tank.getFluid().getFluid() == fluid && tank.getFluidAmount() < tank.getCapacity(); } return findRecipe(fluid) != null; }
public int getComparatorOutput() { if (pos == 4) { return (15 * tank.getFluidAmount()) / tank.getCapacity(); } if (offset[1] >= 1 && offset[1] <= 4 && master() != null) { // 4 layers of storage FluidTank t = master().tank; int layer = offset[1] - 1; int vol = t.getCapacity() / 4; int filled = t.getFluidAmount() - layer * vol; int ret = Math.min(15, Math.max(0, (15 * filled) / vol)); return ret; } return 0; }
public ItemStack getFilledItem(ItemStack empty, boolean drainTank) { if (empty == null || tank.getFluid() == null) return null; BottlingMachineRecipe recipe = BottlingMachineRecipe.findRecipe(empty, tank.getFluid()); if (recipe != null && recipe.output != null) { if (drainTank) tank.drain(recipe.fluidInput.amount, true); return recipe.output; } ItemStack filled = FluidContainerRegistry.fillFluidContainer( new FluidStack(tank.getFluid(), Integer.MAX_VALUE), empty); FluidStack fs = FluidContainerRegistry.getFluidForFilledItem(filled); if (filled != null && fs.amount <= tank.getFluidAmount()) { if (drainTank) tank.drain(fs.amount, true); return filled; } if (empty.getItem() instanceof IFluidContainerItem) { int accepted = ((IFluidContainerItem) empty.getItem()).fill(empty, tank.getFluid(), false); if (accepted > 0) { filled = empty.copy(); ((IFluidContainerItem) filled.getItem()) .fill(filled, new FluidStack(tank.getFluid(), accepted), true); if (drainTank) tank.drain(accepted, true); return filled; } } return null; }
public void pushFluidOut() { int tanks = 0; boolean[] sides = new boolean[ForgeDirection.VALID_DIRECTIONS.length]; for (int i = 0; i < sides.length; i++) { ForgeDirection side = ForgeDirection.VALID_DIRECTIONS[i]; TileEntity tile = worldObj.getTileEntity( xCoord + side.offsetX, yCoord + side.offsetY, zCoord + side.offsetZ); if (tile != null && tile instanceof IFluidHandler) { tanks++; sides[i] = true; } } int amountPerSide = lava.getFluidAmount(); for (int i = 0; i < sides.length; i++) { if (sides[i]) { ForgeDirection side = ForgeDirection.getOrientation(i); TileEntity tile = worldObj.getTileEntity( xCoord + side.offsetX, yCoord + side.offsetY, zCoord + side.offsetZ); if (tile != null && tile instanceof IFluidHandler && !(tile instanceof Heater) && !(tile instanceof Melter)) { IFluidHandler fluid = (IFluidHandler) tile; if (fluid.fill(side.getOpposite(), lava.drain(amountPerSide, false), false) == amountPerSide) { amountPerSide -= fluid.fill(side.getOpposite(), lava.drain(amountPerSide, true), true); } } } } }
@Override public void update() { // no recipeeeh if (recipe == null) { return; } // fully filled if (tank.getFluidAmount() == tank.getCapacity()) { timer++; if (timer >= recipe.getTime()) { TinkerCastingEvent.OnCasted event = TinkerCastingEvent.OnCasted.fire(recipe, this); // done, finish! if (event.consumeCast) { setInventorySlotContents(0, null); } // put result into output if (event.switchOutputs) { setInventorySlotContents(1, getStackInSlot(0)); setInventorySlotContents(0, event.output); } else { setInventorySlotContents(1, event.output); } // reset state reset(); } } }
public void interact(EntityPlayer player) { // can't interact if liquid inside if (tank.getFluidAmount() > 0) { return; } // completely empty -> insert current item into input if (!isStackInSlot(0) && !isStackInSlot(1)) { ItemStack stack = player.inventory.decrStackSize(player.inventory.currentItem, stackSizeLimit); setInventorySlotContents(0, stack); } // take item out else { // take out of stack 1 if something is in there, 0 otherwise int slot = isStackInSlot(1) ? 1 : 0; // Additional Info: Only 1 item can only be put into the casting block usually, however // recipes // can have Itemstacks with stacksize > 1 as output // we therefore spill the whole contents on extraction ItemStack stack = getStackInSlot(slot); if (slot == 1) { FMLCommonHandler.instance().firePlayerSmeltedEvent(player, stack); } PlayerHelper.spawnItemAtPlayer(player, stack); setInventorySlotContents(slot, null); } }
@Override public void updateEntity() { super.updateEntity(); if (!worldObj.isRemote) { if (tank.getFluidAmount() >= 0 && !(tank.getFluidAmount() == prevAmount)) { prevAmount = tank.getFluidAmount(); markDirty(); } if (initPer >= 0 && tank.getFluid() != null) { initPer--; if (initPer <= 0) { markDirty(); } } } }
public static ItemStack fillFluidContainer(FluidTank tank, ItemStack containerIn) { if (tank.getFluidAmount() > 0) if (FluidContainerRegistry.isEmptyContainer(containerIn)) { ItemStack filledContainer = FluidContainerRegistry.fillFluidContainer(tank.getFluid(), containerIn); if (filledContainer != null) { FluidStack fs = FluidContainerRegistry.getFluidForFilledItem(filledContainer); if (fs.amount <= tank.getFluidAmount()) { tank.drain(fs.amount, true); return filledContainer; } } } return null; }
// called only clientside to sync with the server @SideOnly(Side.CLIENT) public void updateFluidTo(FluidStack fluid) { int oldAmount = tank.getFluidAmount(); tank.setFluid(fluid); if (fluid == null) { tank.setCapacity(0); recipe = null; } else if (recipe == null) { recipe = findRecipe(fluid.getFluid()); if (recipe != null) { tank.setCapacity(recipe.fluid.amount); } } renderOffset += tank.getFluidAmount() - oldAmount; }
@Override public void updateEntity() { super.updateEntity(); if (_steamTank.getFluidAmount() > 0) { int amount = Math.min(_steamTank.getFluidAmount(), PowerConverterCore.throttleSteamConsumer); float energy = amount * PowerConverterCore.powerSystemSteam.getInternalEnergyPerInput(); energy = (int) storeEnergy(energy, false); int toDrain = (int) (amount - (energy / PowerConverterCore.powerSystemSteam.getInternalEnergyPerInput())); _steamTank.drain(toDrain, true); _mBLastTick = toDrain; } else { _mBLastTick = 0; } }
@Override public int fill(ForgeDirection from, FluidStack resource, boolean doFill) { if (resource != null) for (FluidTank _tank : (FluidTank[]) getTanks()) if (_tank.getFluidAmount() == 0 || resource.isFluidEqual(_tank.getFluid())) return _tank.fill(resource, doFill); return 0; }
@Override public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain) { FluidStack drained = tank.drain(maxDrain, doDrain); if (tank.getFluidAmount() == 0 && doDrain) { tank.setFluid(null); } return drained; }
public RefineryRecipe getRecipe(boolean checkCapacity) { RefineryRecipe recipe = DieselHandler.findRefineryRecipe(tank0.getFluid(), tank1.getFluid()); if (recipe == null) return null; if (tank2.getFluid() == null || (tank2.getFluid().isFluidEqual(recipe.output) && (!checkCapacity || tank2.getFluidAmount() + recipe.output.amount <= tank2.getCapacity()))) return recipe; return null; }
public static ItemStack drainFluidContainer(FluidTank tank, ItemStack containerIn) { if (FluidContainerRegistry.isFilledContainer(containerIn)) { FluidStack fs = FluidContainerRegistry.getFluidForFilledItem(containerIn); if (fs != null && tank.getFluidAmount() + fs.amount <= tank.getCapacity()) { ItemStack emptyContainer = FluidContainerRegistry.drainFluidContainer(containerIn); if (emptyContainer != null && tank.fill(fs, true) == fs.amount) return emptyContainer; } } return null; }
public static ItemStack fillFluidContainer( FluidTank tank, ItemStack containerIn, ItemStack containerOut) { if (tank.getFluidAmount() > 0 && containerIn != null) { if (FluidContainerRegistry.isEmptyContainer(containerIn)) { ItemStack filledContainer = FluidContainerRegistry.fillFluidContainer(tank.getFluid(), containerIn); if (filledContainer != null) { FluidStack fs = FluidContainerRegistry.getFluidForFilledItem(filledContainer); if (fs.amount <= tank.getFluidAmount() && (containerOut == null || OreDictionary.itemMatches(containerOut, filledContainer, true))) { tank.drain(fs.amount, true); return filledContainer; } } } else if (containerIn.getItem() instanceof IFluidContainerItem) { IFluidContainerItem iContainer = (IFluidContainerItem) containerIn.getItem(); int available = tank.getFluidAmount(); int space = iContainer.getCapacity(containerIn) - (iContainer.getFluid(containerIn) == null ? 0 : iContainer.getFluid(containerIn).amount); if (available >= space && iContainer.fill(containerIn, tank.getFluid(), false) == space) // Fill in one go { ItemStack filledContainer = copyStackWithAmount(containerIn, 1); int filled = iContainer.fill(filledContainer, tank.getFluid(), true); if (containerOut == null || (OreDictionary.itemMatches(containerOut, filledContainer, true) && ItemStack.areItemStackTagsEqual(filledContainer, containerOut))) { tank.drain(filled, true); return filledContainer; } } else { int filled = iContainer.fill(containerIn, tank.getFluid(), true); tank.drain(filled, true); } } } return null; }
private void updateComparatorValuesPart2() { int vol = tank.getCapacity() / 6; if ((15 * tank.getFluidAmount()) / tank.getCapacity() != masterCompOld) worldObj.func_147453_f(xCoord, yCoord, zCoord, getBlockType()); for (int i = 0; i < 4; i++) { int filled = tank.getFluidAmount() - i * vol; int now = Math.min(15, Math.max((15 * filled) / vol, 0)); if (now != oldComps[i]) { int y = yCoord - offset[1] + i + 1; for (int x = -1; x < 2; x++) for (int z = -1; z < 2; z++) worldObj.func_147453_f( xCoord - offset[0] + x, y, zCoord - offset[2] + z, worldObj.getBlock(xCoord - offset[0] + x, y, zCoord - offset[2] + z)); } } oldComps = null; }
private static void saveTank(ItemStack container, FluidTank tank) { if (tank.getFluidAmount() > 0) { NBTTagCompound itemTag = ItemUtils.getItemTag(container); NBTTagCompound tankTag = new NBTTagCompound(); tank.writeToNBT(tankTag); itemTag.setTag(TANK_TAG, tankTag); } else { container.stackTagCompound = null; } }
@Override public FluidStack drain(EnumFacing from, FluidStack resource, boolean doDrain) { if (tank.getFluidAmount() == 0) { return null; } if (tank.getFluid().getFluid() != resource.getFluid()) { return null; } // same fluid, k return this.drain(from, resource.amount, doDrain); }
@Override public ArrayList getNetworkedData(ArrayList data) { super.getNetworkedData(data); data.add(getReactor() != null && getReactor().isFormed()); if (getReactor() != null) { data.add(getReactor().getPlasmaTemp()); data.add(getReactor().getCaseTemp()); data.add(getReactor().getInjectionRate()); data.add(getReactor().isBurning()); data.add(fuelTank.getStored()); data.add(deuteriumTank.getStored()); data.add(tritiumTank.getStored()); data.add(waterTank.getCapacity()); data.add(waterTank.getFluidAmount()); data.add(steamTank.getCapacity()); data.add(steamTank.getFluidAmount()); } return data; }
public static ItemStack fillFluidContainer(FluidTank tank, ItemStack emptyFluidContainer) { if (tank.getFluidAmount() >= FluidContainerRegistry.BUCKET_VOLUME) { FluidStack fluidStack = tank.drain(FluidContainerRegistry.BUCKET_VOLUME, false); ItemStack filledFluidContainer = FluidContainerRegistry.fillFluidContainer(fluidStack, emptyFluidContainer); if (filledFluidContainer != null) { tank.drain(FluidContainerRegistry.BUCKET_VOLUME, true); } return filledFluidContainer; } else { return null; } }
private void activeEmit() { if (fluidTank.getFluid() != null) { TileEntity tileEntity = Coord4D.get(this).offset(EnumFacing.DOWN).getTileEntity(worldObj); if (tileEntity != null && CapabilityUtils.hasCapability( tileEntity, CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, EnumFacing.UP)) { IFluidHandler handler = CapabilityUtils.getCapability( tileEntity, CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, EnumFacing.UP); FluidStack toDrain = new FluidStack(fluidTank.getFluid(), Math.min(tier.output, fluidTank.getFluidAmount())); fluidTank.drain(handler.fill(toDrain, true), true); } } }
@Override public void updateEntity() { if (!worldObj.isRemote) { if (tank.getFluidAmount() > 2400) { if (progress > 0) { tank.drainInternal(15, true); progress--; } else if (progress == 0) { ItemStack s = MachineCraftingHandler.getFurnaceRecipe(stack[0]); if (s != null) { if (stack[1] != null) { if (TomsModUtils.areItemStacksEqual(stack[1], s, true, true, false) && stack[1].stackSize + s.stackSize <= s.getMaxStackSize() && stack[0].stackSize >= 1) { stack[1].stackSize += s.stackSize; progress = -1; decrStackSize(0, 1); } } else { progress = -1; stack[1] = s; decrStackSize(0, 1); } } else { progress = -1; } } else { ItemStack s = MachineCraftingHandler.getFurnaceRecipe(stack[0]); if (s != null) { if (stack[1] != null) { if (TomsModUtils.areItemStacksEqual(stack[1], s, true, true, false) && stack[1].stackSize + s.stackSize <= s.getMaxStackSize() && stack[0].stackSize >= 1) { progress = MAX_PROCESS_TIME; } } else { progress = MAX_PROCESS_TIME; } } TomsModUtils.setBlockStateWithCondition(worldObj, pos, SteamFurnace.ACTIVE, progress > 0); } } else { TomsModUtils.setBlockStateWithCondition(worldObj, pos, SteamFurnace.ACTIVE, false); } } }
public int drain(FluidTank _tank, int maxDrain, boolean doDrain) { if (_tank.getFluidAmount() > 0) { FluidStack drained = _tank.drain(maxDrain, doDrain); if (drained != null) { if (doDrain) { internalChange = true; onInventoryChanged(); internalChange = false; } return drained.amount; } } return 0; }
@Override public void updateEntity() { super.updateEntity(); if (worldObj.isRemote) { return; } if (heat > 1500) { if (inv[0] != null && inv[0].itemID == BaconItems.rawBacon.itemID && lava.getCapacity() - 100 >= lava.getFluidAmount()) { progress++; if (progress > 100) { progress = 0; lava.fill(new FluidStack(BaconItems.liquidBacon, 100), true); } } } pushFluidOut(); if (worldObj.isRemote) // || worldObj.getWorldTime() % 20 != 0) { return; } int HottestHeat = 20; for (int i = 0; i < 6; i++) { TileEntity tile = BaconWorld.getTileEntity(worldObj, xCoord, yCoord, zCoord, i); if (tile != null && tile instanceof Heater) { Heater heat = (Heater) tile; HottestHeat = Math.max(HottestHeat, heat.getHeat()); } } if (HottestHeat > heat) { heat++; } else if (HottestHeat == heat) { } else { heat--; } }
public int getCurrentNeeded() { int needed = fluidTank.getCapacity() - fluidTank.getFluidAmount(); Coord4D top = Coord4D.get(this).offset(EnumFacing.UP); TileEntity topTile = top.getTileEntity(worldObj); if (topTile instanceof TileEntityFluidTank) { TileEntityFluidTank topTank = (TileEntityFluidTank) topTile; if (fluidTank.getFluid() != null && topTank.fluidTank.getFluid() != null) { if (fluidTank.getFluid().getFluid() != topTank.fluidTank.getFluid().getFluid()) { return needed; } } needed += topTank.getCurrentNeeded(); } return needed; }