Java ItemStackSnapshot类代码示例

import org.spongepowered.api.item.inventory.ItemStackSnapshot; //导入依赖的package包/类
private void processCostItem(Player player, String command, Consumer<CommandResult> callback)
{
    int count = Integer.parseInt(command.replaceFirst("\\s++$", ""));
    ItemStack stackUsed = SpongeUnimplemented.getItemHeldByMouse(player).createStack();
    int stackUsedQuantity = stackUsed.getQuantity();
    if (stackUsedQuantity > count)
    {
        stackUsed.setQuantity(stackUsedQuantity - count);
        SpongeUnimplemented.setItemHeldByMouse(player, stackUsed.createSnapshot());
        callback.accept(CommandResult.success());
    }
    else
    {
        SpongeUnimplemented.setItemHeldByMouse(player, ItemStackSnapshot.NONE);
        callback.accept(CommandResult.empty());
    }
}
 

import org.spongepowered.api.item.inventory.ItemStackSnapshot; //导入依赖的package包/类
public void give(Player player) {
	this.checkCache();
	for (ItemStackSnapshot iss : itemStacksCache) {
		InventoryTransactionResult result = player.getInventory().offer(iss.createStack());
		for (ItemStackSnapshot is : result.getRejectedItems()) {
			Item item = (Item) player.getLocation().getExtent().createEntity(EntityTypes.ITEM, player.getLocation().getPosition());
			item.offer(Keys.REPRESENTED_ITEM, is.copy());
			player.getWorld().spawnEntity(item, Cause.of(NamedCause.source(player), NamedCause.owner("BetterKits")));
		}
	}

	for (String command : this.getCommands()) {
		try {
			Sponge.getCommandManager().process(Sponge.getServer().getConsole(), command.replace("%name", player.getName()).replace("%uuid", player.getUniqueId().toString()));
		} catch (Throwable e) {
			e.printStackTrace();
		}
	}
}
 

import org.spongepowered.api.item.inventory.ItemStackSnapshot; //导入依赖的package包/类
private ObjectMapper getDefaultObjectMapper(boolean xml, boolean details, TreeNode<String, Boolean> perms) {
    if (perms == null) {
        throw new NullPointerException("Permissions may not be null");
    }

    ObjectMapper om = xml ? new XmlMapper() : new ObjectMapper();
    om.setSerializationInclusion(JsonInclude.Include.NON_NULL);

    SimpleModule mod = new SimpleModule();
    for (Map.Entry<Class, BaseSerializer> entry : serializers.entrySet()) {
        mod.addSerializer(entry.getKey(), entry.getValue());
    }
    mod.addDeserializer(ItemStack.class, new ItemStackDeserializer());
    mod.addDeserializer(BlockState.class, new BlockStateDeserializer());
    mod.addDeserializer(ItemStackSnapshot.class, new ItemStackSnapshotDeserializer());
    mod.addDeserializer(Location.class, new LocationDeserializer());
    om.registerModule(mod);

    SimpleFilterProvider filterProvider = new SimpleFilterProvider();
    filterProvider.addFilter(BaseFilter.ID, new BaseFilter(details, perms));
    om.setFilterProvider(filterProvider);

    om.setAnnotationIntrospector(new AnnotationIntrospector(details));

    return om;
}
 

import org.spongepowered.api.item.inventory.ItemStackSnapshot; //导入依赖的package包/类
private void populate(SimpleCustomInventory inventory) {
    CustomInventoryData data = inventory.getCustomInventoryData();
    val slotIdToItemStack = data.getSlotIdToItemStack();

    inventory.getCustomSlots().forEach(customSlot -> {
        ItemStack itemStack = customSlot.getDefinition().getId()
                .flatMap(slotId -> Optional.ofNullable(slotIdToItemStack.get(slotId)))
                .map(ItemStackSnapshot::createStack)
                .orElseGet(() -> customSlot.getDefinition().createDefaultItemStack());

        customSlot.setItemStack(itemStack);
    });

    val slotIdToFeatureId = data.getSlotIdToFeatureId();

    slotIdToFeatureId.forEach((slotId, featureId) ->
            inventory.getCustomSlot(slotId).ifPresent(customSlot ->
                    customSlot.setFeature(featureId)
            )
    );
}
 

import org.spongepowered.api.item.inventory.ItemStackSnapshot; //导入依赖的package包/类
public Optional<ItemStack> getItemStack() {
    Optional<Slot> slot = getSlot();

    if(slot.isPresent()) {
        return slot.get().peek();
    }

    if(definition.isPersistent()) {
        CustomInventoryData data = customInventoryDefinition.getCustomInventoryData(dataHolder);
        String definitionId = definition.getId()
                .orElseThrow(() -> new IllegalStateException("Could not access the ID of a persistent CustomSlot."));

        return Optional.ofNullable(data.getSlotIdToItemStack().get(definitionId))
                .map(ItemStackSnapshot::createStack);
    }

    return Optional.ofNullable(definition.createDefaultItemStack());
}
 

