@occultus/toolkit 0.23.4 → 0.24.0

package/src/entity/health.ts

@@ -1,71 +1,71 @@
-import {
-  Entity,
-  EntityComponentTypes,
-  EntityHealthComponent
-} from "@minecraft/server";
-import { OccultusSDKError } from "@occultus/core";
-
-export class EntityHealthUtils {
-  private readonly component: EntityHealthComponent;
-  public constructor(entity: Entity) {
-    this.component =
-      entity.getComponent(EntityComponentTypes.Health) ??
-      (() => {
-        throw new OccultusSDKError(
-          `Entity ${entity.typeId} (id ${entity.id}) 没有 EntityHealthComponent!`
-        );
-      })();
-  }
-  // 对于 component 方法的重载，便于直接代替原来的 component
-  public get current() {
-    return this.component.currentValue;
-  }
-  public set current(value: number) {
-    this.component.setCurrentValue(value);
-  }
-  public get default() {
-    return this.component.defaultValue;
-  }
-  public get max() {
-    return this.component.effectiveMax;
-  }
-  public get min() {
-    return this.component.effectiveMin;
-  }
-  public reset() {
-    this.component.resetToDefaultValue();
-  }
-  public setMax() {
-    this.component.resetToMaxValue();
-  }
-  public setMin() {
-    this.component.resetToMinValue();
-  }
-  // 重载结束
-  /**
-   * 恢复实体的生命值
-   * @param amount 恢复的生命值。小于 0 时为未定义行为
-   * @return 治愈后的生命值
-   */
-  public heal(value: number): number {
-    const newValue = this.current + value;
-    return (this.current = Math.min(newValue, this.max));
-  }
-  /**
-   * 消耗实体生命值，这一行为不会被视为攻击
-   * @param value 伤害大小。小于 0 时为未定义行为
-   * @returns
-   */
-  public damage(value: number) {
-    const newValue = this.current - value;
-    return (this.current = Math.max(newValue, this.min));
-  }
-  /**
-   * 以指定倍率消耗实体的生命值，这一行为不会被视为攻击
-   * @param amplifier 消耗生命的倍率，例如`0.8`将会被视为消耗实体当前 80% 的生命值
-   * @returns
-   */
-  public damageWithAmplifier(amplifier: number): number {
-    return this.damage(this.current * amplifier);
-  }
-}
+import {
+  Entity,
+  EntityComponentTypes,
+  EntityHealthComponent
+} from "@minecraft/server";
+import { OccultusSDKError } from "@occultus/core";
+
+export class EntityHealthUtils {
+  private readonly component: EntityHealthComponent;
+  public constructor(entity: Entity) {
+    this.component =
+      entity.getComponent(EntityComponentTypes.Health) ??
+      (() => {
+        throw new OccultusSDKError(
+          `Entity ${entity.typeId} (id ${entity.id}) 没有 EntityHealthComponent!`
+        );
+      })();
+  }
+  // 对于 component 方法的重载，便于直接代替原来的 component
+  public get current() {
+    return this.component.currentValue;
+  }
+  public set current(value: number) {
+    this.component.setCurrentValue(value);
+  }
+  public get default() {
+    return this.component.defaultValue;
+  }
+  public get max() {
+    return this.component.effectiveMax;
+  }
+  public get min() {
+    return this.component.effectiveMin;
+  }
+  public reset() {
+    this.component.resetToDefaultValue();
+  }
+  public setMax() {
+    this.component.resetToMaxValue();
+  }
+  public setMin() {
+    this.component.resetToMinValue();
+  }
+  // 重载结束
+  /**
+   * 恢复实体的生命值
+   * @param amount 恢复的生命值。小于 0 时为未定义行为
+   * @return 治愈后的生命值
+   */
+  public heal(value: number): number {
+    const newValue = this.current + value;
+    return (this.current = Math.min(newValue, this.max));
+  }
+  /**
+   * 消耗实体生命值，这一行为不会被视为攻击
+   * @param value 伤害大小。小于 0 时为未定义行为
+   * @returns
+   */
+  public damage(value: number) {
+    const newValue = this.current - value;
+    return (this.current = Math.max(newValue, this.min));
+  }
+  /**
+   * 以指定倍率消耗实体的生命值，这一行为不会被视为攻击
+   * @param amplifier 消耗生命的倍率，例如`0.8`将会被视为消耗实体当前 80% 的生命值
+   * @returns
+   */
+  public damageWithAmplifier(amplifier: number): number {
+    return this.damage(this.current * amplifier);
+  }
+}

