Java ItemStackSnapshot.createStack方法代码示例

import org.spongepowered.api.item.inventory.ItemStackSnapshot; //导入方法依赖的package包/类
public void sweepFloor() {

    for (Item item : getContained(Item.class)) {

      if (!contains(item)) {
        continue;
      }

      ItemType id = item.getItemType();
      for (ItemType aItem : ITEMS) {
        if (aItem == id) {
          ItemStackSnapshot snapshot = item.get(Keys.REPRESENTED_ITEM).get();
          int newAmt = (int) (snapshot.getCount() * .8);
          if (newAmt < 1) {
            item.remove();
          } else {
            ItemStack newStack = snapshot.createStack();
            newStack.setQuantity(newAmt);
            item.offer(Keys.REPRESENTED_ITEM, newStack.createSnapshot());
          }
          break;
        }
      }
    }
  }
 

import org.spongepowered.api.item.inventory.ItemStackSnapshot; //导入方法依赖的package包/类
@Override
public IIngredient.Builder with(ItemStackSnapshot... items) {
    checkNotNull(items, "items");
    for (ItemStackSnapshot item : items) {
        checkNotNull(item, "item");
        final ItemStack item1 = item.createStack();
        this.matchers.add(itemStack -> LanternItemStack.areSimilar(itemStack, item1));
    }
    return withDisplay(items);
}
 

import org.spongepowered.api.item.inventory.ItemStackSnapshot; //导入方法依赖的package包/类
public static Clause<Boolean, List<Clause<ItemStack, Integer>>> giveItems(Player player, Collection<ItemStack> stacks, Cause cause) {
  List<Clause<ItemStack, Integer>> transactions = new ArrayList<>(stacks.size());
  List<ItemStackSnapshot> itemBuffer = new ArrayList<>();
  itemBuffer.addAll(stacks.stream().map(ItemStack::createSnapshot).collect(Collectors.toList()));

  PlayerInventory playerInventory = player.getInventory().query(PlayerInventory.class);
  List<Inventory> inventories = new ArrayList<>();
  inventories.add(playerInventory.getHotbar());
  inventories.add(playerInventory.getMain());

  // Loop through replacing empty space with the requested items
  for (Inventory inventory : inventories) {
    List<ItemStackSnapshot> newBuffer = new ArrayList<>();
    for (ItemStackSnapshot snapshot : itemBuffer) {
      ItemStack stack = snapshot.createStack();

      InventoryTransactionResult result = inventory.offer(stack);
      newBuffer.addAll(result.getRejectedItems());

      transactions.add(new Clause<>(stack, stack.getQuantity()));
    }
    itemBuffer = newBuffer;
  }

  // Drop remaining items
  new ItemDropper(player.getLocation()).dropStackSnapshots(itemBuffer, SpawnTypes.PLUGIN);

  return new Clause<>(true, transactions);
}
 

import org.spongepowered.api.item.inventory.ItemStackSnapshot; //导入方法依赖的package包/类
public ItemStackSnapshotView(ItemStackSnapshot value) {
    super(value);

    this.stack = value.createStack();
}
 

import org.spongepowered.api.item.inventory.ItemStackSnapshot; //导入方法依赖的package包/类
@Override
public IIngredient.Builder withRemaining(ItemStackSnapshot item) {
    checkNotNull(item, "item");
    this.remainingItemProvider = itemStack -> item.createStack();
    return this;
}
 

import org.spongepowered.api.item.inventory.ItemStackSnapshot; //导入方法依赖的package包/类
/**
 * Gets the {@link MatrixResult}.
 *
 * @return The matrix result
 */
