keystonemc 1.0.0 → 1.1.0

package/dist/core/event/eventManager.d.ts

@@ -0,0 +1,33 @@
+import { world } from '@minecraft/server';
+import { Listener } from './types';
+/**
+ * AfterEventMap / BeforeEventMap を world.afterEvents / world.beforeEvents の
+ * subscribe のハンドラ引数から自動抽出する。
+ *
+ * 例: world.afterEvents.playerSpawn.subscribe((ev: PlayerSpawnAfterEvent) => {...})
+ *    の ev の型を自動的に E として取り出す。
+ */
+type ExtractSubscribeArg<T> = T extends {
+    subscribe: (handler: (ev: infer E) => any) => any;
+} ? E : never;
+export type AfterEventMap = {
+    [K in keyof typeof world.afterEvents]: ExtractSubscribeArg<(typeof world.afterEvents)[K]>;
+};
+export type BeforeEventMap = {
+    [K in keyof typeof world.beforeEvents]: ExtractSubscribeArg<(typeof world.beforeEvents)[K]>;
+};
+type AfterEventName = keyof AfterEventMap;
+type BeforeEventName = keyof BeforeEventMap;
+export declare class EventManager {
+    private static afterListeners;
+    private static beforeListeners;
+    /** init: world.beforeEvents / world.afterEvents を全自動で subscribe して dispatch に流す */
+    static initialize(): void;
+    static registerAfter<K extends AfterEventName>(eventName: K, listener: Listener<AfterEventMap[K]>): void;
+    static registerBefore<K extends BeforeEventName>(eventName: K, listener: Listener<BeforeEventMap[K]>): void;
+    private static dispatchAfter;
+    private static dispatchBefore;
+    /** 登録済みリスナーを全部クリア（Plugin 単位で実装するなら拡張する） */
+    private static clearAll;
+}
+export {};

package/dist/core/event/flow.d.ts

@@ -0,0 +1,18 @@
+interface WaitForOptions {
+    onInterval?: () => void;
+    onTimeout?: () => void;
+    interval?: number;
+    timeout?: number;
+    resolveOnInterval?: boolean;
+    resolveOnTimeout?: boolean;
+}
+/**
+ * イベントを条件付きで待機（タイムアウト付き）
+ */
+export declare function waitFor<T extends object>(predicate: (event: T) => boolean, options?: WaitForOptions): Promise<T>;
+/**
+ * 複数イベントを束ねて非同期フローを開始
+ * すべてのイベントで、Entityを自動検出
+ */
+export declare function flowListen<E extends object>(...args: any[]): void;
+export {};

package/dist/core/event/priority.d.ts

@@ -0,0 +1,8 @@
+export declare enum Priority {
+    LOWEST = 5,
+    LOW = 4,
+    NORMAL = 3,
+    HIGH = 2,
+    HIGHEST = 1,
+    MONITOR = 0
+}

package/dist/core/event/types.d.ts

@@ -0,0 +1,6 @@
+import { Priority } from './priority';
+/** リスナー型 */
+export interface Listener<T> {
+    handler(event: T): void;
+    priority?: Priority;
+}

package/dist/core/index.d.ts

@@ -0,0 +1,7 @@
+export { keystone } from './keystone';
+export { Vector3 } from './math/vector3';
+export { AxisAlignedBB } from './math/axisAlignedBB';
+export { Priority } from './event/priority';
+export { EventManager } from './event/eventManager';
+export { debug } from './utils/debugger';
+export { RepeatingTimer, DelayedTimer, repeating, delayed, sleep } from './timer/timer';

package/dist/core/keystone.d.ts

@@ -0,0 +1,5 @@
+declare class Keystone {
+    constructor();
+}
+export declare const keystone: Keystone;
+export {};

package/dist/core/math/axisAlignedBB.d.ts

