@occultus/task-api 0.18.1

package/LICENSE

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright © 2025 CTN Studios
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,6 @@
+# Star Tenon Task API
+
+> [!IMPORTANT]
+> 该包仍处于开发阶段，可能会有一些问题亟待修复
+
+本包提供了方便的、基于脚本表单实现的任务 API。

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@occultus/task-api",
+  "version": "0.18.1",
+  "description": "Star Tenon task api",
+  "main": "src/index.ts",
+  "keywords": [
+    "Minecraft",
+    "Occultus SDK",
+    "Script API"
+  ],
+  "contributors": [
+    "FangLimao <mucigames@outlook.com>"
+  ],
+  "license": "MIT",
+  "author": "CTN Studios",
+  "dependencies": {
+    "@occultus/format-api": "0.18.1",
+    "@occultus/entity-api": "0.18.1",
+    "@occultus/text-api": "0.18.1",
+    "@occultus/item-api": "0.18.2"
+  },
+  "peerDependencies": {
+    "@minecraft/server": "2.3.0-beta.1.21.110-preview.20",
+    "@minecraft/server-ui": "2.1.0-beta.1.21.110-preview.20",
+    "@occultus/core": ">=0.18.2 || <0.19.0"
+  },
+  "devDependencies": {
+    "typedoc": "^0.28.9"
+  }
+}

package/src/api/Task.ts

@@ -0,0 +1,131 @@
+import { parseText, parseToRaw, TextProvider } from "@occultus/text-api";
+import { Player } from "@minecraft/server";
+import { TaskOptions } from "../interface/TaskOptions";
+import { TaskStatus } from "../enum/TaskStaus";
+import { TaskGroup } from "./TaskGroup";
+import { TaskCenter } from "./TaskCenter";
+import { MessageFormData } from "@minecraft/server-ui";
+import { TaskUtils } from "../utils/TaskUtils";
+import { LockedScreen } from "../ui/LockedScreen";
+
+export class Task {
+  /**
+   * @param id 任务的唯一标识符
+   * @param name 任务名称
+   * @param description 任务描述
+   * @param options 任务的配置选项
+   */
+  constructor(
+    readonly id: string,
+    public name: TextProvider,
+    public description: TextProvider,
+    public options: TaskOptions
+  ) {}
+  /**
+   * 向玩家展示任务
+   * @param player 要展示任务的玩家
+   * @param backTo 关闭任务 UI 后返回的界面
+   */
+  display(player: Player, backTo?: Task | TaskCenter | TaskGroup) {
+    if (this.getStatus(player) === TaskStatus.Locked) {
+      this.lockedDisplay(player, backTo);
+      return;
+    }
+    const form = new MessageFormData();
+    form.title(parseText(this.name, player));
+    form.body(TaskUtils.generateTaskBody(this, player));
+    form.button1({ translate: "gui.back" });
+    if (this.getStatus(player) === TaskStatus.Done) {
+      // 任务已完成
+      form.button2({ translate: "ui.task.done" });
+    } else {
+      // 提交任务
+      form.button2({ translate: "ui.task.submit" });
+    }
+    form.show(player).then((result) => {
+      if (result.selection === 1) {
+        if (this.getStatus(player) === TaskStatus.Done) return;
+        if (this.checkConditions(player)) {
+          this.complete(player);
+          return;
+        }
+        player.sendMessage(TaskUtils.generateFailMessage(this, player));
+        return;
+      }
+      if (backTo) {
+        backTo.display(player);
+      }
+    });
+  }
+  /**
+   * 返回玩家是否可以在任务列表中看到该任务
+   * @param player 
+   * @return 倘若玩家可以在任务列表中看到该任务返回`true`，否则返回`false`
+   */
+  isVisible(player: Player): boolean {
+    if(this.isAvailable(player)) return true;
+    if(this.options.hiddenWhenLocked) return false;
+    return true;
+  }
+  isAvailable(player: Player): boolean {
+    if(this.getStatus(player) === TaskStatus.Done) return true;
+    if(this.options.previousTask === "none") return true;
+    if(this.options.previousTask.getStatus(player) === TaskStatus.Done) return true;
+    return false;
+  }
+  protected lockedDisplay(
+    player: Player,
+    backTo?: Task | TaskCenter | TaskGroup
+  ) {
+    const screen = LockedScreen.create(this, player);
+    screen.show(player).then((response) => {
+      if (this.options.previousTask === "none") return;
+      if (response.selection === 1) {
+        this.options.previousTask.display(player, this);
+      }
+      backTo?.display(player);
+    });
+  }
+  /**
+   * 获取任务状态
+   * @param player 要获取任务状态的玩家
+   * @return 玩家的任务状态
+   */
+  getStatus(player: Player): TaskStatus {
+    if (player.hasTag("done:" + this.id)) return TaskStatus.Done;
+    if (this.options.previousTask === "none") return TaskStatus.Undone;
+    if (this.options.previousTask.getStatus(player) === TaskStatus.Done) {
+      return TaskStatus.Undone;
+    }
+    return TaskStatus.Locked;
+  }
+  /**
+   * 检查玩家是否能完成任务
+   * @param player
+   * @returns
+   */
+  protected checkConditions(player: Player): boolean {
+    const conditions = this.options.conditions;
+    if (conditions.length === 0) return true;
+    return conditions.every((condition) => condition.check(player));
+  }
+  /**
+   * 向玩家给予奖励
+   * @param player
+   */
+  protected giveAwards(player: Player) {
+    this.options.awards.forEach((award) => award.give(player));
+  }
+  protected complete(player: Player) {
+    player.addTag("done:" + this.id);
+    this.giveAwards(player);
+    player.onScreenDisplay.setActionBar({
+      rawtext: [
+        // 你完成了任务：
+        { translate: "ui.task.complete" },
+        parseToRaw(this.name, player),
+      ],
+    });
+    player.playSound(this.options.completeSound ?? "random.levelup");
+  }
+}

