@Override protected boolean isEqual(FluidStack a, FluidStack b) { return a.isFluidStackIdentical(b); } }
public static boolean areFluidStacksEqual(@Nullable FluidStack fluidStack1, @Nullable FluidStack fluidStack2) { if (fluidStack1 == null) { return fluidStack2 == null; } else { return fluidStack1.isFluidStackIdentical(fluidStack2); } }
/** * Checks if either both stacks are null or if they are identical. DOES CHECK AMOUNTS * * @param stackA * @param stackB * @return */ public static boolean areFluidStacksIdentical(@Nullable FluidStack stackA, @Nullable FluidStack stackB) { return stackA == null && stackB == null || ((stackA != null && stackB != null) && stackA.isFluidStackIdentical(stackB)); }
@Override public boolean hasLiquid(FluidStack liquid) { FluidStack drained = resourceTank.drainInternal(liquid, false); return liquid.isFluidStackIdentical(drained); }
@Override public boolean hasLiquid(FluidStack liquid) { FluidStack drained = resourceTank.drainInternal(liquid, false); return liquid.isFluidStackIdentical(drained); }
@Nullable @Override public FluidStack isValidFluidItem(@Nonnull ItemStack stack) { if (fluidStack == null) return null; if (FluidLib.hasFluidItemCap(stack)) { IFluidHandler handler = FluidLib.getFluidItemCap(stack); FluidStack drained = handler.drain(fluidStack, false); if (drained == null || !drained.isFluidStackIdentical(fluidStack)) { return null; } return fluidStack.copy(); } return null; }
private boolean removeLiquidResources(boolean doRemove) { if (currentRecipe == null) { return true; } FluidStack fluid = currentRecipe.getFluidResource(); if (fluid != null) { FluidStack drained = resourceTank.drainInternal(fluid, false); if (!fluid.isFluidStackIdentical(drained)) { return false; } if (doRemove) { resourceTank.drainInternal(fluid, true); } } return true; }
@Override public boolean apply(@Nullable ItemStack input) { if (input == null || input.isEmpty()) { return false; } IFluidHandlerItem handler = input.getCount() > 1 ? FluidUtil.getFluidHandler(ItemHelper.cloneStack(input, 1)) : FluidUtil.getFluidHandler(input); if (handler == null) { return false; } return fluid.isFluidStackIdentical(handler.drain(Fluid.BUCKET_VOLUME, false)); }
@Override public void detectAndSendChanges() { FluidStack currentStack = fluidStackSupplier.get(); if(currentStack == null && lastFluidStack != null) { this.lastFluidStack = null; writeUpdateInfo(1, buffer -> buffer.writeBoolean(false)); } else if(currentStack != null && !currentStack.isFluidStackIdentical(lastFluidStack)) { this.lastFluidStack = currentStack; writeUpdateInfo(1, buffer -> { buffer.writeBoolean(true); buffer.writeCompoundTag(currentStack.writeToNBT(new NBTTagCompound())); }); } }
@SideOnly(Side.CLIENT) @Override public void onDataPacket(NetworkManager net, SPacketUpdateTileEntity pkt) { FluidStack old = tank.getFluid(); this.readFromNBT(pkt.getNbtCompound()); if (old != null && !old.isFluidStackIdentical(tank.getFluid()) || old == null && tank.getFluid() != null) { this.world.notifyBlockUpdate(getPos(), world.getBlockState(pos), world.getBlockState(pos), 3); } }
@SideOnly(Side.CLIENT) @Override public void onDataPacket(NetworkManager net, SPacketUpdateTileEntity pkt) { FluidStack old = tank.getFluid(); this.readFromNBT(pkt.getNbtCompound()); if (old != null && !old.isFluidStackIdentical(tank.getFluid()) || old == null && tank.getFluid() != null) { this.world.notifyBlockUpdate(getPos(), world.getBlockState(pos), world.getBlockState(pos), 3); } }
@Override public boolean hasWork() { boolean hasRecipe = true; boolean hasLiquidResources = true; boolean hasResources = true; ItemStack plan = getStackInSlot(InventoryFabricator.SLOT_PLAN); RecipePair<IFabricatorRecipe> recipePair = FabricatorRecipeManager.findMatchingRecipe(plan, craftingInventory); if (!recipePair.isEmpty()) { IFabricatorRecipe recipe = recipePair.getRecipe(); NonNullList<ItemStack> crafting = InventoryUtil.getStacks(craftingInventory, InventoryGhostCrafting.SLOT_CRAFTING_1, InventoryGhostCrafting.SLOT_CRAFTING_COUNT); hasResources = removeFromInventory(crafting, recipePair, false); FluidStack toDrain = recipe.getLiquid(); FluidStack drained = moltenTank.drainInternal(toDrain, false); hasLiquidResources = drained != null && drained.isFluidStackIdentical(toDrain); } else { hasRecipe = false; } IErrorLogic errorLogic = getErrorLogic(); errorLogic.setCondition(!hasRecipe, EnumErrorCode.NO_RECIPE); errorLogic.setCondition(!hasLiquidResources, EnumErrorCode.NO_RESOURCE_LIQUID); errorLogic.setCondition(!hasResources, EnumErrorCode.NO_RESOURCE_INVENTORY); return hasRecipe; }
@SubscribeEvent(priority = EventPriority.HIGH) public void onBucketFill(FillBucketEvent evt) { if (evt.getResult() != Result.DEFAULT) return; if (evt.getEmptyBucket().getItem() != EMPTY_BUCKET) return; final RayTraceResult target = evt.getTarget(); if (target == null || target.typeOfHit != RayTraceResult.Type.BLOCK) return; final TileEntity te = evt.getWorld().getTileEntity(target.getBlockPos()); if (te == null) return; if (te.hasCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, target.sideHit)) { final IFluidHandler source = te.getCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, target.sideHit); final FluidStack drained = source.drain(containedFluid, false); if (containedFluid.isFluidStackIdentical(drained)) { source.drain(containedFluid, true); evt.setFilledBucket(filledBucket.copy()); evt.setResult(Result.ALLOW); } } }
private void craftResult() { RecipePair<IFabricatorRecipe> myRecipePair = getRecipe(); ItemStack craftResult = getResult(myRecipePair); IFabricatorRecipe myRecipe = myRecipePair.getRecipe(); if (myRecipe != null && !craftResult.isEmpty() && getStackInSlot(InventoryFabricator.SLOT_RESULT).isEmpty()) { FluidStack liquid = myRecipe.getLiquid(); // Remove resources NonNullList<ItemStack> crafting = InventoryUtil.getStacks(craftingInventory, InventoryGhostCrafting.SLOT_CRAFTING_1, InventoryGhostCrafting.SLOT_CRAFTING_COUNT); if (removeFromInventory(crafting, myRecipePair, false)) { FluidStack drained = moltenTank.drainInternal(liquid, false); if (drained != null && drained.isFluidStackIdentical(liquid)) { removeFromInventory(crafting, myRecipePair, true); moltenTank.drain(liquid.amount, true); // Damage plan if (!getStackInSlot(InventoryFabricator.SLOT_PLAN).isEmpty()) { Item planItem = getStackInSlot(InventoryFabricator.SLOT_PLAN).getItem(); if (planItem instanceof ICraftingPlan) { ItemStack planUsed = ((ICraftingPlan) planItem).planUsed(getStackInSlot(InventoryFabricator.SLOT_PLAN), craftResult); setInventorySlotContents(InventoryFabricator.SLOT_PLAN, planUsed); } } setInventorySlotContents(InventoryFabricator.SLOT_RESULT, craftResult); } } } }
@SubscribeEvent public void onBucketFill(FillBucketEvent evt) { if (evt.getResult() != Result.DEFAULT) return; if (evt.getEmptyBucket().getItem() != EMPTY_BUCKET) return; final RayTraceResult target = evt.getTarget(); if (target == null || target.typeOfHit != RayTraceResult.Type.BLOCK) return; final TileEntity te = evt.getWorld().getTileEntity(target.getBlockPos()); if (te == null) return; if (!canFill(evt.getWorld(), target.getBlockPos(), te)) { return; } if (te.hasCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, target.sideHit)) { final IFluidHandler source = te.getCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, target.sideHit); final FluidStack fluidInContainer = source.drain(Fluid.BUCKET_VOLUME, false); if (fluidInContainer != null) { final ItemStack filledBucket = getFilledBucket(fluidInContainer); if (!filledBucket.isEmpty()) { final IFluidHandlerItem container = FluidUtil.getFluidHandler(filledBucket); if (container != null) { final FluidStack fluidInBucket = container.drain(Integer.MAX_VALUE, false); if (fluidInBucket != null && fluidInBucket.isFluidStackIdentical(source.drain(fluidInBucket, false))) { source.drain(fluidInBucket, true); evt.setFilledBucket(filledBucket.copy()); evt.setResult(Result.ALLOW); } } } } } }