/** Checks if the given fluidstack can be used as smeltery fuel */ public static boolean isSmelteryFuel(FluidStack in) { for(Map.Entry<FluidStack, Integer> entry : smelteryFuels.entrySet()) { if(entry.getKey().isFluidEqual(in)) { return true; } } return false; }
/** Reduces the fluidstack by one increment of the fuel and returns how much fuel duration it gives. */ public static int consumeSmelteryFuel(FluidStack in) { for(Map.Entry<FluidStack, Integer> entry : smelteryFuels.entrySet()) { if(entry.getKey().isFluidEqual(in)) { FluidStack fuel = entry.getKey(); int out = entry.getValue(); if(in.amount < fuel.amount) { float coeff = (float) in.amount / (float) fuel.amount; out = Math.round(coeff * in.amount); in.amount = 0; } else { in.amount -= fuel.amount; } return out; } } return 0; }
@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; }
private void handlePossibleSlotChanges( int slot, IAEFluidStack oldAeFS, FluidStack newFS, List<IAEFluidStack> changes ) { if( oldAeFS != null && oldAeFS.getFluidStack().isFluidEqual( newFS ) ) { this.handleStackSizeChanged( slot, oldAeFS, newFS, changes ); } else { this.handleFluidChanged( slot, oldAeFS, newFS, changes ); } }
@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; }
private boolean hasTankWithFuel(BlockPos pos, FluidStack preference) { IFluidTank tank = getTankAt(pos); if(tank != null && tank.getFluid() != null) { if(tank.getFluidAmount() > 0 && TinkerRegistry.isSmelteryFuel(tank.getFluid())) { // if we have a preference, only use that if(preference != null && tank.getFluid().isFluidEqual(preference)) { return true; } else if(preference == null) { return true; } } } return false; }
public void setTargetStack( final IAEFluidStack stack ) { if( Platform.isClient() ) { if( stack == null && this.clientRequestedTargetFluid == null ) { return; } if( stack != null && this.clientRequestedTargetFluid != null && stack.getFluidStack() .isFluidEqual( this.clientRequestedTargetFluid.getFluidStack() ) ) { return; } NetworkHandler.instance().sendToServer( new PacketTargetFluidStack( (AEFluidStack) stack ) ); } this.clientRequestedTargetFluid = stack == null ? null : stack.copy(); }
public static boolean areFluidsCompatable(FluidStack a, FluidStack b) { if (a == null || b == null) { return true; } return a.isFluidEqual(b); }
@Override public boolean isInput(FluidStack test) { if (test == null || fluid == null) { return false; } return test.isFluidEqual(fluid); }
protected boolean checkInputFluid(FluidStack fluidStack) { if(!isFilterInstalled) { return true; } for (FluidStack filterStack : fluidFilterSlots) { if (filterStack != null && filterStack.isFluidEqual(fluidStack)) { return true; } } return false; }
@Nullable protected FluidStack getExisting(final FluidStack stack) { for (final FluidStack stack2 : this.fluidStacks) { if (stack2.isFluidEqual(stack)) { return stack2; } } return null; }
if(!drained.isFluidEqual(toDrain) || drained.amount != toDrain.amount) { log.error("Smeltery alloy creation drained incorrect amount: was %s:%d, should be %s:%d", drained .getUnlocalizedName(), drained.amount, toDrain.getUnlocalizedName(), toDrain.amount);
public void sync(FluidStack liquid) { s_liquid = liquid; if (!s_liquid.isFluidEqual(c_liquid)) { f_liquid = c_liquid.copy(); } }
@Nullable public static IHygroregulatorRecipe findMatchingRecipe(FluidStack liquid) { if (liquid.amount <= 0) { return null; } for (IHygroregulatorRecipe recipe : recipes) { FluidStack resource = recipe.getResource(); if (resource.isFluidEqual(liquid)) { return recipe; } } return null; }
@Override public boolean isValidInput(@Nonnull FluidStack item) { for (IRecipeInput ri : inputs) { if (item.getFluid() != null && item.isFluidEqual(ri.getFluidInput())) { return true; } } return false; }
@Override public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain) { if (resource.isFluidEqual(tank.getFluid())) return tank.drain(resource.amount, doDrain); else return null; }
else if(tank.getFluid().isFluidEqual(info.fluid)) { info.fluid.amount += tank.getFluidAmount(); info.maxCap += tank.getCapacity();
public static boolean matches(IFermenterRecipe recipe, ItemStack res, FluidStack liqu) { ItemStack resource = recipe.getResource(); if (!ItemStackUtil.isCraftingEquivalent(resource, res, recipe.getResourceOreName(), false)) { return false; } FluidStack fluid = recipe.getFluidResource(); return liqu.isFluidEqual(fluid); }
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; }
public FluidStack drain(EnumFacing from, FluidStack resource, boolean doDrain) { if (sideTanks[from.ordinal()].getFluid() == null || !(sideTanks[from.ordinal()].getFluid().isFluidEqual(resource))) { return new FluidStack(resource.getFluid(), 0); } return drain(from, resource.amount, doDrain); }