package/src/api/TaskCenter.ts

@@ -0,0 +1,26 @@
+import { CustomCommand, Player } from "@minecraft/server";
+import { TextProvider } from "@occultus/text-api";
+import { TaskCenterOptions } from "../interface/TaskCenterOptions";
+import { TaskListScreen } from "../ui/TaskListScreen";
+import { TaskUtils } from "../utils/TaskUtils";
+
+export class TaskCenter {
+  constructor(
+    readonly id: string,
+    public name: TextProvider,
+    public description: TextProvider,
+    public options: TaskCenterOptions
+  ) {}
+  display(player: Player) {
+    const { screen, tasks } = TaskListScreen.create(this, player);
+    screen.show(player).then((response) => {
+      if (response.canceled) return;
+      if (response.selection === undefined) return;
+      tasks[response.selection].display(player, this);
+    });
+  }
+  addTrigger(itemComponent?: string, command?: CustomCommand) {
+    if (itemComponent) TaskUtils.registryComponent(itemComponent, this);
+    if (command) TaskUtils.registryCommand(command, this);
+  }
+}

package/src/api/TaskGroup.ts

@@ -0,0 +1,91 @@
+import { Player } from "@minecraft/server";
+import { parseToRaw, TextProvider } from "@occultus/text-api";
+import { TaskGroupOptions } from "../interface/TaskGroupOptions";
+import { TaskStatus } from "../enum/TaskStaus";
+import { ActionFormData, MessageFormData } from "@minecraft/server-ui";
+import { Task } from "./Task";
+import { TaskCenter } from "./TaskCenter";
+import { LockedScreen } from "../ui/LockedScreen";
+import { TaskListScreen } from "../ui/TaskListScreen";
+
+export class TaskGroup {
+  constructor(
+    readonly id: string,
+    public name: TextProvider,
+    public description: TextProvider,
+    public options: TaskGroupOptions
+  ) {}
+  display(player: Player, backTo?: Task | TaskCenter | TaskGroup) {
+    if (this.getStatus(player) === TaskStatus.Locked) {
+      this.lockedDisplay(player);
+      return;
+    }
+    const { screen, tasks } = TaskListScreen.create(this, player);
+    screen.show(player).then((response) => {
+      if (response.canceled) {
+        return backTo?.display(player);
+      }
+      if (response.selection === undefined) {
+        return backTo?.display(player);
+      }
+      if (response.selection === 0) {
+        if(this.hasOwnedAward(player)){
+          // 你已经领取过该奖励！
+          player.onScreenDisplay.setActionBar({translate: "ui.taskGroup.award.owned"})
+        }
+        if (this.getStatus(player) === TaskStatus.Done) {
+          this.giveAward(player);
+        }
+        return backTo?.display(player);
+      }
+      tasks[response.selection - 1].display(player, this);
+    });
+  }
+  isVisible(player: Player): boolean {
+    if (this.isAvailable(player)) return true;
+    if (this.options.hiddenWhenLocked) return false;
+    return true;
+  }
+  isAvailable(player: Player): boolean {
+    if (this.getStatus(player) === TaskStatus.Done) return true;
+    if (this.options.previousTask === "none") return true;
+    if (this.options.previousTask.getStatus(player) === TaskStatus.Done)
+      return true;
+    return false;
+  }
+  getStatus(player: Player): TaskStatus {
+    if (
+      this.options.tasks.every(
+        (task) => task.getStatus(player) === TaskStatus.Done
+      )
+    ) {
+      return TaskStatus.Done;
+    }
+    if (this.options.previousTask === "none") return TaskStatus.Undone;
+    if (this.options.previousTask.getStatus(player) === TaskStatus.Done)
+      return TaskStatus.Undone;
+    return TaskStatus.Locked;
+  }
+  hasOwnedAward(player: Player): boolean {
+    return player.hasTag(`taskGroup.${this.id}.award`);
+  }
+  ownAward(player: Player) {
+    player.addTag(`taskGroup.${this.id}.award`);
+  }
+  protected lockedDisplay(
+    player: Player,
+    backTo?: Task | TaskCenter | TaskGroup
+  ) {
+    const screen = LockedScreen.create(this, player);
+    screen.show(player).then((response) => {
+      if (this.options.previousTask === "none") return;
+      if (response.selection === 1) {
+        this.options.previousTask.display(player, this);
+      }
+      backTo?.display(player);
+    });
+  }
+  protected giveAward(player: Player) {
+    this.options.awards.forEach((award) => award.give(player));
+  }
+}

