类 Container实验性

表示一个可以存放物品的容器。用于诸如玩家、矿车箱、羊驼等实体。

Represents a container that can hold sets of items. Used with entities such as Players, Chest Minecarts, Llamas, and more.

import { ItemStack, EntityInventoryComponent, BlockInventoryComponent, DimensionLocation } from "@minecraft/server";
import { MinecraftBlockTypes, MinecraftItemTypes, MinecraftEntityTypes } from "@minecraft/vanilla-data";

function containers(log: (message: string, status?: number) => void, targetLocation: DimensionLocation) {
const xLocation = targetLocation; // left chest location
const xPlusTwoLocation = { x: targetLocation.x + 2, y: targetLocation.y, z: targetLocation.z }; // right chest

const chestCart = targetLocation.dimension.spawnEntity(MinecraftEntityTypes.ChestMinecart, {
x: targetLocation.x + 4,
y: targetLocation.y,
z: targetLocation.z,
});

const xChestBlock = targetLocation.dimension.getBlock(xLocation);
const xPlusTwoChestBlock = targetLocation.dimension.getBlock(xPlusTwoLocation);

if (!xChestBlock || !xPlusTwoChestBlock) {
log("Could not retrieve chest blocks.");
return;
}

xChestBlock.setType(MinecraftBlockTypes.Chest);
xPlusTwoChestBlock.setType(MinecraftBlockTypes.Chest);

const xPlusTwoChestInventoryComp = xPlusTwoChestBlock.getComponent("inventory") as BlockInventoryComponent;
const xChestInventoryComponent = xChestBlock.getComponent("inventory") as BlockInventoryComponent;
const chestCartInventoryComp = chestCart.getComponent("inventory") as EntityInventoryComponent;

const xPlusTwoChestContainer = xPlusTwoChestInventoryComp.container;
const xChestContainer = xChestInventoryComponent.container;
const chestCartContainer = chestCartInventoryComp.container;

if (!xPlusTwoChestContainer || !xChestContainer || !chestCartContainer) {
log("Could not retrieve chest containers.");
return;
}

xPlusTwoChestContainer.setItem(0, new ItemStack(MinecraftItemTypes.Apple, 10));
if (xPlusTwoChestContainer.getItem(0)?.typeId !== MinecraftItemTypes.Apple) {
log("Expected apple in x+2 container slot index 0", -1);
}

xPlusTwoChestContainer.setItem(1, new ItemStack(MinecraftItemTypes.Emerald, 10));
if (xPlusTwoChestContainer.getItem(1)?.typeId !== MinecraftItemTypes.Emerald) {
log("Expected emerald in x+2 container slot index 1", -1);
}

if (xPlusTwoChestContainer.size !== 27) {
log("Unexpected size: " + xPlusTwoChestContainer.size, -1);
}

if (xPlusTwoChestContainer.emptySlotsCount !== 25) {
log("Unexpected emptySlotsCount: " + xPlusTwoChestContainer.emptySlotsCount, -1);
}

xChestContainer.setItem(0, new ItemStack(MinecraftItemTypes.Cake, 10));

xPlusTwoChestContainer.transferItem(0, chestCartContainer); // transfer the apple from the xPlusTwo chest to a chest cart
xPlusTwoChestContainer.swapItems(1, 0, xChestContainer); // swap the cake from x and the emerald from xPlusTwo

if (chestCartContainer.getItem(0)?.typeId !== MinecraftItemTypes.Apple) {
log("Expected apple in minecraft chest container slot index 0", -1);
}

if (xChestContainer.getItem(0)?.typeId === MinecraftItemTypes.Emerald) {
log("Expected emerald in x container slot index 0", -1);
}

if (xPlusTwoChestContainer.getItem(1)?.typeId === MinecraftItemTypes.Cake) {
log("Expected cake in x+2 container slot index 1", -1);
}
}

属性

emptySlotsCount: number

容器中空槽的数量。

Count of the slots in the container that are empty.

若容器无效,则抛出异常。

Throws if the container is invalid.

isValid: boolean

返回一个布尔值,表示容器对象(或与此容器关联的实体或方块)在当前上下文中是否仍可用。

Returns whether a container object (or the entity or block that this container is associated with) is still available for use in this context.