package/src/identifier/namespace.ts

@@ -1,23 +1,23 @@
-/**
- * 确保命名空间存在，若不存在则自动加上`minecraft:`命名空间
- * @param identifier 要检查的标识符
- * @return 存在命名空间的标识符
- */
-export function ensureNamespace(identifier: string): string {
-  if (identifier.includes(":")) {
-    return identifier;
-  }
-  return `minecraft:${identifier}`;
-}
-
-/**
- * 确保命名空间**不**存在，若存在则自动去掉命名空间
- * @param identifier 要检查的标识符
- * @return 不存在命名空间的标识符
- */
-export function ensureNoNamespace(identifier: string): string {
-  if (identifier.includes(":")) {
-    return identifier.split(":")[1];
-  }
-  return identifier;
-}
+/**
+ * 确保命名空间存在，若不存在则自动加上`minecraft:`命名空间
+ * @param identifier 要检查的标识符
+ * @return 存在命名空间的标识符
+ */
+export function ensureNamespace(identifier: string): string {
+  if (identifier.includes(":")) {
+    return identifier;
+  }
+  return `minecraft:${identifier}`;
+}
+
+/**
+ * 确保命名空间**不**存在，若存在则自动去掉命名空间
+ * @param identifier 要检查的标识符
+ * @return 不存在命名空间的标识符
+ */
+export function ensureNoNamespace(identifier: string): string {
+  if (identifier.includes(":")) {
+    return identifier.split(":")[1];
+  }
+  return identifier;
+}

package/src/index.ts

@@ -1,9 +1,10 @@
-/**
- * @module toolkit
- */
-export * from "./entity/EntitiesUtils";
-export * from "./entity/entityUtils";
-export * from "./item/item";
-export * from "./item/container";
-export * from "./identifier/namespace";
-export * from "./item/cooldown";
+/**
+ * @module toolkit
+ */
+export * from "./entity/EntitiesUtils";
+export * from "./entity/entityUtils";
+export * from "./entity/health";
+export * from "./item/item";
+export * from "./item/container";
+export * from "./identifier/namespace";
+export * from "./item/cooldown";

package/src/item/container.ts