package/src/api/awards/ItemAwards.ts

@@ -0,0 +1,29 @@
+import { ItemStack, Player } from "@minecraft/server";
+import { TextProvider } from "@occultus/text-api";
+import { TaskAwards } from "./TaskAwards";
+import { giveItem } from "@occultus/entity-api";
+
+export class ItemAwards extends TaskAwards {
+  constructor(
+    protected itemType: string,
+    protected amount?: number
+  ) {
+    super(itemType);
+  }
+  getItem() {
+    return new ItemStack(this.itemType, this.amount);
+  }
+  give(player: Player) {
+    giveItem(player, this.getItem());
+  }
+  getTextProvider() {
+    const item = this.getItem();
+    return {
+      rawtext: [
+        { translate: item.localizationKey },
+        { text: " × " },
+        { text: item.amount.toString() },
+      ],
+    };
+  }
+}

package/src/api/awards/TaskAwards.ts

@@ -0,0 +1,23 @@
+import { Player } from "@minecraft/server";
+import { TextProvider } from "@occultus/text-api";
+
+/**
+ * 任务奖励抽象基类
+ * 
+ * 该类定义了游戏中任务奖励系统的基础结构，用于管理和分发各种类型的任务奖励，所有具体的奖励类型（如经验奖励、物品奖励、货币奖励等）都应继承此抽象类。
+ */
+export abstract class TaskAwards {
+  /**
+   * @param data 奖励数据
+   */
+  constructor(protected data: unknown) {}
+  /**
+   * 向玩家发放奖励
+   * @param player 
+   */
+  abstract give(player: Player): void;
+  /**
+   * 获取提示文本
+   */
+  abstract getTextProvider(): TextProvider;
+}

package/src/api/conditions/ItemConditions.ts