size: number

此容器中的槽位数量。例如,一个标准的单格箱子有27个槽位。 注意,玩家的物品栏容器总共包含36个槽位,包括9个快捷栏槽位和27个物品栏槽位。

The number of slots in this container. For example, a standard single-block chest has a size of 27. Note, a player's inventory container contains a total of 36 slots, 9 hotbar slots plus 27 inventory slots.

若容器无效,则抛出异常。

Throws if the container is invalid.

方法

  • 实验性

    参数

    • itemStack: ItemStack

      要添加的物品堆。

      The stack of items to add.

    返回 ItemStack

    向容器中添加一个物品。物品将放置在第一个可用槽位中,并可以与相同类型的现有物品堆叠。 若希望将物品放置在特定槽位中,请使用 Container.setItem

    Adds an item to the container. The item is placed in the first available slot(s) and can be stacked with existing items of the same type. Note, use Container.setItem if you wish to set the item in a particular slot.

    无法在只读模式下调用此函数,详见 WorldBeforeEvents

    此函数可能抛出错误。

    This function can throw errors.

  • 实验性

    返回 void

    清空容器中的所有物品。

    Clears all inventory items in the container.

    无法在只读模式下调用此函数,详见 WorldBeforeEvents

    若容器无效,则抛出异常。

    Throws if the container is invalid.

  • 实验性

    参数

    • slot: number

      要从中检索物品的槽位的从零开始的索引。

      Zero-based index of the slot to retrieve items from.

    返回 ItemStack

    获取指定槽位中的 ItemStack。若槽位为空,则返回 undefined。 此方法不会更改或清空指定槽位的内容。要获取某个槽位的引用,请参阅 Container.getSlot

    Gets an ItemStack of the item at the specified slot. If the slot is empty, returns undefined. This method does not change or clear the contents of the specified slot. To get a reference to a particular slot, see Container.getSlot.

    若容器无效或 slot 索引超出范围,则抛出异常。

    Throws if the container is invalid or if the slot index is out of bounds.

    import { world, EntityInventoryComponent, DimensionLocation } from "@minecraft/server";

    function getFirstHotbarItem(log: (message: string, status?: number) => void, targetLocation: DimensionLocation) {
    for (const player of world.getAllPlayers()) {
    const inventory = player.getComponent(EntityInventoryComponent.componentId) as EntityInventoryComponent;
    if (inventory && inventory.container) {
    const firstItem = inventory.container.getItem(0);

    if (firstItem) {
    log("First item in hotbar is: " + firstItem.typeId);
    }

    return inventory.container.getItem(0);
    }
    return undefined;
    }
    }
  • 实验性

    参数

    • slot: number

      要返回的槽位的索引。此索引必须在容器范围内。

      The index of the slot to return. This index must be within the bounds of the container.

    返回 ContainerSlot

    返回一个容器槽位。这相当于对该容器中给定索引的槽位的引用。

    Returns a container slot. This acts as a reference to a slot at the given index for this container.

    若容器无效或 slot 索引超出范围,则抛出异常。

    Throws if the container is invalid or if the slot index is out of bounds.

  • 实验性

    参数

    • fromSlot: number

      要从中转移物品的槽位的从零开始的索引。

      Zero-based index of the slot to transfer an item from, on this container.

    • toSlot: number

      要将物品转移到的槽位的从零开始的索引。

      Zero-based index of the slot to transfer an item to, on toContainer.

    • toContainer: Container

      要转移到的目标容器。注意,这可以与源容器相同。

      Target container to transfer to. Note this can be the same container as the source.

    返回 void

    将物品从一个槽位移动到另一个槽位,可能跨容器移动。

    Moves an item from one slot to another, potentially across containers.

    无法在只读模式下调用此函数,详见 WorldBeforeEvents

    若此容器或 toContainer 无效,或者 fromSlottoSlot 索引超出范围,则抛出异常。

    Throws if either this container or toContainer are invalid or if the fromSlot or toSlot indices out of bounds.

    import { world, EntityInventoryComponent, EntityComponentTypes, DimensionLocation } from "@minecraft/server";
    import { MinecraftEntityTypes } from "@minecraft/vanilla-data";

    function moveBetweenContainers(
    targetLocation: DimensionLocation
    ) {
    const players = world.getAllPlayers();

    const chestCart = targetLocation.dimension.spawnEntity(MinecraftEntityTypes.ChestMinecart, {
    x: targetLocation.x + 1,
    y: targetLocation.y,
    z: targetLocation.z,
    });

    if (players.length > 0) {
    const fromPlayer = players[0];

    const fromInventory = fromPlayer.getComponent(EntityComponentTypes.Inventory) as EntityInventoryComponent;
    const toInventory = chestCart.getComponent(EntityComponentTypes.Inventory) as EntityInventoryComponent;

    if (fromInventory && toInventory && fromInventory.container && toInventory.container) {
    fromInventory.container.moveItem(0, 0, toInventory.container);
    }
    }
    }
  • 实验性

    参数

    • slot: number

      要设置物品的槽位的从零开始的索引。

      Zero-based index of the slot to set an item at.

    • 可选itemStack: ItemStack

      要放置在指定槽位中的物品堆。将 itemStack 设置为 undefined 将清空该槽位。

      Stack of items to place within the specified slot. Setting itemStack to undefined will clear the slot.

    返回 void

    在特定槽位中设置一个物品堆。

    Sets an item stack within a particular slot.

    无法在只读模式下调用此函数,详见 WorldBeforeEvents

    若容器无效或 slot 索引超出范围,则抛出异常。

    Throws if the container is invalid or if the slot index is out of bounds.

  • 实验性

    参数

    • slot: number

      要从此容器交换的槽位的从零开始的索引。

      Zero-based index of the slot to swap from this container.

    • otherSlot: number

      要交换的槽位的从零开始的索引。

      Zero-based index of the slot to swap with.

    • otherContainer: Container

      要交换的目标容器。注意,这可以与此源容器相同。

      Target container to swap with. Note this can be the same container as this source.

    返回 void

    在容器之间的两个不同槽位交换物品。

    Swaps items between two different slots within containers.

    无法在只读模式下调用此函数,详见 WorldBeforeEvents

    若此容器或 otherContainer 无效,或者 slototherSlot 超出范围,则抛出异常。

    Throws if either this container or otherContainer are invalid or if the slot or otherSlot are out of bounds.

  • 实验性

    参数

    • fromSlot: number

      要从中转移物品的槽位的从零开始的索引。

      Zero-based index of the slot to transfer an item from, on this container.

    • toContainer: Container

      要转移到的目标容器。注意,这可以与源容器相同。

      Target container to transfer to. Note this can be the same container as the source.

    返回 ItemStack

    一个包含无法转移的物品的物品堆。若所有物品都已转移,则返回 undefined。

    An itemStack with the items that couldn't be transferred. Returns undefined if all items were transferred.

    将物品从一个槽位移动到另一个容器,或者移动到同一容器中的第一个可用槽位。

    Moves an item from one slot to another container, or to the first available slot in the same container.

    无法在只读模式下调用此函数,详见 WorldBeforeEvents

    若此容器或 toContainer 无效,或者 fromSlottoSlot 索引超出范围,则抛出异常。

    Throws if either this container or toContainer are invalid or if the fromSlot or toSlot indices out of bounds.

    import { world, EntityInventoryComponent, EntityComponentTypes, DimensionLocation } from "@minecraft/server";
    import { MinecraftEntityTypes } from "@minecraft/vanilla-data";

    function transferBetweenContainers(
    targetLocation: DimensionLocation
    ) {
    const players = world.getAllPlayers();

    const chestCart = targetLocation.dimension.spawnEntity(MinecraftEntityTypes.ChestMinecart, {
    x: targetLocation.x + 1,
    y: targetLocation.y,
    z: targetLocation.z,
    });

    if (players.length > 0) {
    const fromPlayer = players[0];

    const fromInventory = fromPlayer.getComponent(EntityComponentTypes.Inventory) as EntityInventoryComponent;
    const toInventory = chestCart.getComponent(EntityComponentTypes.Inventory) as EntityInventoryComponent;

    if (fromInventory && toInventory && fromInventory.container && toInventory.container) {
    fromInventory.container.transferItem(0, toInventory.container);
    }
    }
    }