@@ -0,0 +1,114 @@
+import { AABB, Vector3 } from '@minecraft/server';
+export declare class AxisAlignedBB implements AABB {
+    center: Vector3;
+    extent: Vector3;
+    constructor(center: Vector3, extent: Vector3);
+    /**
+     * 最小点最大点からオブジェクト化
+     * @param min
+     * @param max
+     * @returns {AxisAlignedBB}
+     */
+    static fromMinMax(min: Vector3, max: Vector3): AxisAlignedBB;
+    /**
+     * 大きさ1のAABB生成
+     * @returns {AxisAlignedBB}
+     */
+    static one(): AxisAlignedBB;
+    /**
+     * {center, extent} オブジェクトから生成
+     * @param aabb
+     * @returns {AxisAlignedBB}
+     */
+    static fromBDS(aabb: AABB): AxisAlignedBB;
+    /**
+     * 最小点
+     * @returns {Vector3}
+     */
+    get min(): Vector3;
+    /**
+     * 最大点
+     * @returns {Vector3}
+     */
+    get max(): Vector3;
+    /**
+     * オフセット
+     * @param dx
+     * @param dy
+     * @param dz
+     * @returns {AxisAlignedBB}
+     */
+    offset(dx: number, dy: number, dz: number): AxisAlignedBB;
+    /**
+     * 拡大
+     * @param dx
+     * @param dy
+     * @param dz
+     * @returns {AxisAlignedBB}
+     */
+    expand(dx: number, dy: number, dz: number): AxisAlignedBB;
+    /**
+     * 縮小
+     * @param dx
+     * @param dy
+     * @param dz
+     * @returns {AxisAlignedBB}
+     */
+    contract(dx: number, dy: number, dz: number): AxisAlignedBB;
+    /**
+     * 接触判定
+     * @param other
+     * @param epsilon
+     * @returns {boolean}
+     */
+    intersects(other: AxisAlignedBB, epsilon?: number): boolean;
+    /**
+     * 対象座標が内包されているか
+     * @param v
+     * @returns {boolean}
+     */
+    contains(v: Vector3): boolean;
+    /**
+     * Xの長さ
+     * @returns {number}
+     */
+    getXLength(): number;
+    /**
+     * Yの長さ
+     * @returns {number}
+     */
+    getYLength(): number;
+    /**
+     * Zの長さ
+     * @returns {number}
+     */
+    getZLength(): number;
+    /**
+     * 体積
+     * @returns {number}
+     */
+    getVolume(): number;
+    /**
+     * キューブ判定
+     * @param epsilon
+     * @returns {boolean}
+     */
+    isCube(epsilon?: number): boolean;
+    /**
+     * BDS ScriptAPIで使える {center, extent} 形式に変換
+     * @returns {AABB}
+     */
+    toBDS(): AABB;
+    /**
+     * オブジェクトに変換
+     */
+    toObject(): {
+        center: Vector3;
+        extent: Vector3;
+    };
+    /**
+     * toString
+     * @returns {string}
+     */
+    toString(): string;
+}

package/dist/core/math/vector3.d.ts