import org.spongepowered.api.item.inventory.ItemStackSnapshot; //导入依赖的package包/类
static AffectCustomSlotListener output() {
    return (customSlot, slotTransaction, affectSlotEvent) -> {
        if(slotTransaction.getFinal() == ItemStackSnapshot.NONE)
            return;

        ItemStack finalStackOne = slotTransaction.getFinal().createStack();
        ItemStack originalStackOne = slotTransaction.getOriginal().createStack();

        finalStackOne.setQuantity(1);
        originalStackOne.setQuantity(1);

        if(!finalStackOne.equals(originalStackOne)) {
            affectSlotEvent.setCancelled(true);
            return;
        }

        if(slotTransaction.getFinal().getCount() > slotTransaction.getOriginal().getCount())
            affectSlotEvent.setCancelled(true);
    };
}
 

import org.spongepowered.api.item.inventory.ItemStackSnapshot; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Override
protected Optional<CustomInventoryData> buildContent(DataView container) throws InvalidDataException {
    if(!container.contains(CUSTOM_INVENTORY_ID, CUSTOM_INVENTORY_SLOT_ID_TO_ITEMSTACK,
            CUSTOM_INVENTORY_SLOT_ID_TO_FEATURE_ID)) {
        return Optional.empty();
    }

    Optional<String> id = container.getString(CUSTOM_INVENTORY_ID.getQuery());

    if(!id.isPresent())
        throw new InvalidDataException("Could not access the ID of the inventory data.");

    val slotIdToItemStack = (Map<String, ItemStackSnapshot>) container.getMap(
            CUSTOM_INVENTORY_SLOT_ID_TO_ITEMSTACK.getQuery()
    ).orElse(null);

    val slotIdToFeatureId = (Map<String, String>) container.getMap(
            CUSTOM_INVENTORY_SLOT_ID_TO_FEATURE_ID.getQuery()
    ).orElse(null);

    return Optional.of(new CustomInventoryData(id.get(), slotIdToItemStack, slotIdToFeatureId));
}
 

import org.spongepowered.api.item.inventory.ItemStackSnapshot; //导入依赖的package包/类
public void spawnItem(Location<World> location, ItemStackSnapshot snapshot, Object notifier) {
    World world = location.getExtent();
    Item rejectedItem = (Item) world.createEntity(EntityTypes.ITEM, location.getPosition());

    Cause cause = Cause.source(
            EntitySpawnCause.builder()
                    .entity(rejectedItem)
                    .type(SpawnTypes.PLUGIN)
                    .build()
            )
            .owner(CustomItemLibrary.getInstance().getPluginContainer())
            .notifier(notifier)
            .build();

    rejectedItem.offer(Keys.REPRESENTED_ITEM, snapshot);
    world.spawnEntity(rejectedItem, cause);
}
 

import org.spongepowered.api.item.inventory.ItemStackSnapshot; //导入依赖的package包/类
private void handleOutputClick(SlotTransaction slotTransaction, Transaction<ItemStackSnapshot> cursorTransaction) {
    // Trying to put item in slot
    if (slotTransaction.getFinal() != ItemStackSnapshot.NONE) {
        if (slotTransaction.getOriginal() != cursorTransaction.getFinal()) {
            System.out.println("false positive");
            // False positive
            return;
        }
        System.out.println("put item in output");
        slotTransaction.setValid(false);
        // TODO because Sponge is broken - set custom to original
        cursorTransaction.setCustom(cursorTransaction.getOriginal());
        return;
    }
    if (!canTakeOutput()) {
        System.out.println("take output before ready");
        slotTransaction.setValid(false);
        cursorTransaction.setCustom(cursorTransaction.getOriginal());
        return;
    }
    System.out.println("take output");
    takeOutput();
}
 

import org.spongepowered.api.item.inventory.ItemStackSnapshot; //导入依赖的package包/类
@Listener(order = Order.LATE)
public void onPlayerCombat(DamageEntityEvent event) {
  Entity targetEntity = event.getTargetEntity();
  if (!(targetEntity instanceof Living)) {
    return;
  }

  Optional<Clause<Living, ItemStackSnapshot>> optSourceEntity = getSource(event.getCause());
  if (!optSourceEntity.isPresent()) {
    return;
  }

  Living sourceEntity = optSourceEntity.get().getKey();
  ItemStackSnapshot snapshot = optSourceEntity.get().getValue();
  if (!applicabilityTest.test(sourceEntity, snapshot)) {
    return;
  }

  if (cooldownHandler.canUseAbility(sourceEntity)) {
    cooldownHandler.useAbility(sourceEntity);
  } else {
    return;
  }

  rangedCluster.getNextAttackToRun().run(sourceEntity, (Living) targetEntity, event);
}
 

