@Override
 public boolean isItemValidForSlot(int slot, ItemStack stack) {
   return stack != null
       && stack.getItem() != null
       && slot == 0
       && (stack.getItem() instanceof IFluidContainerItem
           || FluidContainerRegistry.isContainer(stack));
 }
  public int getProgress() {
    ItemStack stack = inventory.getStackInSlot(0);
    if (stack == null) return 0;
    Item item = stack.getItem();
    FluidStack fluidstack = null;
    int capacity = 0;
    if (item instanceof IFluidContainerItem) {
      IFluidContainerItem iFluidContainerItem = (IFluidContainerItem) stack.getItem();
      fluidstack = iFluidContainerItem.getFluid(stack);
      capacity = iFluidContainerItem.getCapacity(stack);
    } else if (FluidContainerRegistry.isContainer(stack)) {
      fluidstack = FluidContainerRegistry.getFluidForFilledItem(stack);
      capacity =
          FluidContainerRegistry.getContainerCapacity(fill ? tank.getFluid() : fluidstack, stack);
    }

    if (fluidstack == null || capacity <= 0) {
      if (fill) return 0;
      return 16;
    }
    if (fill) return (int) ((fluidstack.amount * 16D) / capacity);
    return (int) (((capacity - fluidstack.amount) * 16D) / capacity);
  }
예제 #3
0
 public static boolean isFluidRelatedItemStack(ItemStack stack) {
   if (stack == null) return false;
   return FluidContainerRegistry.isContainer(stack)
       || stack.getItem() instanceof IFluidContainerItem;
 }
  @Override
  public void updateEntity() {
    super.updateEntity();
    if (worldObj.isRemote) return;
    ItemStack stack = inventory.getStackInSlot(0);
    if (stack != null) {
      Item stackItem = stack.getItem();
      if (stackItem instanceof IFluidContainerItem) {
        IFluidContainerItem iFluidContainerItem = (IFluidContainerItem) stackItem;
        if (fill) {
          if (!tank.isEmpty()) {
            int amount = 128;
            if (tank.getFluidAmount() < amount) amount = tank.getFluidAmount();
            if (energy >= amount) {
              drain(
                  ForgeDirection.UNKNOWN,
                  iFluidContainerItem.fill(stack, new FluidStack(tank.getFluid(), amount), true),
                  true);
              energy -= amount;
            }
          }
        } else {
          FluidStack contained = iFluidContainerItem.getFluid(stack);
          if (!fill && !tank.isFull() && contained != null && contained.amount > 0) {
            int amount = 64;
            if (tank.getFreeSpace() < amount) amount = tank.getFreeSpace();
            if (amount > contained.amount) amount = contained.amount;
            iFluidContainerItem.drain(
                stack, fill(ForgeDirection.UNKNOWN, new FluidStack(contained, amount), true), true);
          }
        }
      } else if (FluidContainerRegistry.isContainer(stack)) {
        if (fill) {
          if (!tank.isEmpty()) {
            int amount = FluidContainerRegistry.getContainerCapacity(tank.getFluid(), stack);
            if (amount > 0 && energy >= amount && tank.getFluidAmount() >= amount) {
              ItemStack filledContainer =
                  FluidContainerRegistry.fillFluidContainer(
                      new FluidStack(tank.getFluid(), amount), stack);
              if (filledContainer != null
                  && filledContainer.getItem() != null
                  && filledContainer.stackSize > 0) {
                energy -= amount;
                drain(ForgeDirection.UNKNOWN, amount, true);
                inventory.setInventorySlotContents(0, filledContainer.copy());
              }
            }
          }
        } else {
          FluidStack contained = FluidContainerRegistry.getFluidForFilledItem(stack);
          if (contained != null
              && contained.amount > 0
              && tank.getFreeSpace() >= contained.amount) {
            if (fill(ForgeDirection.UNKNOWN, contained, false) == contained.amount) {
              fill(ForgeDirection.UNKNOWN, contained, true);
              ItemStack drainedContainer = FluidContainerRegistry.drainFluidContainer(stack);
              if (drainedContainer != null
                  && drainedContainer.getItem() != null
                  && drainedContainer.stackSize > 0)
                inventory.setInventorySlotContents(0, drainedContainer.copy());
            }
          }
        }
      }

      if (getProgress() >= 16) {
        stack = getStackInSlot(0);
        if (stack != null) {
          ItemStack outputStack = getStackInSlot(1);
          if (outputStack == null || outputStack.getItem() == null || outputStack.stackSize <= 0) {
            ItemStack copyStack = stack.copy();
            copyStack.stackSize = 1;
            inventory.setInventorySlotContents(1, copyStack);
            inventory.decrStackSize(0, 1);
          }
        }
      }
    }
  }