@@ -0,0 +1,225 @@
+import { Vector3 as _Vector3 } from '@minecraft/server';
+export declare class Vector3 {
+    x: number;
+    y: number;
+    z: number;
+    constructor(x: number, y: number, z: number);
+    /**
+     * ゼロベクトルで生成
+     * @return {Vector3}
+     */
+    static zero(): Vector3;
+    /**
+     * {x, y, z} オブジェクトから生成
+     * @param pos
+     * @returns {Vector3}
+     */
+    static fromBDS(pos: _Vector3): Vector3;
+    /**
+     * x
+     * @returns {number}
+     */
+    getX(): number;
+    /**
+     * y
+     * @returns {number}
+     */
+    getY(): number;
+    /**
+     * z
+     * @returns {number}
+     */
+    getZ(): number;
+    /**
+     * x (整数値)
+     * @returns {number}
+     */
+    getFloorX(): number;
+    /**
+     * y (整数値)
+     * @returns {number}
+     */
+    getFloorY(): number;
+    /**
+     * z (整数値)
+     * @returns {number}
+     */
+    getFloorZ(): number;
+    /**
+     * 加算
+     * @param x
+     * @param y
+     * @param z
+     * @return {Vector3}
+     */
+    add(x: number, y: number, z: number): Vector3;
+    /**
+     * ベクトル単位での加算
+     * @param v
+     * @returns {Vector3}
+     */
+    addVector(v: _Vector3): Vector3;
+    /**
+     * 減算
+     * @param x
+     * @param y
+     * @param z
+     * @return {Vector3}
+     */
+    subtract(x: number, y: number, z: number): Vector3;
+    /**
+     * ベクトル単位での減算
+     * @param v
+     * @return {Vector3}
+     */
+    subtractVector(v: _Vector3): Vector3;
+    /**
+     * 乗算
+     * @param value
+     * @return {Vector3}
+     */
+    multiply(value: number): Vector3;
+    /**
+     * 除算
+     * @param value
+     * @return {Vector3}
+     */
+    divide(value: number): Vector3;
+    /**
+     * ベクトルの内部数値小数点切り上げ
+     * @return {Vector3}
+     */
+    ceil(): Vector3;
+    /**
+     * ベクトルの内部数値小数点切り捨て
+     * @return {Vector3}
+     */
+    floor(): Vector3;
+    /**
+     * ベクトルの内部数値小数点四捨五入
+     * @param precision
+     * @return {Vector3}
+     */
+    round(precision?: number): Vector3;
+    /**
+     * ベクトルの内部数値の絶対値
+     * @return {Vector3}
+     */
+    abs(): Vector3;
+    /**
+     * 指定した2点間のユークリッド距離
+     * @param pos
+     * @return {number}
+     */
+    distance(pos: _Vector3): number;
+    /**
+     * 指定した2点間のユークリッド距離の2乗
+     * @param pos
+     * @return {number}
+     */
+    distanceSquared(pos: _Vector3): number;
+    /**
+     * 内積
+     * @param pos
+     * @return {number}
+     */
+    dot(pos: _Vector3): number;
+    /**
+     * 外積
+     * @param pos
+     * @return {Vector3}
+     */
+    cross(pos: _Vector3): Vector3;
+    /**
+     * ベクトルの比較
+     * @param pos
+     * @return {boolean}
+     */
+    equals(pos: _Vector3): boolean;
+    /**
+     * ベクトルの長さ
+     * @return {number}
+     */
+    length(): number;
+    /**
+     * ベクトルの長さの2乗
+     * @return {number}
+     */
+    lengthSquared(): number;
+    /**
+     * 正規化
+     * @return {Vector3}
+     */
+    normalize(): Vector3;
+    /**
+     * オブジェクトの数値指定再生成
+     * @param x
+     * @param y
+     * @param z
+     * @return {Vector3}
+     */
+    withComponents(x?: number, y?: number, z?: number): Vector3;
+    /**
+   * X座標をxValueにしたとき線分上に存在する点を返す
+   * @param end 終点
+   * @param xValue 途中点のX値
+   * @returns {Vector3|undefined}
+   */
+    getIntermediateWithXValue(end: Vector3, xValue: number): Vector3 | undefined;
+    /**
+     * Y座標をyValueにしたとき線分上に存在する点を返す
+     * @param end 終点
+     * @param yValue 途中点のY値
+     * @returns {Vector3|undefined}
+     */
+    getIntermediateWithYValue(end: Vector3, yValue: number): Vector3 | undefined;
+    /**
+     * Z座標をzValueにしたとき線分上に存在する点を返す
+     * @param end 終点
+     * @param zValue 途中点のZ値
+     * @returns {Vector3|undefined}
+     */
+    getIntermediateWithZValue(end: Vector3, zValue: number): Vector3 | undefined;
+    /**
+     * BDS ScriptAPIで使える {x, y, z} 形式に変換
+     * @returns {_Vector3}
+     */
+    toBDS(): _Vector3;
+    /**
+     * オブジェクトに変換
+     */
+    toObject(): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /**
+     * toString
+     * @returns {string}
+     */
+    toString(): string;
+    /**
+     * 最大点
+     * @param vector
+     * @param vectors
+     * @returns {Vector3}
+     */
+    static maxComponents(vector: _Vector3, ...vectors: _Vector3[]): Vector3;
+    /**
+     * 最小点
+     * @param vector
+     * @param vectors
+     * @returns {Vector3}
+     */
+    static minComponents(vector: _Vector3, ...vectors: _Vector3[]): Vector3;
+    /**
+     * 合計
+     * @param vectors
+     * @returns {Vector3}
+     */
+    static sum(...vectors: {
+        x: number;
+        y: number;
+        z: number;
+    }[]): Vector3;
+}