import org.spongepowered.api.item.inventory.ItemStackSnapshot; //导入依赖的package包/类
@Override
public IInventory getTarget(LanternContainer container, AbstractInventorySlot slot) {
    if (container.getOpenInventory().containsInventory(slot)) {
        return getDefaultTarget(container, slot);
    }
    // The item stack should be present
    final ItemStackSnapshot snapshot = LanternItemStackSnapshot.wrap(slot.peek().get()); // Wrap, peek creates a copy
    // Check if the item can be used as a ingredient
    final Optional<SmeltingRecipe> optSmeltingRecipe = Lantern.getRegistry()
            .getSmeltingRecipeRegistry().findMatchingRecipe(snapshot);
    final List<IInventory> inventories = new ArrayList<>();
    final FurnaceInventory furnaceInventory = (FurnaceInventory) container.getOpenInventory();
    if (optSmeltingRecipe.isPresent()) {
        inventories.add(furnaceInventory.getInputSlot());
    }
    // Check if the item can be used as a fuel
    final Optional<IFuel> optFuel = Lantern.getRegistry()
            .getFuelRegistry().findMatching(snapshot);
    if (optFuel.isPresent()) {
        inventories.add(furnaceInventory.getFuelSlot());
    }
    return inventories.isEmpty() ? getDefaultTarget(container, slot) :
            inventories.size() == 1 ? inventories.get(0) : inventories.get(0).union(inventories.get(1));
}
 

import org.spongepowered.api.item.inventory.ItemStackSnapshot; //导入依赖的package包/类
@SuppressWarnings("ConstantConditions")
@Override
public IShapelessCraftingRecipe build(String id, Object plugin) {
    checkState(this.resultProvider != null, "The result provider is not set.");
    checkState(!this.ingredients.isEmpty(), "The ingredients are not set.");
    checkNotNull(id, "id");
    checkNotNull(id, "plugin");

    final PluginContainer container = checkPlugin(plugin, "plugin");
    final int index = id.indexOf(':');
    if (index != -1) {
        final String pluginId = id.substring(0, index);
        checkState(pluginId.equals(container.getId()), "Plugin ids mismatch, "
                + "found %s in the id but got %s from the container", pluginId, container.getId());
        id = id.substring(index + 1);
    }

    final ItemStackSnapshot exemplary = this.resultProvider.getSnapshot(
            EmptyCraftingMatrix.INSTANCE, EmptyIngredientList.INSTANCE);
    return new LanternShapelessCraftingRecipe(container.getId(), id, exemplary,
            this.groupName, this.resultProvider, ImmutableList.copyOf(this.ingredients));
}
 

import org.spongepowered.api.item.inventory.ItemStackSnapshot; //导入依赖的package包/类
@Listener
public void onBlockCollide(CollideEvent.Impact event, @First Projectile projectile) {
  ProjectileSource source = projectile.getShooter();
  if (!(source instanceof Living)) {
    return;
  }

  Living sourceEntity = (Living) source;
  ItemStackSnapshot shootingItemStack = projectile.get(SHOOTING_ITEM_DATA_KEY).map(Optional::get).orElse(null);
  if (!applicabilityTest.test(sourceEntity, shootingItemStack)) {
    return;
  }

  if (cooldownHandler.canUseAbility(sourceEntity)) {
    cooldownHandler.useAbility(sourceEntity);
  } else {
    return;
  }

  attackCluster.getNextAbilityToRun().run(sourceEntity, event.getImpactPoint());
}
 

import org.spongepowered.api.item.inventory.ItemStackSnapshot; //导入依赖的package包/类
@Override
protected void init() {
    super.init();

    // Search for the underlying inventories
    this.output = query(Holder.CRAFTING_OUTPUT_OPERATION).first();
    this.grid = query(Holder.CRAFTING_GRID_OPERATION).first();

    // Add a change listener to update the output slot
    ((AbstractInventory) this.grid).addChangeListener(slot -> {
        final World world = getWorld();
        if (world == null) {
            return;
        }
        final Optional<CraftingResult> optResult = Lantern.getRegistry()
                .getCraftingRecipeRegistry().getResult(this.grid, getWorld());
        this.output.set(optResult
                .map(CraftingResult::getResult)
                .map(ItemStackSnapshot::createStack)
                .orElse(ItemStack.empty()));
    });
}
 

import org.spongepowered.api.item.inventory.ItemStackSnapshot; //导入依赖的package包/类
@Override
public ISmeltingRecipe build() {
    check();

    // Attempt to generate a id for the smelting recipe
    String ingredient = this.exemplaryIngredient.getType().getId();
    ingredient = ingredient.substring(ingredient.indexOf(':') + 1);
    final ItemStackSnapshot exemplaryResult = getResultProvider().get(this.exemplaryIngredient).getResult();
    String result = exemplaryResult.getType().getId();
    result = result.substring(result.indexOf(':') + 1);

    final String id = ingredient + "_to_" + result;
    final int count = idCounters.computeIfAbsent(id, s -> 0) + 1;
    idCounters.put(id, count);

    return build0(id + "_" + count, Lantern.getGame().getImplementationPlugin());
}