@@ -0,0 +1,52 @@
+import { ItemStack, Player } from "@minecraft/server";
+import { TaskConditions } from "./TaskConditions";
+import { getItemAmountInContainer } from "@occultus/item-api";
+
+/**
+ * 物品条件
+ */
+export class ItemConditions extends TaskConditions {
+  /**
+   * @param itemType 满足条件所需要的物品类型
+   * @param amount 满足条件所需要的物品数量，默认为 1
+   */
+  constructor(
+    protected itemType: string,
+    protected amount?: number
+  ) {
+    super(itemType);
+  }
+  getItem(){
+    return new ItemStack(this.itemType, this.amount)
+  }
+  check(player: Player) {
+    const container = player.getComponent("minecraft:inventory")?.container;
+    if (!container) return false;
+    const amount = getItemAmountInContainer(
+      container,
+      this.getItem().typeId
+    );
+    return amount >= this.getItem().amount;
+  }
+  getTextProvider(){
+    return {
+      rawtext: [
+        { translate: this.getItem().localizationKey },
+        { text: " × " },
+        { text: this.getItem().amount.toString() },
+      ],
+    };
+  };
+  getFailedReason(){
+    return {
+      rawtext: [
+        // 你缺少这些物品：
+        { translate: "task.condition.item.failed" },
+        { text: " " },
+        { translate: this.getItem().localizationKey },
+        { text: " × " },
+        { text: this.getItem().amount.toString() },
+      ],
+    }
+  };
+}

package/src/api/conditions/TaskConditions.ts

@@ -0,0 +1,35 @@
+import { Player } from "@minecraft/server";
+import { TextProvider } from "@occultus/text-api";
+
+/**
+ * 任务条件的抽象类
+ * 
+ * 定义了任务条件的基本结构和必须实现的方法，所有具体的任务条件类都应该继承此抽象类并实现其抽象方法
+ */
+export abstract class TaskConditions {
+  /**
+   * @param data 任务条件所需的数据
+   */
+  constructor(protected data: unknown) {}
+  
+  /**
+   * 检查玩家是否满足任务条件
+   * 
+   * @param player 要检查的玩家对象
+   * @return 如果玩家满足条件返回`true`，否则返回`false`
+   */
+  abstract check(player: Player): boolean;
+  
+  /**
+   * 获取任务条件的文本，该文本将会在任务面板中显示
+   * 
+   * @return 用于显示任务条件描述的文本
+   */
+  abstract getTextProvider(): TextProvider;
+  /**
+   * 获取条件检查失败时的原因说明文本
+   * 
+   * @return 用于显示失败原因的文本
+   */
+  abstract getFailedReason(): TextProvider;
+}

package/src/enum/TaskStaus.ts