package/dist/core/timer/timer.d.ts

@@ -0,0 +1,94 @@
+/**
+ * ============================================================
+ * マスター Interval（負荷分散スケジューラ）
+ * ============================================================
+ */
+export declare class TimerScheduler {
+    private static tasks;
+    private static tick;
+    private static started;
+    /** スケジューラにタスクを登録 */
+    static addTask(task: () => void): void;
+    /** タスクを削除 */
+    static removeTask(task: () => void): void;
+    /** Interval を開始（1 本だけ） */
+    private static ensureStarted;
+}
+/** 内部キャンセル結果 */
+declare enum CancelResult {
+    SUCCESS = 0,
+    FORCE = 1,
+    FAILURE = 2
+}
+/**
+ * ============================================================
+ * Base Timer
+ * ============================================================
+ * スケジューラに登録され、tick ごとに管理される抽象クラス
+ */
+declare abstract class Timer {
+    protected currentTick: number;
+    protected onRun?: (currentTick: number) => void;
+    protected onCancel?: () => void;
+    protected stopped: boolean;
+    protected canceled: boolean;
+    protected forceCanceled: boolean;
+    /** スケジューラに登録されたタスク */
+    protected task?: () => void;
+    constructor(onRun?: (currentTick: number) => void, onCancel?: () => void);
+    /** 開始（各派生クラスで実装） */
+    abstract start(): void;
+    /** 一時停止 */
+    stop(): void;
+    /** 再開 */
+    resume(): void;
+    /** 停止しているか */
+    isStopped(): boolean;
+    /** キャンセル要求 */
+    cancel(force?: boolean): void;
+    /** タイマー内部キャンセル */
+    protected internalCancel(force?: boolean): CancelResult;
+}
+export interface RepeatingOptions {
+    period?: number;
+    endless?: boolean;
+    silenceOnStop?: boolean;
+    maxElapsedTicks?: number;
+    onFinal?: () => void;
+}
+/**
+ * 一定間隔で実行される繰り返しタイマー
+ */
+export declare class RepeatingTimer extends Timer {
+    private period;
+    private endless;
+    private silenceOnStop;
+    private maxElapsedTicks?;
+    private onFinal?;
+    constructor(onRun?: (currentTick: number) => void, opts?: RepeatingOptions, onCancel?: () => void);
+    /** タイマー開始 */
+    start(): void;
+}
+export interface DelayedOptions {
+    delay?: number;
+}
+/**
+ * 指定 tick 後に一度だけ実行されるタイマー
+ */
+export declare class DelayedTimer extends Timer {
+    private delay;
+    constructor(onRun?: (currentTick: number) => void, opts?: DelayedOptions, onCancel?: () => void);
+    start(): void;
+}
+export declare function repeating(opts: {
+    every?: number;
+    endless?: boolean;
+    max?: number;
+    silenceWhenStopped?: boolean;
+    run?: (tick: number) => void;
+    cancel?: () => void;
+    final?: () => void;
+}): RepeatingTimer;
+export declare function delayed(ticks: number, run: () => void, cancel?: () => void): DelayedTimer;
+export declare function sleep(tick: number): Promise<void>;
+export {};

package/dist/core/utils/debugger.d.ts

@@ -0,0 +1 @@
+export declare function debug(...args: any[]): void;