yoni-mcscripts-lib/yoni/remix/Location.js

为 Minecraft Script API 中的部分接口创建了 wrapper，并提供简单的事件管理器和任务管理器，另附有一些便于代码编写的一些小工具。

import { Minecraft } from "../basis.js";
import { Dimension } from "./dimension.js";
import { getNumber as getFiniteNumber } from "../lib/getNumber.js";
/**
 * 代表Minecraft中的特定位置，其中包含维度，坐标，旋转角。
 */
export class Location {
    static #zero;
    /**
     * 处于零点的Location对象。
     */
    static get zero() {
        if (Location.#zero === undefined)
            Location.#zero = new Location(0, 0, 0);
        return Location.#zero.clone();
    }
    static #checkReadOnly(location) {
        if (location.#readOnly) {
            throw new TypeError("Read-only Location Object");
        }
    }
    static normalizePitch(num) {
        num = getFiniteNumber(num);
        num += 180;
        num = num % 360;
        num -= 180;
        return num;
    }
    static normalizeYaw(num) {
        num = getFiniteNumber(num);
        num += 180;
        num = num % 360;
        num -= 180;
        return num;
    }
    #readOnly = false;
    get readOnly() {
        return this.#readOnly;
    }
    // @ts-ignore
    #dimension = null;
    #x = NaN;
    #y = NaN;
    #z = NaN;
    #rx = 0;
    #ry = 0;
    /**
     * 设置此位置对应的 z 轴坐标。
     * @param x
     * @returns 返回此位置本身。
     */
    setX(x) {
        Location.#checkReadOnly(this);
        this.#x = getFiniteNumber(x);
        return this;
    }
    /**
     * 设置此位置对应的 z 轴坐标。
     * @param y
     * @returns 返回此位置本身。
     */
    setY(y) {
        Location.#checkReadOnly(this);
        this.#y = getFiniteNumber(y);
        return this;
    }
    /**
     * 设置此位置对应的 z 轴坐标。
     * @param z
     * @returns 返回此位置本身。
     */
    setZ(z) {
        Location.#checkReadOnly(this);
        this.#z = getFiniteNumber(z);
        return this;
    }
    setPosition(...args) {
        let x, y, z;
        if (args.length === 1)
            ({ x, y, z } = args[0]);
        else
            ([x, y, z] = args);
        this.x = x;
        this.y = y;
        this.z = z;
        return this;
    }
    /**
     * 设置此位置对应的 pitch 角。
     * @param rx
     * @returns 返回此位置本身。
     */
    setRx(rx) {
        Location.#checkReadOnly(this);
        this.#rx = Location.normalizePitch(rx);
        return this;
    }
    /**
     * 设置此位置对应的 yaw 角。
     * @param {number} v
     */
    setRy(ry) {
        Location.#checkReadOnly(this);
        this.#ry = Location.normalizeYaw(ry);
        return this;
    }
    setRotation(...args) {
        let x, y;
        if (args.length === 1)
            ({ x, y } = args[0]);
        else
            ([x, y] = args);
        this.rx = x;
        this.ry = y;
        return this;
    }
    /**
     * 设置此位置所在的维度
     * @param dim
     */
    setDimension(dim) {
        Location.#checkReadOnly(this);
        this.#dimension = Dimension.toDimension(dim);
        return this;
    }
    get x() {
        return this.#x;
    }
    set x(x) {
        this.setX(x);
    }
    get y() {
        return this.#y;
    }
    set y(y) {
        this.setY(y);
    }
    get z() {
        return this.#z;
    }
    set z(z) {
        this.setZ(z);
    }
    get rx() {
        return this.#rx;
    }
    set rx(rx) {
        this.setRx(rx);
    }
    get ry() {
        return this.#ry;
    }
    set ry(ry) {
        this.setRy(ry);
    }
    /**
     * 此位置所处的维度。
     */
    get dimension() {
        return this.#dimension;
    }
    set dimension(dim) {
        this.setDimension(dim);
    }
    //魔法代码，用于快速复制Location对象
    static #magicCloneSymbol = { x: 0, y: 0, z: 0 };
    /**
     * 创建一个代表MC中特定位置的对象。其中包括维度，坐标，旋转角。
     
     * 可以以多种形式传递参数来构造一个Location。
     * 例如，大部分原版中需要一个位置的值。（Block, Entity）
     * 符合${link Vector3}的对象也可以传入。
     *
     * 参数传递顺序一般遵循以下规则：
     *
     * - 先维度，后坐标，最后旋转角。
     *
     * - 坐标先x，之后是y，最后是z，必须连续指定。
     *
     * - 旋转角先是rx，后是ry，必须连续指定。
     *
     * 至少需要传入可以表示一个坐标的参数。
     *
     * 如果传入的参数中并不能读取到特定的值，则使用默认值补充。
     *
     * 注意，现在允许的参数类型中，包含尚未支持的类型 {@link Rotation}，这是因为我想支持这种，但是还没支持，先写了上去。
     */
    constructor(...values) {
        //使用此标志以加快复制对象的速度
        if (arguments[0] === Location.#magicCloneSymbol)
            return;
        let { x, y, z, rx, ry, dimension } = makeLocation(values);
        this.setPosition(x, y, z);
        if (rx !== undefined) {
            this.rx = rx;
        }
        if (ry !== undefined) {
            this.ry = ry;
        }
        if (dimension == null) {
            this.setDimension("minecraft:overworld");
        }
        else {
            this.setDimension(dimension);
        }
    }
    add(value) {
        let { x, y, z } = makeLocation([value]);
        let location = this.clone();
        location.x += x;
        location.y += y;
        location.z += z;
        return location;
    }
    subtract(value) {
        let { x, y, z } = makeLocation([value]);
        let location = this.clone();
        location.x -= x;
        location.y -= y;
        location.z -= z;
        return location;
    }
    multiply(value) {
        let { x, y, z } = makeLocation([value]);
        let location = this.clone();
        location.x *= x;
        location.y *= y;
        location.z *= z;
        return location;
    }
    /**
     * 复制一个Location对象，然后将坐标设置为原点。
     */
    zero() {
        let location = this.clone();
        location.x = 0;
        location.y = 0;
        location.z = 0;
        return location;
    }
    /**
     * 计算此坐标与指定位置的距离。
     */
    distance(loc) {
        let distance = this.distanceSquared(loc);
        return Math.sqrt(distance);
    }
    distanceSquared(loc) {
        let fromLocation = makeLocation([loc]);
        let { x, y, z } = this;
        let distance = 0;
        distance += Math.abs(fromLocation.x ** 2 - x ** 2);
        distance += Math.abs(fromLocation.y ** 2 - y ** 2);
        distance += Math.abs(fromLocation.z ** 2 - z ** 2);
        return distance;
    }
    getLength() {
        return this.distance(Location.zero);
    }
    getLengthSquared() {
        return this.distanceSquared(Location.zero);
    }
    /**
     * @param {number} v
     */
    toFixed(v) {
        let { dimension, x, y, z, rx, ry } = this;
        let loc = this.clone();
        return loc.setX(x.toFixed(v))
            .setY(y.toFixed(v))
            .setZ(z.toFixed(v))
            .setRx(rx.toFixed(v))
            .setRy(ry.toFixed(v));
    }
    toVector() {
        return this.getVanillaVector();
    }
    getDirection() {
        throw new Error("not implemented yet");
    }
    setDirection() {
        throw new Error("not implemented yet");
    }
    /**
     * @returns 此位置上的方块。
     */
    getBlock() {
        return this.dimension.getBlock(this);
    }
    getBlockX() {
        return Math.floor(this.x);
    }
    getBlockY() {
        return Math.floor(this.y);
    }
    getBlockZ() {
        return Math.floor(this.z);
    }
    /**
     * 返回一个取整后的坐标，且旋转角为0
     */
    toBlockLocation() {
        const location = this.clone();
        const { x, y, z, rx, ry } = location;
        location.x = Math.floor(x);
        location.y = Math.floor(y);
        location.z = Math.floor(z);
        location.rx = 0;
        location.ry = 0;
        return location;
    }
    /**
     * 返回一个在此坐标上进行指定偏移后的Location
     * @param {number} x
     * @param {number} y
     * @param {number} z
     */
    offset(x, y, z) {
        const location = this.clone();
        location.x += x;
        location.y += y;
        location.z += z;
        return location;
    }
    /**
     * @returns {Minecraft.BlockLocation} 根据此位置创建一个原版的Minecraft.BlockLocation
     */
    getVanillaBlockLocation() {
        let { x, y, z } = this;
        x = Math.floor(x);
        y = Math.floor(y);
        z = Math.floor(z);
        return { x, y, z };
    }
    /**
     * @returns {Minecraft.Location} 根据此位置创建一个原版的Minecraft.Location
     */
    getVanillaLocation() {
        let { x, y, z } = this;
        return { x, y, z };
    }
    /**
     * @returns {Minecraft.DimensionLocation} 根据此位置创建一个原版的 Minecraft.DimensionLocation
     */
    getVanillaDimensionLocation() {
        const { x, y, z, dimension } = this;
        return { x, y, z, dimension: dimension.vanillaDimension };
    }
    getVanillaVector() {
        let { x, y, z } = this;
        return new Minecraft.Vector(x, y, z);
    }
    isLoaded() {
        try {
            this.getBlock();
            return true;
        }
        catch {
            return false;
        }
    }
    getChunk() {
        throw new Error("not implemented yet");
    }
    checkFinite() {
        throw new Error("not implemented yet");
    }
    /**
     * 判断传入的位置是否与此位置对象代表的位置相同。
     */
    equals(loc) {
        let fromLocation = new Location(loc);
        let { x, y, z, rx, ry, dimension } = this;
        return fromLocation.x === x
            && fromLocation.y === y
            && fromLocation.z === z
            && fromLocation.rx === rx
            && fromLocation.ry === ry
            && fromLocation.dimension === dimension;
    }
    /**
     * 判断传入的位置的坐标是否与此位置对象代表的坐标相同。
     */
    equalsPosition(loc) {
        let fromLocation = new Location(loc);
        let { x, y, z } = this;
        return fromLocation.x === x
            && fromLocation.y === y
            && fromLocation.z === z;
    }
    clone() {
        const location = new Location(Location.#magicCloneSymbol);
        location.#x = this.#x;
        location.#y = this.#y;
        location.#z = this.#z;
        location.#rx = this.#rx;
        location.#ry = this.#ry;
        location.#dimension = this.#dimension;
        return location;
    }
    toString() {
        return "Location: " + JSON.stringify(this);
    }
    toJSON() {
        let { x, y, z, rx, ry } = this;
        let dimension = this.dimension.id;
        return { x, y, z, rx, ry, dimension };
    }
    static fromBlock(block) {
        return new Location(block.dimension, block.x, block.y, block.z, 0, 0);
    }
    /**
     * 将一个Location对象转换为一段字符串
     * @param {Location} v
     * @returns {string}
     */
    static serialize(v) {
        return JSON.stringify(v);
    }
    /**
     * 将一段由Location对象转换后的字符串转换为Location对象
     * @param {string} v
     * @returns {Location}
     */
    static deserialize(v) {
        return new Location(JSON.parse(v));
    }
    /**
     * 创建一个只读的Location对象。
     * @returns {Readonly<Location>}
     */
    static createReadonly(...values) {
        //@ts-ignore
        const location = new Location(...values);
        location.#readOnly = true;
        return location;
    }
    /**
     * 使用Location创建创建一个只读的Location对象。
     * @param {Location} location
     * @returns {Readonly<Location>}
     */
    static makeReadonly(location) {
        location = location.clone();
        location.#readOnly = true;
        return location;
    }
    static blocksBetween(start, end) {
        let startPoint = new Location(start).toBlockLocation();
        let endPoint = new Location(end).toBlockLocation();
        let { x0, x1, y0, y1, z0, z1 } = (function () {
            let { x: x2, y: y2, z: z2 } = startPoint;
            let { x: x3, y: y3, z: z3 } = endPoint;
            let x0, x1, y0, y1, z0, z1;
            x0 = Math.min(x2, x3);
            y0 = Math.min(y2, y3);
            z0 = Math.min(z2, z3);
            x1 = Math.max(x2, x3);
            y1 = Math.max(y2, y3);
            z1 = Math.max(z2, z3);
            return { x0, x1, y0, y1, z0, z1 };
        })();
        let offset = Location.zero;
        startPoint = startPoint.zero()
            .add([x0, y0, z0]);
        endPoint = endPoint.zero()
            .add([x1, y1, z1]);
        let areaSize = endPoint.subtract(startPoint)
            .add([1, 1, 1]);
        let blocks = [];
        for (let x = 0; x < areaSize.x; x++) {
            for (let y = 0; y < areaSize.y; y++) {
                for (let z = 0; z < areaSize.z; z++) {
                    blocks.push(startPoint.add([x, y, z]));
                }
            }
        }
        return blocks;
    }
}
import { FunctionParamsOverrides } from "../lib/FunctionParamsOverrides.js";
const overrides = new FunctionParamsOverrides();
function requireDimensionValue(argc, args) {
    const value = args[0];
    return Dimension.isDimensionValue(value);
}
function requireVector3Object(argc, args) {
    const { x, y, z } = args[0];
    return "number" === typeof x
        && "number" === typeof y
        && "number" === typeof z;
}
function requireVector3Array(argc, args) {
    const vec3arr = args[0];
    const x = vec3arr[0];
    const y = vec3arr[1];
    const z = vec3arr[2];
    return "number" === typeof x
        && "number" === typeof y
        && "number" === typeof z;
}
function requireVector3(argc, args) {
    return requireVector3Array(1, [args]);
}
function requireVector2Object(argc, args) {
    const { x, y } = args[0];
    return "number" === typeof x
        && "number" === typeof y;
}
function requireVector2Array(argc, args) {
    const vec2arr = args[0];
    const x = vec2arr[0];
    const y = vec2arr[1];
    return "number" === typeof x
        && "number" === typeof y;
}
function requireVector2(argc, args) {
    return requireVector2Array(1, [args]);
}
function requireRotation(argc, args) {
    const { rx, ry } = args[0];
    return "number" === typeof rx
        && "number" === typeof ry;
}
function requireObjectWithDimensionAndCoords(argc, args) {
    return requireDimensionValue(1, [args[0].dimension])
        && requireVector3Object(1, [args[0].location]);
}
function requireObjectWithDimensionAndVector3(argc, args) {
    return requireDimensionValue(1, [args[0].dimension])
        && requireVector3Object(1, args);
}
function requireArrayWithVector3AndVector2(argc, args) {
    const loc = args[0];
    return requireVector3(3, Array.prototype.slice.call(args[0], 0, 3))
        && requireVector2(2, Array.prototype.slice.call(args[0], 3, 2));
}
function requireArrayWithDimensionAndVector3(argc, args) {
    const loc = args[0];
    return requireDimensionValue(1, args[0])
        && requireVector3(3, Array.prototype.slice.call(args[0], 1, 3));
}
function requireEntityObject(argc, args) {
    const entity = args[0];
    let { location, dimension, rotation } = entity;
    if (!rotation && "function" === typeof entity.getRotation) {
        try {
            rotation = entity.getRotation();
        }
        catch {
            //no thing to do
        }
    }
    return location && rotation && dimension
        && requireVector3Object(1, [location])
        && requireVector2Object(1, [rotation])
        && requireDimensionValue(1, [dimension]);
}
function requireBlockObject(argc, args) {
    const block = args[0];
    return block && block.dimension
        && requireVector3Object(1, [block])
        && requireDimensionValue(1, [block.dimension]);
}
function requireObjectWithPositionAndRotationObject(argc, args) {
    const object = args[0];
    let { location, rotation } = object;
    if (!rotation && "function" === typeof object.getRotation) {
        try {
            rotation = object.getRotation();
        }
        catch { }
    }
    return location && rotation
        && requireVector3Object(1, [location])
        && requireVector2Object(1, [rotation]);
}
// seq 1 variant 4
// high priority
overrides.addOverrides([
    { argc: 1, condition: requireEntityObject }
], function (args) {
    const entity = args[0];
    let { location, dimension, rotation } = entity;
    if (!rotation)
        rotation = entity.getRotation();
    const { x, y, z } = location;
    const rx = rotation.x;
    const ry = rotation.y;
    return { dimension, x, y, z, rx, ry };
});
overrides.addOverrides([
    { argc: 1, condition: requireObjectWithPositionAndRotationObject }
], function (args) {
    const entity = args[0];
    let { location, rotation } = entity;
    if (!rotation)
        rotation = entity.getRotation();
    const { x, y, z } = location;
    const rx = rotation.x;
    const ry = rotation.y;
    return { x, y, z, rx, ry };
});
//see seq 1 variant 3 over 5
//same to only requireArrayWithDimensionAndVector3
/*

overrides.addOverrides(
    [
        { argc: 1, condition: requireBlockObject }
    ],
    function (args: any[]){
        const block = args[0];
        const { dimension, x, y, z } = blcok;
        return { dimension, x, y, z };
    }
);
*/
// seq 1
overrides.addOverrides([
    { argc: 1, condition: requireDimensionValue },
    { argc: 3, condition: requireVector3 },
    { argc: 2, condition: requireVector2 }
], function (args) {
    const dimension = args[0];
    const x = args[1];
    const y = args[2];
    const z = args[3];
    const rx = args[4];
    const ry = args[5];
    return { dimension, x, y, z, rx, ry };
});
overrides.addOverrides([
    { argc: 1, condition: requireDimensionValue },
    { argc: 3, condition: requireVector3 },
    { argc: 1, condition: requireVector2Array }
], function (args) {
    const dimension = args[0];
    const x = args[1];
    const y = args[2];
    const z = args[3];
    const rocarr = args[4];
    const rx = rocarr[0];
    const ry = rocarr[1];
    return { dimension, x, y, z, rx, ry };
});
overrides.addOverrides([
    { argc: 1, condition: requireDimensionValue },
    { argc: 3, condition: requireVector3 },
    { argc: 1, condition: requireRotation }
], function (args) {
    const dimension = args[0];
    const x = args[1];
    const y = args[2];
    const z = args[3];
    const { rx, ry } = args[4];
    return { dimension, x, y, z, rx, ry };
});
overrides.addOverrides([
    { argc: 1, condition: requireDimensionValue },
    { argc: 3, condition: requireVector3 },
    { argc: 1, condition: requireVector2Object }
], function (args) {
    const dimension = args[0];
    const x = args[1];
    const y = args[2];
    const z = args[3];
    const rotation = args[4];
    const rx = rotation.x;
    const ry = rotation.y;
    return { dimension, x, y, z, rx, ry };
});
overrides.addOverrides([
    { argc: 1, condition: requireDimensionValue },
    { argc: 3, condition: requireVector3 }
], function (args) {
    const dimension = args[0];
    const x = args[1];
    const y = args[2];
    const z = args[3];
    return { dimension, x, y, z };
});
// seq 1 variant 1
overrides.addOverrides([
    { argc: 1, condition: requireObjectWithDimensionAndVector3 },
    { argc: 2, condition: requireVector2 }
], function (args) {
    const { dimension, x, y, z } = args[0];
    const rx = args[1];
    const ry = args[2];
    return { dimension, x, y, z, rx, ry };
});
overrides.addOverrides([
    { argc: 1, condition: requireObjectWithDimensionAndVector3 },
    { argc: 1, condition: requireVector2Array }
], function (args) {
    const { dimension, x, y, z } = args[0];
    const rocarr = args[1];
    const rx = rocarr[0];
    const ry = rocarr[1];
    return { dimension, x, y, z, rx, ry };
});
overrides.addOverrides([
    { argc: 1, condition: requireObjectWithDimensionAndVector3 },
    { argc: 1, condition: requireRotation }
], function (args) {
    const { dimension, x, y, z } = args[0];
    const { rx, ry } = args[1];
    return { dimension, x, y, z, rx, ry };
});
overrides.addOverrides([
    { argc: 1, condition: requireObjectWithDimensionAndVector3 },
    { argc: 1, condition: requireVector2Object }
], function (args) {
    const { dimension, x, y, z } = args[0];
    const rotation = args[1];
    const rx = rotation.x;
    const ry = rotation.y;
    return { dimension, x, y, z, rx, ry };
});
overrides.addOverrides([
    { argc: 1, condition: requireObjectWithDimensionAndVector3 }
], function (args) {
    const { dimension, x, y, z } = args[0];
    return { dimension, x, y, z };
});
// seq 1 variant 2
overrides.addOverrides([
    { argc: 1, condition: requireObjectWithDimensionAndCoords },
    { argc: 2, condition: requireVector2 }
], function (args) {
    const { dimension, location } = args[0];
    const { x, y, z } = location;
    const rx = args[1];
    const ry = args[2];
    return { dimension, x, y, z, rx, ry };
});
overrides.addOverrides([
    { argc: 1, condition: requireObjectWithDimensionAndCoords },
    { argc: 1, condition: requireVector2Array }
], function (args) {
    const { dimension, location } = args[0];
    const { x, y, z } = location;
    const rocarr = args[1];
    const rx = rocarr[0];
    const ry = rocarr[1];
    return { dimension, x, y, z, rx, ry };
});
overrides.addOverrides([
    { argc: 1, condition: requireObjectWithDimensionAndCoords },
    { argc: 1, condition: requireRotation }
], function (args) {
    const { dimension, location } = args[0];
    const { x, y, z } = location;
    const { rx, ry } = args[1];
    return { dimension, x, y, z, rx, ry };
});
overrides.addOverrides([
    { argc: 1, condition: requireObjectWithDimensionAndCoords },
    { argc: 1, condition: requireVector2Object }
], function (args) {
    const { dimension, location } = args[0];
    const { x, y, z } = location;
    const rotation = args[1];
    const rx = rotation.x;
    const ry = rotation.y;
    return { dimension, x, y, z, rx, ry };
});
overrides.addOverrides([
    { argc: 1, condition: requireObjectWithDimensionAndCoords },
], function (args) {
    const { dimension, location } = args[0];
    const { x, y, z } = location;
    return { dimension, x, y, z };
});
// seq 1 variant 3
overrides.addOverrides([
    { argc: 1, condition: requireArrayWithDimensionAndVector3 },
    { argc: 2, condition: requireVector2 }
], function (args) {
    const location = args[0];
    const dimension = location[0];
    const x = location[1];
    const y = location[2];
    const z = location[3];
    const rx = args[1];
    const ry = args[2];
    return { dimension, x, y, z, rx, ry };
});
overrides.addOverrides([
    { argc: 1, condition: requireArrayWithDimensionAndVector3 },
    { argc: 1, condition: requireVector2Array }
], function (args) {
    const location = args[0];
    const dimension = location[0];
    const x = location[1];
    const y = location[2];
    const z = location[3];
    const rocarr = args[1];
    const rx = rocarr[0];
    const ry = rocarr[1];
    return { dimension, x, y, z, rx, ry };
});
overrides.addOverrides([
    { argc: 1, condition: requireArrayWithDimensionAndVector3 },
    { argc: 1, condition: requireRotation }
], function (args) {
    const location = args[0];
    const dimension = location[0];
    const x = location[1];
    const y = location[2];
    const z = location[3];
    const { rx, ry } = args[1];
    return { dimension, x, y, z, rx, ry };
});
overrides.addOverrides([
    { argc: 1, condition: requireArrayWithDimensionAndVector3 },
    { argc: 1, condition: requireVector2Object }
], function (args) {
    const location = args[0];
    const dimension = location[0];
    const x = location[1];
    const y = location[2];
    const z = location[3];
    const rotation = args[1];
    const rx = rotation.x;
    const ry = rotation.y;
    return { dimension, x, y, z, rx, ry };
});
overrides.addOverrides([
    { argc: 1, condition: requireArrayWithDimensionAndVector3 },
], function (args) {
    const location = args[0];
    const dimension = location[0];
    const x = location[1];
    const y = location[2];
    const z = location[3];
    return { dimension, x, y, z };
});
// seq 2
overrides.addOverrides([
    { argc: 1, condition: requireDimensionValue },
    { argc: 1, condition: requireVector3Object },
    { argc: 2, condition: requireVector2 }
], function (args) {
    const dimension = args[0];
    const { x, y, z } = args[1];
    const rx = args[2];
    const ry = args[3];
    return { dimension, x, y, z, rx, ry };
});
overrides.addOverrides([
    { argc: 1, condition: requireDimensionValue },
    { argc: 1, condition: requireVector3Object },
    { argc: 1, condition: requireVector2Array }
], function (args) {
    const dimension = args[0];
    const { x, y, z } = args[1];
    const rocarr = args[2];
    const rx = rocarr[0];
    const ry = rocarr[1];
    return { dimension, x, y, z, rx, ry };
});
overrides.addOverrides([
    { argc: 1, condition: requireDimensionValue },
    { argc: 1, condition: requireVector3Object },
    { argc: 1, condition: requireRotation }
], function (args) {
    const dimension = args[0];
    const { x, y, z } = args[1];
    const { rx, ry } = args[2];
    return { dimension, x, y, z, rx, ry };
});
overrides.addOverrides([
    { argc: 1, condition: requireDimensionValue },
    { argc: 1, condition: requireVector3Object },
    { argc: 1, condition: requireVector2Object }
], function (args) {
    const dimension = args[0];
    const { x, y, z } = args[1];
    const rotation = args[2];
    const rx = rotation.x;
    const ry = rotation.y;
    return { dimension, x, y, z, rx, ry };
});
overrides.addOverrides([
    { argc: 1, condition: requireDimensionValue },
    { argc: 3, condition: requireVector3Object }
], function (args) {
    const dimension = args[0];
    const { x, y, z } = args[1];
    return { dimension, x, y, z };
});
// seq 3
overrides.addOverrides([
    { argc: 1, condition: requireDimensionValue },
    { argc: 1, condition: requireVector3Array },
    { argc: 2, condition: requireVector2 }
], function (args) {
    const dimension = args[0];
    const locarr = args[1];
    const x = locarr[0];
    const y = locarr[1];
    const z = locarr[2];
    const rx = args[2];
    const ry = args[3];
    return { dimension, x, y, z, rx, ry };
});
overrides.addOverrides([
    { argc: 1, condition: requireDimensionValue },
    { argc: 1, condition: requireVector3Array },
    { argc: 1, condition: requireVector2Array }
], function (args) {
    const dimension = args[0];
    const locarr = args[1];
    const x = locarr[0];
    const y = locarr[1];
    const z = locarr[2];
    const rocarr = args[2];
    const rx = rocarr[0];
    const ry = rocarr[1];
    return { dimension, x, y, z, rx, ry };
});
overrides.addOverrides([
    { argc: 1, condition: requireDimensionValue },
    { argc: 1, condition: requireVector3Array },
    { argc: 1, condition: requireRotation }
], function (args) {
    const dimension = args[0];
    const locarr = args[1];
    const x = locarr[0];
    const y = locarr[1];
    const z = locarr[2];
    const { rx, ry } = args[2];
    return { dimension, x, y, z, rx, ry };
});
overrides.addOverrides([
    { argc: 1, condition: requireDimensionValue },
    { argc: 1, condition: requireVector3Array },
    { argc: 1, condition: requireVector2Object }
], function (args) {
    const dimension = args[0];
    const locarr = args[1];
    const x = locarr[0];
    const y = locarr[1];
    const z = locarr[2];
    const rotation = args[2];
    const rx = rotation.x;
    const ry = rotation.y;
    return { dimension, x, y, z, rx, ry };
});
overrides.addOverrides([
    { argc: 1, condition: requireDimensionValue },
    { argc: 3, condition: requireVector3Array }
], function (args) {
    const dimension = args[0];
    const locarr = args[1];
    const x = locarr[0];
    const y = locarr[1];
    const z = locarr[2];
    return { dimension, x, y, z };
});
// ------------------------
// seq 1-2
overrides.addOverrides([
    { argc: 3, condition: requireVector3 },
    { argc: 2, condition: requireVector2 }
], function (args) {
    const x = args[0];
    const y = args[1];
    const z = args[2];
    const rx = args[3];
    const ry = args[4];
    return { x, y, z, rx, ry };
});
overrides.addOverrides([
    { argc: 3, condition: requireVector3 },
    { argc: 1, condition: requireVector2Array }
], function (args) {
    const x = args[0];
    const y = args[1];
    const z = args[2];
    const rocarr = args[3];
    const rx = rocarr[0];
    const ry = rocarr[1];
    return { x, y, z, rx, ry };
});
overrides.addOverrides([
    { argc: 3, condition: requireVector3 },
    { argc: 1, condition: requireRotation }
], function (args) {
    const x = args[0];
    const y = args[1];
    const z = args[2];
    const { rx, ry } = args[3];
    return { x, y, z, rx, ry };
});
overrides.addOverrides([
    { argc: 3, condition: requireVector3 },
    { argc: 1, condition: requireVector2Object }
], function (args) {
    const x = args[0];
    const y = args[1];
    const z = args[2];
    const rotation = args[3];
    const rx = rotation.x;
    const ry = rotation.y;
    return { x, y, z, rx, ry };
});
overrides.addOverrides([
    { argc: 3, condition: requireVector3 }
], function (args) {
    const x = args[0];
    const y = args[1];
    const z = args[2];
    return { x, y, z };
});
// seq 1-2 variant 1
overrides.addOverrides([
    { argc: 1, condition: requireArrayWithVector3AndVector2 },
], function (args) {
    const locarr = args[0];
    const x = locarr[0];
    const y = locarr[1];
    const z = locarr[2];
    const rx = locarr[3];
    const ry = locarr[4];
    return { x, y, z, rx, ry };
});
// seq 2-2
overrides.addOverrides([
    { argc: 1, condition: requireVector3Object },
    { argc: 2, condition: requireVector2 }
], function (args) {
    const { x, y, z } = args[0];
    const rx = args[1];
    const ry = args[2];
    return { x, y, z, rx, ry };
});
overrides.addOverrides([
    { argc: 1, condition: requireVector3Object },
    { argc: 1, condition: requireVector2Array }
], function (args) {
    const { x, y, z } = args[0];
    const rocarr = args[1];
    const rx = rocarr[0];
    const ry = rocarr[1];
    return { x, y, z, rx, ry };
});
overrides.addOverrides([
    { argc: 1, condition: requireVector3Object },
    { argc: 1, condition: requireRotation }
], function (args) {
    const { x, y, z } = args[0];
    const { rx, ry } = args[1];
    return { x, y, z, rx, ry };
});
overrides.addOverrides([
    { argc: 1, condition: requireVector3Object },
    { argc: 1, condition: requireVector2Object }
], function (args) {
    const { x, y, z } = args[0];
    const rotation = args[1];
    const rx = rotation.x;
    const ry = rotation.y;
    return { x, y, z, rx, ry };
});
overrides.addOverrides([
    { argc: 1, condition: requireVector3Object }
], function (args) {
    const { x, y, z } = args[0];
    return { x, y, z };
});
// seq 3-2
overrides.addOverrides([
    { argc: 1, condition: requireVector3Array },
    { argc: 2, condition: requireVector2 }
], function (args) {
    const locarr = args[0];
    const x = locarr[0];
    const y = locarr[1];
    const z = locarr[2];
    const rx = args[1];
    const ry = args[2];
    return { x, y, z, rx, ry };
});
overrides.addOverrides([
    { argc: 1, condition: requireVector3Array },
    { argc: 1, condition: requireVector2Array }
], function (args) {
    const locarr = args[0];
    const x = locarr[0];
    const y = locarr[1];
    const z = locarr[2];
    const rocarr = args[1];
    const rx = rocarr[0];
    const ry = rocarr[1];
    return { x, y, z, rx, ry };
});
overrides.addOverrides([
    { argc: 1, condition: requireVector3Array },
    { argc: 1, condition: requireRotation }
], function (args) {
    const locarr = args[0];
    const x = locarr[0];
    const y = locarr[1];
    const z = locarr[2];
    const { rx, ry } = args[1];
    return { x, y, z, rx, ry };
});
overrides.addOverrides([
    { argc: 1, condition: requireVector3Array },
    { argc: 1, condition: requireVector2Object }
], function (args) {
    const locarr = args[0];
    const x = locarr[0];
    const y = locarr[1];
    const z = locarr[2];
    const rotation = args[1];
    const rx = rotation.x;
    const ry = rotation.y;
    return { x, y, z, rx, ry };
});
overrides.addOverrides([
    { argc: 1, condition: requireVector3Array }
], function (args) {
    const locarr = args[0];
    const x = locarr[0];
    const y = locarr[1];
    const z = locarr[2];
    return { x, y, z };
});
function makeLocation(values) {
    let overrideMathces = overrides.match(values);
    if (!overrideMathces?.hasResult)
        throw new TypeError("没有匹配结果，无法创建对应的位置对象");
    return overrideMathces.result;
}