@@ -0,0 +1,14 @@
+export enum TaskStatus {
+  /**
+   * 该任务/任务组前置任务未完成，已被锁定
+   */  
+  Locked = -1,
+  /**
+   * 该任务/任务组已经解锁，但并没有完成
+   */
+  Undone = 0,
+  /**
+   * 该任务/任务组已经完成
+   */
+  Done = 1,
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+export * from "./api/Task"
+export * from "./api/TaskGroup"
+export * from "./api/TaskCenter"
+export * from "./api/awards/ItemAwards"
+export * from "./api/awards/TaskAwards"
+export * from "./api/conditions/ItemConditions"
+export * from "./api/conditions/TaskConditions"
+export * from "./enum/TaskStaus"
+export * from "./interface/TaskCenterOptions"
+export * from "./interface/TaskGroupOptions"
+export * from "./interface/TaskOptions"

package/src/interface/TaskCenterOptions.ts

@@ -0,0 +1,14 @@
+import { Task } from "../api/Task";
+import { TaskGroup } from "../api/TaskGroup";
+
+/**
+ * 任务中心配置选项接口
+ */
+export interface TaskCenterOptions {
+  /**
+   * 任务中心中包含的所有任务和任务组列表
+   * 
+   * 可以是单个任务或任务组
+   */
+  tasks: (Task| TaskGroup)[];
+}

package/src/interface/TaskGroupOptions.ts

@@ -0,0 +1,34 @@
+import { TaskAwards } from "../api/awards/TaskAwards";
+import { Task } from "../api/Task";
+import { TaskGroup } from "../api/TaskGroup";
+
+/**
+ * 任务组配置选项接口
+ */
+export interface TaskGroupOptions {
+  /**
+   * 任务组中包含的任务列表
+   */
+  tasks: Task[];
+
+  /**
+   * 任务完成后的奖励列表
+   */
+  awards: TaskAwards[];
+
+  /**
+   * 前置任务，可以是单个任务、任务组或无前置任务
+   */
+  previousTask: Task | TaskGroup | "none";
+
+  /**
+   * 是否在锁定状态下隐藏任务组
+   * @default false
+   */
+  hiddenWhenLocked?: boolean;
+
+  /**
+   * 任务组的图标路径
+   */
+  iconPath?: string;
+}

package/src/interface/TaskOptions.ts

@@ -0,0 +1,46 @@
+import { TextProvider } from "@occultus/text-api";
+import { TaskAwards } from "../api/awards/TaskAwards";
+import { TaskConditions } from "../api/conditions/TaskConditions";
+import { Task } from "../api/Task";
+
+/**
+ * 任务配置选项接口
+ */
+export interface TaskOptions {
+  /**
+   * 任务完成后的奖励列表
+   */
+  awards: TaskAwards[];
+  
+  /**
+   * 任务完成所需满足的条件列表
+   */
+  conditions: TaskConditions[];
+  
+  /**
+   * 前置任务
+   * 可以是其他任务或无前置任务("none")
+   */
+  previousTask: Task | "none";
+  
+  /**
+   * 是否在锁定状态下隐藏该任务
+   * @default false
+   */
+  hiddenWhenLocked?: boolean;
+  
+  /**
+   * 任务完成时的音效资源路径
+   */
+  completeSound?: string;
+  
+  /**
+   * 任务提示信息
+   */
+  tips?: TextProvider;
+  
+  /**
+   * 任务图标的资源路径
+   */
+  iconPath?: string;
+}

package/src/ui/LockedScreen.ts

@@ -0,0 +1,30 @@
+import { MessageFormData } from "@minecraft/server-ui";
+import { Task } from "../api/Task";
+import { TaskGroup } from "../api/TaskGroup";
+import { Player } from "@minecraft/server";
+import { Format } from "@occultus/format-api";
+import { parseToRaw } from "@occultus/text-api";
+
+export class LockedScreen {
+  static create(task: Task | TaskGroup, player: Player): MessageFormData {
+    const previous = task.options.previousTask;
+    if (previous === "none") {
+      throw new Error("Previous task is not set");
+    }
+    const form = new MessageFormData();
+    // 任务未解锁
+    form.title({ translate: "task.locked" });
+    // 你需要完成以下任务来解锁这组任务：
+    form.body({
+      rawtext: [
+        { translate: "task.locked.body" },
+        { text: Format.newLine },
+        parseToRaw(previous.name, player),
+      ],
+    });
+    form.button1({ translate: "gui.back" });
+    // 前往完成
+    form.button2({ translate: "ui.task.goto" });
+    return form;
+  }
+}

package/src/ui/TaskListScreen.ts

@@ -0,0 +1,33 @@
+import { ActionFormData } from "@minecraft/server-ui";
+import { TaskCenter } from "../api/TaskCenter";
+import { TaskGroup } from "../api/TaskGroup";
+import { Player } from "@minecraft/server";
+import { parseToRaw } from "@occultus/text-api";
+import { Task } from "../api/Task";
+import { TaskUtils } from "../utils/TaskUtils";
+
+export class TaskListScreen {
+  private constructor(
+    readonly screen: ActionFormData,
+    readonly tasks: (Task | TaskGroup)[]
+  ) {}
+  static create(
+    origin: TaskCenter | TaskGroup,
+    player: Player
+  ): TaskListScreen {
+    const form = new ActionFormData();
+    form.title(parseToRaw(origin.name, player));
+    form.body(parseToRaw(origin.description, player));
+    if (origin instanceof TaskGroup) {
+      // 获取奖励
+      form.button({ translate: "" });
+    }
+    const tasks: (Task | TaskGroup)[] = [];
+    origin.options.tasks.forEach((task) => {
+      if (!task.isVisible(player)) return;
+      form.button(TaskUtils.getTaskListButtonName(task, player), task.options.iconPath);
+      tasks.push(task);
+    });
+    return { screen: form, tasks: tasks };
+  }
+}

package/src/utils/TaskUtils.ts

@@ -0,0 +1,116 @@
+import {
+  CustomCommand,
+  CustomCommandSource,
+  CustomCommandStatus,
+  Player,
+  RawMessage,
+  system,
+} from "@minecraft/server";
+import { Task } from "../api/Task";
+import { parseToRaw } from "@occultus/text-api";
+import { Format, Color } from "@occultus/format-api";
+import { TaskStatus } from "../enum/TaskStaus";
+import { TaskGroup } from "../api/TaskGroup";
+import { TaskCenter } from "../api/TaskCenter";
+
+export class TaskUtils {
+  static generateTaskBody(task: Task, player: Player): RawMessage {
+    let texts: RawMessage[] = [];
+    texts.push(parseToRaw(task.description, player));
+    texts.push({ text: Format.newLine }, { text: Format.newLine });
+    // 提示：
+    if (task.options.tips) {
+      texts.push(
+        { translate: "ui.task.tips" },
+        parseToRaw(task.options.tips, player)
+      );
+      texts.push({ text: Format.newLine });
+    }
+
+    // 完成条件：
+    texts.push({ translate: "ui.task.condition" });
+    task.options.conditions.forEach((condition) => {
+      texts.push(parseToRaw(condition.getTextProvider(), player));
+    });
+    texts.push({ text: Format.newLine });
+
+    // 奖励：
+    texts.push({ translate: "ui.task.award" });
+    task.options.awards.forEach((award) => {
+      texts.push(parseToRaw(award.getTextProvider(), player));
+    });
+    texts.push({ text: Format.newLine });
+
+    return {
+      rawtext: texts,
+    };
+  }
+  static generateFailMessage(task: Task, player: Player): RawMessage {
+    let texts: RawMessage[] = [];
+    // 你无法提交该任务，因为：
+    texts.push({ translate: "ui.task.failed_reason" });
+    task.options.conditions.forEach((condition) => {
+      if (condition.check(player)) return;
+      // eg. 你没有获取 114514 个方漓猫
+      texts.push(parseToRaw(condition.getFailedReason(), player));
+    });
+    return {
+      rawtext: texts,
+    };
+  }
+  static getTaskListButtonName(
+    task: Task | TaskGroup,
+    player: Player
+  ): RawMessage {
+    const raw: RawMessage[] = [];
+    if (task.getStatus(player) === TaskStatus.Done) {
+      raw.push({ text: Color.darkGreen });
+      raw.push({ text: "✔" });
+      raw.push({ text: Format.reset }, { text: "" });
+    }
+    raw.push(parseToRaw(task.name, player));
+    return { rawtext: raw };
+  }
+  static generateGroupAwardButton(task: TaskGroup, player: Player): RawMessage {
+    const raw: RawMessage[] = [];
+    if (task.hasOwnedAward(player)) {
+      raw.push({ text: Color.darkGreen });
+      raw.push({ text: "✔" });
+      raw.push({ text: Format.reset }, { text: "" });
+    }
+    raw.push({ translate: "ui.task.getAward" });
+    return { rawtext: raw };
+  }
+  static registryComponent(componentName: string, center: TaskCenter) {
+    system.beforeEvents.startup.subscribe((arg) => {
+      arg.itemComponentRegistry.registerCustomComponent(componentName, {
+        onUse(arg0) {
+          center.display(arg0.source);
+        },
+      });
+    });
+  }
+  static registryCommand(command: CustomCommand, center: TaskCenter) {
+    system.beforeEvents.startup.subscribe((arg) => {
+      arg.customCommandRegistry.registerCommand(command, (origin) => {
+        system.run(() => {
+          if (origin.sourceType !== CustomCommandSource.Entity)
+            return {
+              status: CustomCommandStatus.Failure,
+            };
+          if (!(origin.sourceEntity instanceof Player))
+            return {
+              status: CustomCommandStatus.Failure,
+            };
+          center.display(origin.sourceEntity);
+          return {
+            status: CustomCommandStatus.Success,
+          };
+        });
+        return {
+          status: CustomCommandStatus.Failure,
+        };
+      });
+    });
+  }
+}