@@ -1,227 +1,227 @@
-import { Container, EquipmentSlot, ItemStack, Player } from "@minecraft/server";
-import {
-  getContainer,
-  getEquipmentItem,
-  setEquipmentItem
-} from "../entity/entityUtils";
-
-/**
- * 获取容器中指定含指定物品标签的物品的数量
- * @param container 容器对象
- * @param tag 要获取的物品标签
- * @returns 容器中指定物品的数量
- * @author RawDiamondMC, FangLiulii
- */
-
-export function getTagItemAmountInContainer(
-  container: Container,
-  tag: string
-): number {
-  let amount = 0;
-  for (let slot = 0; slot < container.size; slot++) {
-    const itemStack: undefined | ItemStack = container.getItem(slot);
-    if (itemStack?.hasTag(tag)) {
-      amount += itemStack.amount;
-    }
-  }
-  return amount;
-}
-
-/**
- * 从容器中移除指定数量的含有特定标签的物品
- * @param container 容器对象
- * @param tag 物品标签
- * @param amount 要移除物品的数量
- * @author RawDiamondMC, FangLiulii
- */
-export function removeTagItemInContainer(
-  container: Container,
-  tag: string,
-  amount: number
-): void {
-  for (let slot = 0; slot < container.size; slot++) {
-    const itemStack: undefined | ItemStack = container.getItem(slot);
-    if (itemStack?.hasTag(tag)) {
-      if (itemStack.amount > amount) {
-        itemStack.amount -= amount;
-        container.setItem(slot, itemStack);
-        return;
-      }
-      container.setItem(slot);
-      amount -= itemStack.amount;
-    }
-  }
-}
-
-/**
- * 获取容器中指定物品的数量
- * @param container 容器对象
- * @param typeId 要获取的物品 ID
- * @returns 容器中指定物品的数量
- * @author RawDiamondMC
- */
-
-export function getItemAmountInContainer(
-  container: Container,
-  typeId: string
-): number {
-  let amount = 0;
-  for (let slot = 0; slot < container.size; slot++) {
-    const itemStack: undefined | ItemStack = container.getItem(slot);
-    if (itemStack?.typeId === typeId) {
-      amount += itemStack.amount;
-    }
-  }
-  return amount;
-}
-
-/**
- * 获取玩家身上的所有物品（包含装备栏与副手）
- * @param player 玩家对象
- * @param typeId 要获取的物品 ID
- * @returns 容器中指定物品的数量
- * @author RawDiamondMC
- */
-
-export function getItemAmountOfPlayer(player: Player, typeId: string): number {
-  const container = player.getComponent("minecraft:inventory")?.container;
-  if (!container) return 0;
-  let amount = getItemAmountInContainer(container, typeId);
-  // 不包含主手，防止重复计算
-  const slots = [
-    EquipmentSlot.Head,
-    EquipmentSlot.Chest,
-    EquipmentSlot.Legs,
-    EquipmentSlot.Feet,
-    EquipmentSlot.Offhand
-  ];
-  for (const slot of slots) {
-    const itemStack = getEquipmentItem(player, slot);
-    if (itemStack?.typeId === typeId) {
-      amount += itemStack.amount;
-    }
-  }
-  return amount;
-}
-
-/**
- * 从容器中移除指定数量的物品
- * @param container 容器对象
- * @param typeId 物品 ID
- * @param amount 要移除物品的数量
- * @returns 未能够移除完的物品数量
- * @author RawDiamondMC
- */
-export function removeItemInContainer(
-  container: Container,
-  typeId: string,
-  amount: number
-): number {
-  for (let slot = 0; slot < container.size; slot++) {
-    // 物品已经移除完毕
-    if (amount <= 0) return 0;
-    const itemStack: undefined | ItemStack = container.getItem(slot);
-    if (itemStack?.typeId === typeId) {
-      // 这个槽位的物品数量足够移除
-      if (itemStack.amount > amount) {
-        itemStack.amount -= amount;
-        container.setItem(slot, itemStack);
-        // 直接返回，因为肯定移除完毕了
-        return 0;
-      }
-      container.setItem(slot);
-      amount -= itemStack.amount;
-    }
-  }
-  return amount;
-}
-
-/**
- * 从玩家身上移除一定量的物品
- * @param player 玩家对象
- * @param typeId 物品 ID
- * @param amount 要移除物品的数量
- * @returns 未能够移除完的物品数量
- * @author RawDiamondMC
- */
-export function removeItemOfPlayer(
-  player: Player,
-  typeId: string,
-  amount: number
-): number {
-  // 玩家肯定得有inventory组件
-  let remaining = removeItemInContainer(getContainer(player)!, typeId, amount);
-  // 已经移除完毕
-  if (remaining <= 0) return 0;
-  // 不包含主手，防止重复计算
-  const slots = [
-    EquipmentSlot.Head,
-    EquipmentSlot.Chest,
-    EquipmentSlot.Legs,
-    EquipmentSlot.Feet,
-    EquipmentSlot.Offhand
-  ];
-  for (const slot of slots) {
-    // 物品已经移除完毕
-    if (remaining <= 0) return 0;
-    const itemStack = getEquipmentItem(player, slot);
-    if (itemStack?.typeId === typeId) {
-      // 这个槽位的物品数量足够移除
-      if (itemStack.amount > remaining) {
-        itemStack.amount -= remaining;
-        setEquipmentItem(player, itemStack, slot);
-        // 直接返回，因为肯定移除完毕了
-        return 0;
-      }
-      setEquipmentItem(player, itemStack, slot);
-      remaining -= itemStack.amount;
-    }
-  }
-  return remaining;
-}
-
-/**
- * 在容器中查找替换物品
- * @param item 要替换的物品，如果为`undefined`，则替换所有空槽
- * @param newItem 替换后的物品，如果为`undefined`，则清空所有物品
- * @param container 要搜索的容器
- * @author RawDiamondMC
- */
-export function replaceItemStack(
-  item: ItemStack | undefined,
-  newItem: ItemStack | undefined,
-  container: Container
-): number {
-  let amount = 0;
-  for (let slot = 0; slot < container.size; slot++) {
-    const itemStack: undefined | ItemStack = container.getItem(slot);
-    if (itemStack?.typeId === item?.typeId) {
-      container.setItem(slot, newItem);
-      amount++;
-    }
-  }
-  return amount;
-}
-
-/**
- * 在容器中根据标签查找替换物品
- * @param itemTag 要替换的物品标签
- * @param newItem 替换后的物品，如果为`undefined`，则清空所有物品
- * @param container 要搜索的容器
- */
-
-export function replaceItemByTag(
-  itemTag: string,
-  newItem: ItemStack | undefined,
-  container: Container
-): number {
-  let amount = 0;
-  for (let slot = 0; slot < container.size; slot++) {
-    const itemStack: undefined | ItemStack = container.getItem(slot);
-    if (itemStack?.hasTag(itemTag)) {
-      container.setItem(slot, newItem);
-      amount++;
-    }
-  }
-  return amount;
-}
+import { Container, EquipmentSlot, ItemStack, Player } from "@minecraft/server";
+import {
+  getContainer,
+  getEquipmentItem,
+  setEquipmentItem
+} from "../entity/entityUtils";
+
+/**
+ * 获取容器中指定含指定物品标签的物品的数量
+ * @param container 容器对象
+ * @param tag 要获取的物品标签
+ * @returns 容器中指定物品的数量
+ * @author RawDiamondMC, FangLiulii
+ */
+
+export function getTagItemAmountInContainer(
+  container: Container,
+  tag: string
+): number {
+  let amount = 0;
+  for (let slot = 0; slot < container.size; slot++) {
+    const itemStack: undefined | ItemStack = container.getItem(slot);
+    if (itemStack?.hasTag(tag)) {
+      amount += itemStack.amount;
+    }
+  }
+  return amount;
+}
+
+/**
+ * 从容器中移除指定数量的含有特定标签的物品
+ * @param container 容器对象
+ * @param tag 物品标签
+ * @param amount 要移除物品的数量
+ * @author RawDiamondMC, FangLiulii
+ */
+export function removeTagItemInContainer(
+  container: Container,
+  tag: string,
+  amount: number
+): void {
+  for (let slot = 0; slot < container.size; slot++) {
+    const itemStack: undefined | ItemStack = container.getItem(slot);
+    if (itemStack?.hasTag(tag)) {
+      if (itemStack.amount > amount) {
+        itemStack.amount -= amount;
+        container.setItem(slot, itemStack);
+        return;
+      }
+      container.setItem(slot);
+      amount -= itemStack.amount;
+    }
+  }
+}
+
+/**
+ * 获取容器中指定物品的数量
+ * @param container 容器对象
+ * @param typeId 要获取的物品 ID
+ * @returns 容器中指定物品的数量
+ * @author RawDiamondMC
+ */
+
+export function getItemAmountInContainer(
+  container: Container,
+  typeId: string
+): number {
+  let amount = 0;
+  for (let slot = 0; slot < container.size; slot++) {
+    const itemStack: undefined | ItemStack = container.getItem(slot);
+    if (itemStack?.typeId === typeId) {
+      amount += itemStack.amount;
+    }
+  }
+  return amount;
+}
+
+/**
+ * 获取玩家身上的所有物品（包含装备栏与副手）
+ * @param player 玩家对象
+ * @param typeId 要获取的物品 ID
+ * @returns 容器中指定物品的数量
+ * @author RawDiamondMC
+ */
+
+export function getItemAmountOfPlayer(player: Player, typeId: string): number {
+  const container = player.getComponent("minecraft:inventory")?.container;
+  if (!container) return 0;
+  let amount = getItemAmountInContainer(container, typeId);
+  // 不包含主手，防止重复计算
+  const slots = [
+    EquipmentSlot.Head,
+    EquipmentSlot.Chest,
+    EquipmentSlot.Legs,
+    EquipmentSlot.Feet,
+    EquipmentSlot.Offhand
+  ];
+  for (const slot of slots) {
+    const itemStack = getEquipmentItem(player, slot);
+    if (itemStack?.typeId === typeId) {
+      amount += itemStack.amount;
+    }
+  }
+  return amount;
+}
+
+/**
+ * 从容器中移除指定数量的物品
+ * @param container 容器对象
+ * @param typeId 物品 ID
+ * @param amount 要移除物品的数量
+ * @returns 未能够移除完的物品数量
+ * @author RawDiamondMC
+ */
+export function removeItemInContainer(
+  container: Container,
+  typeId: string,
+  amount: number
+): number {
+  for (let slot = 0; slot < container.size; slot++) {
+    // 物品已经移除完毕
+    if (amount <= 0) return 0;
+    const itemStack: undefined | ItemStack = container.getItem(slot);
+    if (itemStack?.typeId === typeId) {
+      // 这个槽位的物品数量足够移除
+      if (itemStack.amount > amount) {
+        itemStack.amount -= amount;
+        container.setItem(slot, itemStack);
+        // 直接返回，因为肯定移除完毕了
+        return 0;
+      }
+      container.setItem(slot);
+      amount -= itemStack.amount;
+    }
+  }
+  return amount;
+}
+
+/**
+ * 从玩家身上移除一定量的物品
+ * @param player 玩家对象
+ * @param typeId 物品 ID
+ * @param amount 要移除物品的数量
+ * @returns 未能够移除完的物品数量
+ * @author RawDiamondMC
+ */
+export function removeItemOfPlayer(
+  player: Player,
+  typeId: string,
+  amount: number
+): number {
+  // 玩家肯定得有inventory组件
+  let remaining = removeItemInContainer(getContainer(player)!, typeId, amount);
+  // 已经移除完毕
+  if (remaining <= 0) return 0;
+  // 不包含主手，防止重复计算
+  const slots = [
+    EquipmentSlot.Head,
+    EquipmentSlot.Chest,
+    EquipmentSlot.Legs,
+    EquipmentSlot.Feet,
+    EquipmentSlot.Offhand
+  ];
+  for (const slot of slots) {
+    // 物品已经移除完毕
+    if (remaining <= 0) return 0;
+    const itemStack = getEquipmentItem(player, slot);
+    if (itemStack?.typeId === typeId) {
+      // 这个槽位的物品数量足够移除
+      if (itemStack.amount > remaining) {
+        itemStack.amount -= remaining;
+        setEquipmentItem(player, itemStack, slot);
+        // 直接返回，因为肯定移除完毕了
+        return 0;
+      }
+      setEquipmentItem(player, itemStack, slot);
+      remaining -= itemStack.amount;
+    }
+  }
+  return remaining;
+}
+
+/**
+ * 在容器中查找替换物品
+ * @param item 要替换的物品，如果为`undefined`，则替换所有空槽
+ * @param newItem 替换后的物品，如果为`undefined`，则清空所有物品
+ * @param container 要搜索的容器
+ * @author RawDiamondMC
+ */
+export function replaceItemStack(
+  item: ItemStack | undefined,
+  newItem: ItemStack | undefined,
+  container: Container
+): number {
+  let amount = 0;
+  for (let slot = 0; slot < container.size; slot++) {
+    const itemStack: undefined | ItemStack = container.getItem(slot);
+    if (itemStack?.typeId === item?.typeId) {
+      container.setItem(slot, newItem);
+      amount++;
+    }
+  }
+  return amount;
+}
+
+/**
+ * 在容器中根据标签查找替换物品
+ * @param itemTag 要替换的物品标签
+ * @param newItem 替换后的物品，如果为`undefined`，则清空所有物品
+ * @param container 要搜索的容器
+ */
+
+export function replaceItemByTag(
+  itemTag: string,
+  newItem: ItemStack | undefined,
+  container: Container
+): number {
+  let amount = 0;
+  for (let slot = 0; slot < container.size; slot++) {
+    const itemStack: undefined | ItemStack = container.getItem(slot);
+    if (itemStack?.hasTag(itemTag)) {
+      container.setItem(slot, newItem);
+      amount++;
+    }
+  }
+  return amount;
+}