public FluidStack getUsableFluid() { if(fluid == null) { return null; } FluidStack stack = this.fluid.copy(); stack.amount -= locked; return stack; }
public FluidStack getResult() { return output.copy(); }
@Override public FluidStack drain(FluidStack resource, boolean doDrain) { // search for the resource ListIterator<FluidStack> iter = liquids.listIterator(); while(iter.hasNext()) { FluidStack liquid = iter.next(); if(liquid.isFluidEqual(resource)) { int drainable = Math.min(resource.amount, liquid.amount); if(doDrain) { liquid.amount -= drainable; if(liquid.amount <= 0) { iter.remove(); } parent.onTankChanged(liquids, liquid); } // return drained amount resource = resource.copy(); resource.amount = drainable; return resource; } } // nothing drained return null; }
public SmeltingRecipeWrapper(MeltingRecipe recipe) { this.inputs = ImmutableList.of(recipe.input.getInputs()); this.outputs = ImmutableList.of(recipe.getResult()); this.temperature = recipe.getTemperature(); ImmutableList.Builder<FluidStack> builder = ImmutableList.builder(); for(FluidStack fs : TinkerRegistry.getSmelteryFuels()) { if(fs.getFluid().getTemperature(fs) >= temperature) { fs = fs.copy(); fs.amount = 1000; builder.add(fs); } } fuels = builder.build(); }
@Override public int fill( final FluidStack fluid, final boolean doFill ) { if( fluid == null || fluid.amount <= 0 ) { return 0; } final FluidStack insert = fluid.copy(); int totalFillAmount = 0; for( int slot = 0; slot < this.getSlots(); ++slot ) { int fillAmount = this.fill( slot, insert, doFill ); totalFillAmount += fillAmount; insert.amount -= fillAmount; if( insert.amount <= 0 ) { break; } } return totalFillAmount; }
final FluidStack resource = fluid.copy();
if( tank != null ) l.tmpUsed = tank.fill( resource.copy(), false ); final FluidStack insert = resource.copy(); insert.amount = (int) Math.ceil( insert.amount * ( (double) l.tmpUsed / (double) requestTotal ) ); if( insert.amount > available ) if( tank != null ) l.tmpUsed = tank.fill( insert.copy(), true );
protected void pour() { if(drained == null) { return; } IFluidHandler toFill = getFluidHandler(pos.down(), EnumFacing.UP); if(toFill != null) { FluidStack fillStack = drained.copy(); fillStack.amount = Math.min(drained.amount, LIQUID_TRANSFER); // can we fill? int filled = toFill.fill(fillStack, false); if(filled > 0) { // transfer it this.drained.amount -= filled; fillStack.amount = filled; toFill.fill(fillStack, true); } } else { // filling TE got lost. reset. all liquid buffered is lost. reset(); } }
CachedFluidStack( final FluidStack is ) { if( is == null ) { this.fluidStack = null; this.aeStack = null; } else { this.fluidStack = is.copy(); this.aeStack = AEApi.instance().storage().getStorageChannel( IFluidStorageChannel.class ).createStack( is ); } } }
FluidStack copy = totalDrained.copy(); copy.amount = toDrain; FluidStack drain = this.drain( slot, copy, doDrain );
@Override public int fill(FluidStack resource, boolean doFill) { // Safeety check, it seems sometimes it can happen that something creates an invalid fluidstack? // does some mod register a fluid with an empty string as name..? if(StringUtils.isNullOrEmpty(FluidRegistry.getFluidName(resource.getFluid()))) { return 0; } // check how much space is left in the smeltery int used = getFluidAmount(); int usable = Math.min(maxCapacity - used, resource.amount); if(!doFill) { return usable; } // check if we already have the given liquid for(FluidStack liquid : liquids) { if(liquid.isFluidEqual(resource)) { // yup. add it liquid.amount += usable; parent.onTankChanged(liquids, liquid); return usable; } } // not present yet, add it resource = resource.copy(); resource.amount = usable; liquids.add(resource); parent.onTankChanged(liquids, resource); return usable; }
@Override protected boolean onItemFinishedHeating(ItemStack stack, int slot) { MeltingRecipe recipe = TinkerRegistry.getMelting(stack); if(recipe == null) { return false; } TinkerSmelteryEvent.OnMelting event = TinkerSmelteryEvent.OnMelting.fireEvent(this, stack, recipe.output.copy()); FluidStack fluidStack = FluidUtil.getValidFluidStackOrNull(event.result); int filled = liquids.fill(fluidStack, false); if(filled == fluidStack.amount) { liquids.fill(fluidStack, true); // only clear out items n stuff if it was successful setInventorySlotContents(slot, ItemStack.EMPTY); return true; } else { // can't fill into the smeltery, set error state itemTemperatures[slot] = itemTempRequired[slot] * 2 + 1; } return false; }
info.maxCap = 1; } else { info.fluid = currentFuel.copy(); info.fluid.amount = 0; info.maxCap = currentFuel.amount; FluidStack tankFluid = tank.getFluid(); assert tankFluid != null; info.fluid = tankFluid.copy(); info.heat = temperature + 300; info.maxCap = tank.getCapacity(); info.fluid = tank.getFluid().copy(); info.heat = info.fluid.getFluid().getTemperature(info.fluid); info.maxCap = tank.getCapacity();
liquids.fill(fluid.copy(), true);
@Nonnull FluidStack convertFluidResult(boolean isFilling, @Nonnull ItemStack input, @Nonnull FluidStack machineFluid, @Nonnull FluidStack recipeFluid, @Nonnull ItemStack output) { return recipeFluid.copy(); }
@Override @Nonnull FluidStack convertFluidResult(boolean isFilling, @Nonnull ItemStack input, @Nonnull FluidStack machineFluid, @Nonnull FluidStack recipeFluid, @Nonnull ItemStack output) { FluidStack copy = recipeFluid.copy(); copy.amount = XpUtil.experienceToLiquid(copy.amount); return copy; } };
public RecipeInput(@Nonnull RecipeInput copyFrom) { input = copyFrom.input.copy(); fluid = copyFrom.fluid == null ? null : copyFrom.fluid.copy(); useMeta = copyFrom.useMeta; multiplier = copyFrom.multiplier; slot = copyFrom.slot; }
public void setFluidType(FluidStack liquidType) { if (tank.getFluid() != null && tank.getFluid().isFluidEqual(liquidType)) { return; } if (liquidType != null) { liquidType = liquidType.copy(); } else if (tank.getFluid() == null) { return; } tank.setLiquid(liquidType); stateDirty = true; }