public MatrixResult getMatrixResult(int times) {
    checkArgument(times <= this.maxTimes, "times cannot exceed getMaxTimes");
    final ICraftingMatrix matrix = (ICraftingMatrix) this.matrix.copy();
    final List<ItemStackSnapshot> remaining = this.result.getRemainingItems();
    final List<ItemStack> rest = new ArrayList<>();
    final int w = matrix.width();
    for (int x = 0; x < w; x++) {
        for (int y = 0; y < matrix.height(); y++) {
            ItemStack itemStack = matrix.get(x, y);
            if (!itemStack.isEmpty()) {
                itemStack.setQuantity(itemStack.getQuantity() -
                        (this.itemQuantities == null ? 1 : this.itemQuantities[x][y]) * times);
            }
            final ItemStackSnapshot itemStackSnapshot = remaining.get(y * w + x);
            if (!itemStackSnapshot.isEmpty()) {
                int quantity;
                final boolean flag = LanternItemStack.areSimilar(itemStack, itemStackSnapshot);
                if (itemStack.isEmpty() || flag) {
                    if (!flag) {
                        itemStack = itemStackSnapshot.createStack();
                        matrix.set(x, y, itemStack);
                    }
                    final int max = itemStack.getMaxStackQuantity();
                    quantity = itemStack.getQuantity() * times;
                    if (quantity > max) {
                        itemStack.setQuantity(max);
                        itemStack = itemStack.copy();
                        itemStack.setQuantity(quantity - max);
                    } else {
                        itemStack = null;
                    }
                } else {
                    itemStack = itemStackSnapshot.createStack();
                    itemStack.setQuantity(itemStack.getQuantity() * times);
                }
                if (itemStack != null) {
                    rest.add(itemStack);
                }
            }
        }
    }
    return new MatrixResult(matrix, rest);
}
 

import org.spongepowered.api.item.inventory.ItemStackSnapshot; //导入方法依赖的package包/类
@Override
public Optional<SmeltingResult> getResult(ItemStackSnapshot ingredient) {
    final ItemStack itemStack = ingredient.createStack();
    return this.ingredient.test(itemStack) ? Optional.of(this.resultProvider.get(itemStack)) : Optional.empty();
}
 

import org.spongepowered.api.item.inventory.ItemStackSnapshot; //导入方法依赖的package包/类
@Nullable
public static LanternItemStack toNullable(@Nullable ItemStackSnapshot itemStackSnapshot) {
    return itemStackSnapshot == null || itemStackSnapshot.isEmpty() ? null :  (LanternItemStack) itemStackSnapshot.createStack();
}
 

import org.spongepowered.api.item.inventory.ItemStackSnapshot; //导入方法依赖的package包/类
@Listener
public void onOreDrop(
    DropItemEvent.Destruct event,
    @Named(NamedCause.SOURCE) BlockSpawnCause spawnCause,
    @Named(NamedCause.NOTIFIER) Player player
) {
  if (!Probability.getChance(4)) {
    return;
  }

  BlockSnapshot blockSnapshot = spawnCause.getBlockSnapshot();

  Optional<Location<World>> optLocation = blockSnapshot.getLocation();
  if (!optLocation.isPresent()) {
    return;
  }

  Location<World> loc = optLocation.get();
  Optional<CursedMineInstance> optInst = manager.getApplicableZone(loc);

  if (!optInst.isPresent()) {
    return;
  }

  CursedMineInstance inst = optInst.get();
  if (!inst.hasrecordForPlayerAt(player, loc)) {
    return;
  }

  List<ItemStackSnapshot> itemStacks = new ArrayList<>();
  Iterator<Entity> entityIterator = event.getEntities().iterator();
  while (entityIterator.hasNext()) {
    Entity entity = entityIterator.next();
    if (entity instanceof Item) {
      ItemStackSnapshot snapshot = ((Item) entity).item().get();
      itemStacks.add(snapshot);
      entityIterator.remove();
    }
  }

  int times = 1;

  Optional<ModifierService> optService = Sponge.getServiceManager().provide(ModifierService.class);
  if (optService.isPresent()) {
    ModifierService service = optService.get();
    if (service.isActive(Modifiers.DOUBLE_CURSED_ORES)) {
      times *= 2;
    }
  }

  for (ItemStackSnapshot stackSnapshot : itemStacks) {
    int quantity = Math.min(
        stackSnapshot.getCount() * Probability.getRangedRandom(4, 8),
        stackSnapshot.getType().getMaxStackQuantity()
    );

    for (int i = 0; i < times; ++i) {
      ItemStack stack = stackSnapshot.createStack();
      stack.setQuantity(quantity);
      player.getInventory().offer(stack);
    }
  }
}