@esengine/ecs-framework-math 1.0.2 → 1.0.5

package/index.d.ts

@@ -0,0 +1,1968 @@
+/**
+ * @esengine/ecs-framework-math v1.0.5
+ * TypeScript definitions
+ */
+/**
+ * 2D向量类
+ *
+ * 提供完整的2D向量运算功能，包括：
+ * - 基础运算（加减乘除）
+ * - 向量运算（点积、叉积、归一化）
+ * - 几何运算（距离、角度、投影）
+ * - 变换操作（旋转、反射、插值）
+ */
+declare class Vector2 {
+    /** X分量 */
+    x: number;
+    /** Y分量 */
+    y: number;
+    /**
+     * 创建2D向量
+     * @param x X分量，默认为0
+     * @param y Y分量，默认为0
+     */
+    constructor(x?: number, y?: number);
+    /** 零向量 (0, 0) */
+    static readonly ZERO: Vector2;
+    /** 单位向量 (1, 1) */
+    static readonly ONE: Vector2;
+    /** 右方向向量 (1, 0) */
+    static readonly RIGHT: Vector2;
+    /** 左方向向量 (-1, 0) */
+    static readonly LEFT: Vector2;
+    /** 上方向向量 (0, 1) */
+    static readonly UP: Vector2;
+    /** 下方向向量 (0, -1) */
+    static readonly DOWN: Vector2;
+    /**
+     * 获取向量长度（模）
+     */
+    get length(): number;
+    /**
+     * 获取向量长度的平方
+     */
+    get lengthSquared(): number;
+    /**
+     * 获取向量角度（弧度）
+     */
+    get angle(): number;
+    /**
+     * 检查是否为零向量
+     */
+    get isZero(): boolean;
+    /**
+     * 检查是否为单位向量
+     */
+    get isUnit(): boolean;
+    /**
+     * 设置向量分量
+     * @param x X分量
+     * @param y Y分量
+     * @returns 当前向量实例（链式调用）
+     */
+    set(x: number, y: number): this;
+    /**
+     * 复制另一个向量的值
+     * @param other 源向量
+     * @returns 当前向量实例（链式调用）
+     */
+    copy(other: Vector2): this;
+    /**
+     * 克隆当前向量
+     * @returns 新的向量实例
+     */
+    clone(): Vector2;
+    /**
+     * 向量加法
+     * @param other 另一个向量
+     * @returns 当前向量实例（链式调用）
+     */
+    add(other: Vector2): this;
+    /**
+     * 向量减法
+     * @param other 另一个向量
+     * @returns 当前向量实例（链式调用）
+     */
+    subtract(other: Vector2): this;
+    /**
+     * 向量数乘
+     * @param scalar 标量
+     * @returns 当前向量实例（链式调用）
+     */
+    multiply(scalar: number): this;
+    /**
+     * 向量数除
+     * @param scalar 标量
+     * @returns 当前向量实例（链式调用）
+     */
+    divide(scalar: number): this;
+    /**
+     * 向量取反
+     * @returns 当前向量实例（链式调用）
+     */
+    negate(): this;
+    /**
+     * 计算与另一个向量的点积
+     * @param other 另一个向量
+     * @returns 点积值
+     */
+    dot(other: Vector2): number;
+    /**
+     * 计算与另一个向量的叉积（2D中返回标量）
+     * @param other 另一个向量
+     * @returns 叉积值
+     */
+    cross(other: Vector2): number;
+    /**
+     * 向量归一化（转换为单位向量）
+     * @returns 当前向量实例（链式调用）
+     */
+    normalize(): this;
+    /**
+     * 获取归一化后的向量（不修改原向量）
+     * @returns 新的单位向量
+     */
+    normalized(): Vector2;
+    /**
+     * 计算到另一个向量的距离
+     * @param other 另一个向量
+     * @returns 距离值
+     */
+    distanceTo(other: Vector2): number;
+    /**
+     * 计算到另一个向量的距离平方
+     * @param other 另一个向量
+     * @returns 距离平方值
+     */
+    distanceToSquared(other: Vector2): number;
+    /**
+     * 计算与另一个向量的夹角（弧度）
+     * @param other 另一个向量
+     * @returns 夹角（0到π）
+     */
+    angleTo(other: Vector2): number;
+    /**
+     * 计算向量在另一个向量上的投影
+     * @param onto 投影目标向量
+     * @returns 新的投影向量
+     */
+    projectOnto(onto: Vector2): Vector2;
+    /**
+     * 计算向量在另一个向量上的投影长度
+     * @param onto 投影目标向量
+     * @returns 投影长度（带符号）
+     */
+    projectOntoLength(onto: Vector2): number;
+    /**
+     * 获取垂直向量（逆时针旋转90度）
+     * @returns 新的垂直向量
+     */
+    perpendicular(): Vector2;
+    /**
+     * 向量旋转
+     * @param angle 旋转角度（弧度）
+     * @returns 当前向量实例（链式调用）
+     */
+    rotate(angle: number): this;
+    /**
+     * 获取旋转后的向量（不修改原向量）
+     * @param angle 旋转角度（弧度）
+     * @returns 新的旋转后向量
+     */
+    rotated(angle: number): Vector2;
+    /**
+     * 围绕一个点旋转
+     * @param center 旋转中心点
+     * @param angle 旋转角度（弧度）
+     * @returns 当前向量实例（链式调用）
+     */
+    rotateAround(center: Vector2, angle: number): this;
+    /**
+     * 反射向量（关于法线）
+     * @param normal 法线向量（应为单位向量）
+     * @returns 当前向量实例（链式调用）
+     */
+    reflect(normal: Vector2): this;
+    /**
+     * 获取反射后的向量（不修改原向量）
+     * @param normal 法线向量（应为单位向量）
+     * @returns 新的反射向量
+     */
+    reflected(normal: Vector2): Vector2;
+    /**
+     * 线性插值
+     * @param target 目标向量
+     * @param t 插值参数（0到1）
+     * @returns 当前向量实例（链式调用）
+     */
+    lerp(target: Vector2, t: number): this;
+    /**
+     * 限制向量长度
+     * @param maxLength 最大长度
+     * @returns 当前向量实例（链式调用）
+     */
+    clampLength(maxLength: number): this;
+    /**
+     * 限制向量分量
+     * @param min 最小值向量
+     * @param max 最大值向量
+     * @returns 当前向量实例（链式调用）
+     */
+    clamp(min: Vector2, max: Vector2): this;
+    /**
+     * 检查两个向量是否相等
+     * @param other 另一个向量
+     * @param epsilon 容差，默认为Number.EPSILON
+     * @returns 是否相等
+     */
+    equals(other: Vector2, epsilon?: number): boolean;
+    /**
+     * 检查两个向量是否完全相等
+     * @param other 另一个向量
+     * @returns 是否完全相等
+     */
+    exactEquals(other: Vector2): boolean;
+    /**
+     * 向量加法（静态方法）
+     * @param a 向量a
+     * @param b 向量b
+     * @returns 新的结果向量
+     */
+    static add(a: Vector2, b: Vector2): Vector2;
+    /**
+     * 向量减法（静态方法）
+     * @param a 向量a
+     * @param b 向量b
+     * @returns 新的结果向量
+     */
+    static subtract(a: Vector2, b: Vector2): Vector2;
+    /**
+     * 向量数乘（静态方法）
+     * @param vector 向量
+     * @param scalar 标量
+     * @returns 新的结果向量
+     */
+    static multiply(vector: Vector2, scalar: number): Vector2;
+    /**
+     * 向量点积（静态方法）
+     * @param a 向量a
+     * @param b 向量b
+     * @returns 点积值
+     */
+    static dot(a: Vector2, b: Vector2): number;
+    /**
+     * 向量叉积（静态方法）
+     * @param a 向量a
+     * @param b 向量b
+     * @returns 叉积值
+     */
+    static cross(a: Vector2, b: Vector2): number;
+    /**
+     * 计算两点间距离（静态方法）
+     * @param a 点a
+     * @param b 点b
+     * @returns 距离值
+     */
+    static distance(a: Vector2, b: Vector2): number;
+    /**
+     * 线性插值（静态方法）
+     * @param a 起始向量
+     * @param b 目标向量
+     * @param t 插值参数（0到1）
+     * @returns 新的插值结果向量
+     */
+    static lerp(a: Vector2, b: Vector2, t: number): Vector2;
+    /**
+     * 从角度创建单位向量（静态方法）
+     * @param angle 角度（弧度）
+     * @returns 新的单位向量
+     */
+    static fromAngle(angle: number): Vector2;
+    /**
+     * 从极坐标创建向量（静态方法）
+     * @param length 长度
+     * @param angle 角度（弧度）
+     * @returns 新的向量
+     */
+    static fromPolar(length: number, angle: number): Vector2;
+    /**
+     * 获取两个向量中的最小分量向量（静态方法）
+     * @param a 向量a
+     * @param b 向量b
+     * @returns 新的最小分量向量
+     */
+    static min(a: Vector2, b: Vector2): Vector2;
+    /**
+     * 获取两个向量中的最大分量向量（静态方法）
+     * @param a 向量a
+     * @param b 向量b
+     * @returns 新的最大分量向量
+     */
+    static max(a: Vector2, b: Vector2): Vector2;
+    /**
+     * 转换为字符串
+     * @returns 字符串表示
+     */
+    toString(): string;
+    /**
+     * 转换为数组
+     * @returns [x, y] 数组
+     */
+    toArray(): [number, number];
+    /**
+     * 转换为普通对象
+     * @returns {x, y} 对象
+     */
+    toObject(): {
+        x: number;
+        y: number;
+    };
+}
+
+/**
+ * 3x3变换矩阵类
+ *
+ * 用于2D变换（平移、旋转、缩放）的3x3矩阵
+ * 矩阵布局：
+ * [m00, m01, m02]   [scaleX * cos, -scaleY * sin, translateX]
+ * [m10, m11, m12] = [scaleX * sin,  scaleY * cos, translateY]
+ * [m20, m21, m22]   [0,            0,            1]
+ */
+declare class Matrix3 {
+    /** 矩阵元素，按行优先存储 */
+    elements: Float32Array;
+    /**
+     * 创建3x3矩阵
+     * @param elements 矩阵元素数组（可选），默认为单位矩阵
+     */
+    constructor(elements?: ArrayLike<number>);
+    /** 单位矩阵 */
+    static readonly IDENTITY: Matrix3;
+    /** 零矩阵 */
+    static readonly ZERO: Matrix3;
+    /** 获取矩阵元素 */
+    get(row: number, col: number): number;
+    /** 设置矩阵元素 */
+    set(row: number, col: number, value: number): this;
+    get m00(): number;
+    set m00(value: number);
+    get m01(): number;
+    set m01(value: number);
+    get m02(): number;
+    set m02(value: number);
+    get m10(): number;
+    set m10(value: number);
+    get m11(): number;
+    set m11(value: number);
+    get m12(): number;
+    set m12(value: number);
+    get m20(): number;
+    set m20(value: number);
+    get m21(): number;
+    set m21(value: number);
+    get m22(): number;
+    set m22(value: number);
+    /**
+     * 设置矩阵为单位矩阵
+     * @returns 当前矩阵实例（链式调用）
+     */
+    identity(): this;
+    /**
+     * 设置矩阵为零矩阵
+     * @returns 当前矩阵实例（链式调用）
+     */
+    zero(): this;
+    /**
+     * 复制另一个矩阵的值
+     * @param other 源矩阵
+     * @returns 当前矩阵实例（链式调用）
+     */
+    copy(other: Matrix3): this;
+    /**
+     * 克隆当前矩阵
+     * @returns 新的矩阵实例
+     */
+    clone(): Matrix3;
+    /**
+     * 从数组设置矩阵元素
+     * @param elements 矩阵元素数组
+     * @returns 当前矩阵实例（链式调用）
+     */
+    fromArray(elements: ArrayLike<number>): this;
+    /**
+     * 矩阵加法
+     * @param other 另一个矩阵
+     * @returns 当前矩阵实例（链式调用）
+     */
+    add(other: Matrix3): this;
+    /**
+     * 矩阵减法
+     * @param other 另一个矩阵
+     * @returns 当前矩阵实例（链式调用）
+     */
+    subtract(other: Matrix3): this;
+    /**
+     * 矩阵标量乘法
+     * @param scalar 标量
+     * @returns 当前矩阵实例（链式调用）
+     */
+    multiplyScalar(scalar: number): this;
+    /**
+     * 矩阵乘法
+     * @param other 另一个矩阵
+     * @returns 当前矩阵实例（链式调用）
+     */
+    multiply(other: Matrix3): this;
+    /**
+     * 左乘另一个矩阵（other * this）
+     * @param other 左乘矩阵
+     * @returns 当前矩阵实例（链式调用）
+     */
+    premultiply(other: Matrix3): this;
+    /**
+     * 设置为平移矩阵
+     * @param x X方向平移
+     * @param y Y方向平移
+     * @returns 当前矩阵实例（链式调用）
+     */
+    makeTranslation(x: number, y: number): this;
+    /**
+     * 设置为旋转矩阵
+     * @param angle 旋转角度（弧度）
+     * @returns 当前矩阵实例（链式调用）
+     */
+    makeRotation(angle: number): this;
+    /**
+     * 设置为缩放矩阵
+     * @param scaleX X方向缩放
+     * @param scaleY Y方向缩放
+     * @returns 当前矩阵实例（链式调用）
+     */
+    makeScale(scaleX: number, scaleY: number): this;
+    /**
+     * 复合平移
+     * @param x X方向平移
+     * @param y Y方向平移
+     * @returns 当前矩阵实例（链式调用）
+     */
+    translate(x: number, y: number): this;
+    /**
+     * 复合旋转
+     * @param angle 旋转角度（弧度）
+     * @returns 当前矩阵实例（链式调用）
+     */
+    rotate(angle: number): this;
+    /**
+     * 复合缩放
+     * @param scaleX X方向缩放
+     * @param scaleY Y方向缩放
+     * @returns 当前矩阵实例（链式调用）
+     */
+    scale(scaleX: number, scaleY: number): this;
+    /**
+     * 矩阵转置
+     * @returns 当前矩阵实例（链式调用）
+     */
+    transpose(): this;
+    /**
+     * 计算矩阵行列式
+     * @returns 行列式值
+     */
+    determinant(): number;
+    /**
+     * 矩阵求逆
+     * @returns 当前矩阵实例（链式调用），如果矩阵不可逆则保持不变
+     */
+    invert(): this;
+    /**
+     * 变换向量（应用完整的3x3变换）
+     * @param vector 向量
+     * @returns 新的变换后的向量
+     */
+    transformVector(vector: Vector2): Vector2;
+    /**
+     * 变换向量（仅应用旋转和缩放，忽略平移）
+     * @param vector 向量
+     * @returns 新的变换后的向量
+     */
+    transformDirection(vector: Vector2): Vector2;
+    /**
+     * 批量变换向量数组
+     * @param vectors 向量数组
+     * @returns 变换后的向量数组
+     */
+    transformVectors(vectors: Vector2[]): Vector2[];
+    /**
+     * 获取平移分量
+     * @returns 平移向量
+     */
+    getTranslation(): Vector2;
+    /**
+     * 获取旋转角度
+     * @returns 旋转角度（弧度）
+     */
+    getRotation(): number;
+    /**
+     * 获取缩放分量
+     * @returns 缩放向量
+     */
+    getScale(): Vector2;
+    /**
+     * 分解变换矩阵为平移、旋转、缩放分量
+     * @returns {translation, rotation, scale}
+     */
+    decompose(): {
+        translation: Vector2;
+        rotation: number;
+        scale: Vector2;
+    };
+    /**
+     * 检查两个矩阵是否相等
+     * @param other 另一个矩阵
+     * @param epsilon 容差，默认为Number.EPSILON
+     * @returns 是否相等
+     */
+    equals(other: Matrix3, epsilon?: number): boolean;
+    /**
+     * 检查两个矩阵是否完全相等
+     * @param other 另一个矩阵
+     * @returns 是否完全相等
+     */
+    exactEquals(other: Matrix3): boolean;
+    /**
+     * 检查是否为单位矩阵
+     * @param epsilon 容差，默认为Number.EPSILON
+     * @returns 是否为单位矩阵
+     */
+    isIdentity(epsilon?: number): boolean;
+    /**
+     * 矩阵乘法（静态方法）
+     * @param a 矩阵a
+     * @param b 矩阵b
+     * @returns 新的结果矩阵
+     */
+    static multiply(a: Matrix3, b: Matrix3): Matrix3;
+    /**
+     * 创建平移矩阵（静态方法）
+     * @param x X方向平移
+     * @param y Y方向平移
+     * @returns 新的平移矩阵
+     */
+    static translation(x: number, y: number): Matrix3;
+    /**
+     * 创建旋转矩阵（静态方法）
+     * @param angle 旋转角度（弧度）
+     * @returns 新的旋转矩阵
+     */
+    static rotation(angle: number): Matrix3;
+    /**
+     * 创建缩放矩阵（静态方法）
+     * @param scaleX X方向缩放
+     * @param scaleY Y方向缩放
+     * @returns 新的缩放矩阵
+     */
+    static scale(scaleX: number, scaleY: number): Matrix3;
+    /**
+     * 创建TRS（平移-旋转-缩放）变换矩阵
+     * @param translation 平移向量
+     * @param rotation 旋转角度（弧度）
+     * @param scale 缩放向量
+     * @returns 新的TRS矩阵
+     */
+    static TRS(translation: Vector2, rotation: number, scale: Vector2): Matrix3;
+    /**
+     * 转换为字符串
+     * @returns 字符串表示
+     */
+    toString(): string;
+    /**
+     * 转换为数组
+     * @returns 矩阵元素数组
+     */
+    toArray(): number[];
+    /**
+     * 转换为CSS transform字符串
+     * @returns CSS transform字符串
+     */
+    toCSSTransform(): string;
+}
+
+/**
+ * 2D矩形类
+ *
+ * 表示一个轴对齐的矩形，提供矩形相关的几何运算功能：
+ * - 矩形创建和属性获取
+ * - 包含检测（点、矩形）
+ * - 相交检测和计算
+ * - 变换和操作
+ */
+declare class Rectangle {
+    /** 矩形左上角X坐标 */
+    x: number;
+    /** 矩形左上角Y坐标 */
+    y: number;
+    /** 矩形宽度 */
+    width: number;
+    /** 矩形高度 */
+    height: number;
+    /**
+     * 创建矩形
+     * @param x 左上角X坐标，默认为0
+     * @param y 左上角Y坐标，默认为0
+     * @param width 宽度，默认为0
+     * @param height 高度，默认为0
+     */
+    constructor(x?: number, y?: number, width?: number, height?: number);
+    /** 空矩形 */
+    static readonly EMPTY: Rectangle;
+    /** 获取左边界 */
+    get left(): number;
+    /** 获取右边界 */
+    get right(): number;
+    /** 获取上边界 */
+    get top(): number;
+    /** 获取下边界 */
+    get bottom(): number;
+    /** 获取中心X坐标 */
+    get centerX(): number;
+    /** 获取中心Y坐标 */
+    get centerY(): number;
+    /** 获取中心点 */
+    get center(): Vector2;
+    /** 获取左上角点 */
+    get topLeft(): Vector2;
+    /** 获取右上角点 */
+    get topRight(): Vector2;
+    /** 获取左下角点 */
+    get bottomLeft(): Vector2;
+    /** 获取右下角点 */
+    get bottomRight(): Vector2;
+    /** 获取面积 */
+    get area(): number;
+    /** 获取周长 */
+    get perimeter(): number;
+    /** 检查是否为空矩形 */
+    get isEmpty(): boolean;
+    /** 检查是否为正方形 */
+    get isSquare(): boolean;
+    /**
+     * 设置矩形属性
+     * @param x 左上角X坐标
+     * @param y 左上角Y坐标
+     * @param width 宽度
+     * @param height 高度
+     * @returns 当前矩形实例（链式调用）
+     */
+    set(x: number, y: number, width: number, height: number): this;
+    /**
+     * 复制另一个矩形的值
+     * @param other 源矩形
+     * @returns 当前矩形实例（链式调用）
+     */
+    copy(other: Rectangle): this;
+    /**
+     * 克隆当前矩形
+     * @returns 新的矩形实例
+     */
+    clone(): Rectangle;
+    /**
+     * 设置矩形位置
+     * @param x 新的X坐标
+     * @param y 新的Y坐标
+     * @returns 当前矩形实例（链式调用）
+     */
+    setPosition(x: number, y: number): this;
+    /**
+     * 设置矩形大小
+     * @param width 新的宽度
+     * @param height 新的高度
+     * @returns 当前矩形实例（链式调用）
+     */
+    setSize(width: number, height: number): this;
+    /**
+     * 设置矩形中心点
+     * @param centerX 中心X坐标
+     * @param centerY 中心Y坐标
+     * @returns 当前矩形实例（链式调用）
+     */
+    setCenter(centerX: number, centerY: number): this;
+    /**
+     * 平移矩形
+     * @param dx X方向偏移
+     * @param dy Y方向偏移
+     * @returns 当前矩形实例（链式调用）
+     */
+    translate(dx: number, dy: number): this;
+    /**
+     * 缩放矩形（从中心缩放）
+     * @param scaleX X方向缩放因子
+     * @param scaleY Y方向缩放因子，默认等于scaleX
+     * @returns 当前矩形实例（链式调用）
+     */
+    scale(scaleX: number, scaleY?: number): this;
+    /**
+     * 扩展矩形
+     * @param amount 扩展量（正值扩大，负值缩小）
+     * @returns 当前矩形实例（链式调用）
+     */
+    inflate(amount: number): this;
+    /**
+     * 扩展矩形（分别指定水平和垂直方向）
+     * @param horizontal 水平方向扩展量
+     * @param vertical 垂直方向扩展量
+     * @returns 当前矩形实例（链式调用）
+     */
+    inflateXY(horizontal: number, vertical: number): this;
+    /**
+     * 检查是否包含指定点
+     * @param point 点
+     * @returns 是否包含
+     */
+    containsPoint(point: Vector2): boolean;
+    /**
+     * 检查是否包含指定坐标
+     * @param x X坐标
+     * @param y Y坐标
+     * @returns 是否包含
+     */
+    contains(x: number, y: number): boolean;
+    /**
+     * 检查是否完全包含另一个矩形
+     * @param other 另一个矩形
+     * @returns 是否完全包含
+     */
+    containsRect(other: Rectangle): boolean;
+    /**
+     * 检查是否与另一个矩形相交
+     * @param other 另一个矩形
+     * @returns 是否相交
+     */
+    intersects(other: Rectangle): boolean;
+    /**
+     * 计算与另一个矩形的相交矩形
+     * @param other 另一个矩形
+     * @returns 相交矩形，如果不相交返回空矩形
+     */
+    intersection(other: Rectangle): Rectangle;
+    /**
+     * 计算与另一个矩形的并集矩形
+     * @param other 另一个矩形
+     * @returns 并集矩形
+     */
+    union(other: Rectangle): Rectangle;
+    /**
+     * 计算相交面积
+     * @param other 另一个矩形
+     * @returns 相交面积
+     */
+    intersectionArea(other: Rectangle): number;
+    /**
+     * 计算点到矩形的最短距离
+     * @param point 点
+     * @returns 最短距离
+     */
+    distanceToPoint(point: Vector2): number;
+    /**
+     * 计算两个矩形间的最短距离
+     * @param other 另一个矩形
+     * @returns 最短距离（相交时为0）
+     */
+    distanceToRect(other: Rectangle): number;
+    /**
+     * 获取矩形上距离指定点最近的点
+     * @param point 指定点
+     * @returns 最近点
+     */
+    closestPointTo(point: Vector2): Vector2;
+    /**
+     * 检查两个矩形是否相等
+     * @param other 另一个矩形
+     * @param epsilon 容差，默认为Number.EPSILON
+     * @returns 是否相等
+     */
+    equals(other: Rectangle, epsilon?: number): boolean;
+    /**
+     * 检查两个矩形是否完全相等
+     * @param other 另一个矩形
+     * @returns 是否完全相等
+     */
+    exactEquals(other: Rectangle): boolean;
+    /**
+     * 从中心点和大小创建矩形
+     * @param centerX 中心X坐标
+     * @param centerY 中心Y坐标
+     * @param width 宽度
+     * @param height 高度
+     * @returns 新的矩形实例
+     */
+    static fromCenter(centerX: number, centerY: number, width: number, height: number): Rectangle;
+    /**
+     * 从两个点创建矩形
+     * @param point1 第一个点
+     * @param point2 第二个点
+     * @returns 新的矩形实例
+     */
+    static fromPoints(point1: Vector2, point2: Vector2): Rectangle;
+    /**
+     * 从点数组创建包围矩形
+     * @param points 点数组
+     * @returns 包围矩形
+     */
+    static fromPointArray(points: Vector2[]): Rectangle;
+    /**
+     * 创建正方形
+     * @param x 左上角X坐标
+     * @param y 左上角Y坐标
+     * @param size 边长
+     * @returns 新的正方形矩形
+     */
+    static square(x: number, y: number, size: number): Rectangle;
+    /**
+     * 线性插值两个矩形
+     * @param a 起始矩形
+     * @param b 目标矩形
+     * @param t 插值参数（0到1）
+     * @returns 新的插值结果矩形
+     */
+    static lerp(a: Rectangle, b: Rectangle, t: number): Rectangle;
+    /**
+     * 转换为字符串
+     * @returns 字符串表示
+     */
+    toString(): string;
+    /**
+     * 转换为数组
+     * @returns [x, y, width, height] 数组
+     */
+    toArray(): [number, number, number, number];
+    /**
+     * 转换为普通对象
+     * @returns {x, y, width, height} 对象
+     */
+    toObject(): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /**
+     * 获取四个顶点
+     * @returns 顶点数组 [topLeft, topRight, bottomRight, bottomLeft]
+     */
+    getVertices(): Vector2[];
+}
+
+/**
+ * 2D圆形类
+ *
+ * 表示一个圆形，提供圆形相关的几何运算功能：
+ * - 圆形创建和属性获取
+ * - 包含检测（点、圆形）
+ * - 相交检测和计算
+ * - 变换和操作
+ */
+declare class Circle {
+    /** 圆心X坐标 */
+    x: number;
+    /** 圆心Y坐标 */
+    y: number;
+    /** 半径 */
+    radius: number;
+    /**
+     * 创建圆形
+     * @param x 圆心X坐标，默认为0
+     * @param y 圆心Y坐标，默认为0
+     * @param radius 半径，默认为0
+     */
+    constructor(x?: number, y?: number, radius?: number);
+    /** 空圆形 */
+    static readonly EMPTY: Circle;
+    /** 单位圆 */
+    static readonly UNIT: Circle;
+    /** 获取圆心坐标 */
+    get center(): Vector2;
+    /** 设置圆心坐标 */
+    set center(value: Vector2);
+    /** 获取直径 */
+    get diameter(): number;
+    /** 设置直径 */
+    set diameter(value: number);
+    /** 获取面积 */
+    get area(): number;
+    /** 获取周长 */
+    get circumference(): number;
+    /** 获取包围矩形 */
+    get bounds(): Rectangle;
+    /** 检查是否为空圆形 */
+    get isEmpty(): boolean;
+    /**
+     * 设置圆形属性
+     * @param x 圆心X坐标
+     * @param y 圆心Y坐标
+     * @param radius 半径
+     * @returns 当前圆形实例（链式调用）
+     */
+    set(x: number, y: number, radius: number): this;
+    /**
+     * 复制另一个圆形的值
+     * @param other 源圆形
+     * @returns 当前圆形实例（链式调用）
+     */
+    copy(other: Circle): this;
+    /**
+     * 克隆当前圆形
+     * @returns 新的圆形实例
+     */
+    clone(): Circle;
+    /**
+     * 设置圆心位置
+     * @param x 新的X坐标
+     * @param y 新的Y坐标
+     * @returns 当前圆形实例（链式调用）
+     */
+    setPosition(x: number, y: number): this;
+    /**
+     * 设置圆心位置（使用向量）
+     * @param center 新的圆心位置
+     * @returns 当前圆形实例（链式调用）
+     */
+    setCenter(center: Vector2): this;
+    /**
+     * 设置半径
+     * @param radius 新的半径
+     * @returns 当前圆形实例（链式调用）
+     */
+    setRadius(radius: number): this;
+    /**
+     * 平移圆形
+     * @param dx X方向偏移
+     * @param dy Y方向偏移
+     * @returns 当前圆形实例（链式调用）
+     */
+    translate(dx: number, dy: number): this;
+    /**
+     * 平移圆形（使用向量）
+     * @param offset 偏移向量
+     * @returns 当前圆形实例（链式调用）
+     */
+    translateBy(offset: Vector2): this;
+    /**
+     * 缩放圆形
+     * @param scale 缩放因子
+     * @returns 当前圆形实例（链式调用）
+     */
+    scale(scale: number): this;
+    /**
+     * 扩展圆形
+     * @param amount 扩展量（正值扩大半径，负值缩小半径）
+     * @returns 当前圆形实例（链式调用）
+     */
+    inflate(amount: number): this;
+    /**
+     * 检查是否包含指定点
+     * @param point 点
+     * @returns 是否包含
+     */
+    containsPoint(point: Vector2): boolean;
+    /**
+     * 检查是否包含指定坐标
+     * @param x X坐标
+     * @param y Y坐标
+     * @returns 是否包含
+     */
+    contains(x: number, y: number): boolean;
+    /**
+     * 检查是否完全包含另一个圆形
+     * @param other 另一个圆形
+     * @returns 是否完全包含
+     */
+    containsCircle(other: Circle): boolean;
+    /**
+     * 检查点是否在圆的边界上
+     * @param point 点
+     * @param epsilon 容差，默认为Number.EPSILON
+     * @returns 是否在边界上
+     */
+    pointOnBoundary(point: Vector2, epsilon?: number): boolean;
+    /**
+     * 检查是否与另一个圆形相交
+     * @param other 另一个圆形
+     * @returns 是否相交
+     */
+    intersects(other: Circle): boolean;
+    /**
+     * 检查是否与矩形相交
+     * @param rect 矩形
+     * @returns 是否相交
+     */
+    intersectsRect(rect: Rectangle): boolean;
+    /**
+     * 计算与另一个圆形的相交面积
+     * @param other 另一个圆形
+     * @returns 相交面积
+     */
+    intersectionArea(other: Circle): number;
+    /**
+     * 计算圆心到点的距离
+     * @param point 点
+     * @returns 距离
+     */
+    distanceToPoint(point: Vector2): number;
+    /**
+     * 计算圆形边界到点的最短距离
+     * @param point 点
+     * @returns 最短距离（点在圆内时为负值）
+     */
+    distanceToPointFromBoundary(point: Vector2): number;
+    /**
+     * 计算两个圆心之间的距离
+     * @param other 另一个圆形
+     * @returns 圆心距离
+     */
+    distanceToCircle(other: Circle): number;
+    /**
+     * 计算两个圆形边界之间的最短距离
+     * @param other 另一个圆形
+     * @returns 最短距离（相交时为负值）
+     */
+    distanceToCircleFromBoundary(other: Circle): number;
+    /**
+     * 计算圆形到矩形的最短距离
+     * @param rect 矩形
+     * @returns 最短距离
+     */
+    distanceToRect(rect: Rectangle): number;
+    /**
+     * 获取圆形上距离指定点最近的点
+     * @param point 指定点
+     * @returns 最近点
+     */
+    closestPointTo(point: Vector2): Vector2;
+    /**
+     * 获取圆形上距离指定点最远的点
+     * @param point 指定点
+     * @returns 最远点
+     */
+    farthestPointFrom(point: Vector2): Vector2;
+    /**
+     * 获取指定角度上的圆周点
+     * @param angle 角度（弧度）
+     * @returns 圆周点
+     */
+    getPointAtAngle(angle: number): Vector2;
+    /**
+     * 获取点相对于圆心的角度
+     * @param point 点
+     * @returns 角度（弧度）
+     */
+    getAngleToPoint(point: Vector2): number;
+    /**
+     * 获取圆形与直线的交点
+     * @param lineStart 直线起点
+     * @param lineEnd 直线终点
+     * @returns 交点数组（0-2个点）
+     */
+    getLineIntersections(lineStart: Vector2, lineEnd: Vector2): Vector2[];
+    /**
+     * 检查两个圆形是否相等
+     * @param other 另一个圆形
+     * @param epsilon 容差，默认为Number.EPSILON
+     * @returns 是否相等
+     */
+    equals(other: Circle, epsilon?: number): boolean;
+    /**
+     * 检查两个圆形是否完全相等
+     * @param other 另一个圆形
+     * @returns 是否完全相等
+     */
+    exactEquals(other: Circle): boolean;
+    /**
+     * 从直径创建圆形
+     * @param x 圆心X坐标
+     * @param y 圆心Y坐标
+     * @param diameter 直径
+     * @returns 新的圆形实例
+     */
+    static fromDiameter(x: number, y: number, diameter: number): Circle;
+    /**
+     * 从三个点创建外接圆
+     * @param p1 第一个点
+     * @param p2 第二个点
+     * @param p3 第三个点
+     * @returns 外接圆，如果三点共线返回null
+     */
+    static fromThreePoints(p1: Vector2, p2: Vector2, p3: Vector2): Circle | null;
+    /**
+     * 从点数组创建最小包围圆
+     * @param points 点数组
+     * @returns 最小包围圆
+     */
+    static fromPointArray(points: Vector2[]): Circle;
+    /**
+     * 线性插值两个圆形
+     * @param a 起始圆形
+     * @param b 目标圆形
+     * @param t 插值参数（0到1）
+     * @returns 新的插值结果圆形
+     */
+    static lerp(a: Circle, b: Circle, t: number): Circle;
+    /**
+     * 转换为字符串
+     * @returns 字符串表示
+     */
+    toString(): string;
+    /**
+     * 转换为数组
+     * @returns [x, y, radius] 数组
+     */
+    toArray(): [number, number, number];
+    /**
+     * 转换为普通对象
+     * @returns {x, y, radius} 对象
+     */
+    toObject(): {
+        x: number;
+        y: number;
+        radius: number;
+    };
+}
+
+/**
+ * 数学工具函数集合
+ *
+ * 提供常用的数学运算、插值、随机数生成等实用工具函数
+ */
+declare class MathUtils {
+    /** 圆周率 */
+    static readonly PI: number;
+    /** 2π */
+    static readonly TWO_PI: number;
+    /** π/2 */
+    static readonly HALF_PI: number;
+    /** π/4 */
+    static readonly QUARTER_PI: number;
+    /** 角度到弧度转换系数 */
+    static readonly DEG_TO_RAD: number;
+    /** 弧度到角度转换系数 */
+    static readonly RAD_TO_DEG: number;
+    /** 黄金比例 */
+    static readonly GOLDEN_RATIO: number;
+    /** 默认浮点数比较容差 */
+    static readonly EPSILON: number;
+    /**
+     * 角度转弧度
+     * @param degrees 角度值
+     * @returns 弧度值
+     */
+    static degToRad(degrees: number): number;
+    /**
+     * 弧度转角度
+     * @param radians 弧度值
+     * @returns 角度值
+     */
+    static radToDeg(radians: number): number;
+    /**
+     * 规范化角度到[0, 2π)范围
+     * @param radians 角度（弧度）
+     * @returns 规范化后的角度
+     */
+    static normalizeAngle(radians: number): number;
+    /**
+     * 规范化角度到(-π, π]范围
+     * @param radians 角度（弧度）
+     * @returns 规范化后的角度
+     */
+    static normalizeAngleSigned(radians: number): number;
+    /**
+     * 计算两个角度之间的最短角度差
+     * @param from 起始角度（弧度）
+     * @param to 目标角度（弧度）
+     * @returns 角度差（-π到π）
+     */
+    static angleDifference(from: number, to: number): number;
+    /**
+     * 角度插值（处理角度环绕）
+     * @param from 起始角度（弧度）
+     * @param to 目标角度（弧度）
+     * @param t 插值参数（0到1）
+     * @returns 插值结果角度
+     */
+    static lerpAngle(from: number, to: number, t: number): number;
+    /**
+     * 限制数值在指定范围内
+     * @param value 待限制的值
+     * @param min 最小值
+     * @param max 最大值
+     * @returns 限制后的值
+     */
+    static clamp(value: number, min: number, max: number): number;
+    /**
+     * 限制数值在0到1之间
+     * @param value 待限制的值
+     * @returns 限制后的值
+     */
+    static clamp01(value: number): number;
+    /**
+     * 线性插值
+     * @param a 起始值
+     * @param b 目标值
+     * @param t 插值参数（0到1）
+     * @returns 插值结果
+     */
+    static lerp(a: number, b: number, t: number): number;
+    /**
+     * 反向线性插值（获取插值参数）
+     * @param a 起始值
+     * @param b 目标值
+     * @param value 当前值
+     * @returns 插值参数
+     */
+    static inverseLerp(a: number, b: number, value: number): number;
+    /**
+     * 重映射数值从一个范围到另一个范围
+     * @param value 输入值
+     * @param inMin 输入范围最小值
+     * @param inMax 输入范围最大值
+     * @param outMin 输出范围最小值
+     * @param outMax 输出范围最大值
+     * @returns 重映射后的值
+     */
+    static remap(value: number, inMin: number, inMax: number, outMin: number, outMax: number): number;
+    /**
+     * 平滑阶跃函数（Hermite插值）
+     * @param t 输入参数（0到1）
+     * @returns 平滑输出（0到1）
+     */
+    static smoothStep(t: number): number;
+    /**
+     * 更平滑的阶跃函数
+     * @param t 输入参数（0到1）
+     * @returns 平滑输出（0到1）
+     */
+    static smootherStep(t: number): number;
+    /**
+     * 浮点数相等比较
+     * @param a 数值a
+     * @param b 数值b
+     * @param epsilon 容差，默认为EPSILON
+     * @returns 是否相等
+     */
+    static approximately(a: number, b: number, epsilon?: number): boolean;
+    /**
+     * 检查数值是否为零
+     * @param value 数值
+     * @param epsilon 容差，默认为EPSILON
+     * @returns 是否为零
+     */
+    static isZero(value: number, epsilon?: number): boolean;
+    /**
+     * 获取数值的符号
+     * @param value 数值
+     * @returns 1、-1或0
+     */
+    static sign(value: number): number;
+    /**
+     * 生成指定范围内的随机数
+     * @param min 最小值（包含）
+     * @param max 最大值（不包含）
+     * @returns 随机数
+     */
+    static random(min?: number, max?: number): number;
+    /**
+     * 生成指定范围内的随机整数
+     * @param min 最小值（包含）
+     * @param max 最大值（包含）
+     * @returns 随机整数
+     */
+    static randomInt(min: number, max: number): number;
+    /**
+     * 随机选择数组中的一个元素
+     * @param array 数组
+     * @returns 随机元素
+     */
+    static randomChoice<T>(array: T[]): T;
+    /**
+     * 生成随机布尔值
+     * @param probability 为true的概率（0到1），默认0.5
+     * @returns 随机布尔值
+     */
+    static randomBoolean(probability?: number): boolean;
+    /**
+     * 生成单位圆内的随机点
+     * @returns 随机向量
+     */
+    static randomInUnitCircle(): Vector2;
+    /**
+     * 生成单位圆上的随机点
+     * @returns 随机单位向量
+     */
+    static randomOnUnitCircle(): Vector2;
+    /**
+     * 快速平方根倒数（用于归一化）
+     * @param value 输入值
+     * @returns 平方根倒数
+     */
+    static fastInverseSqrt(value: number): number;
+    /**
+     * 快速幂运算（整数指数）
+     * @param base 底数
+     * @param exponent 指数（整数）
+     * @returns 幂运算结果
+     */
+    static fastPow(base: number, exponent: number): number;
+    /**
+     * 阶乘
+     * @param n 非负整数
+     * @returns 阶乘结果
+     */
+    static factorial(n: number): number;
+    /**
+     * 最大公约数
+     * @param a 整数a
+     * @param b 整数b
+     * @returns 最大公约数
+     */
+    static gcd(a: number, b: number): number;
+    /**
+     * 最小公倍数
+     * @param a 整数a
+     * @param b 整数b
+     * @returns 最小公倍数
+     */
+    static lcm(a: number, b: number): number;
+    /**
+     * 斐波那契数列
+     * @param n 项数
+     * @returns 第n项斐波那契数
+     */
+    static fibonacci(n: number): number;
+    /**
+     * 等差数列求和
+     * @param first 首项
+     * @param last 末项
+     * @param count 项数
+     * @returns 等差数列和
+     */
+    static arithmeticSum(first: number, last: number, count: number): number;
+    /**
+     * 等比数列求和
+     * @param first 首项
+     * @param ratio 公比
+     * @param count 项数
+     * @returns 等比数列和
+     */
+    static geometricSum(first: number, ratio: number, count: number): number;
+    /**
+     * 贝塞尔二次曲线
+     * @param p0 控制点0
+     * @param p1 控制点1
+     * @param p2 控制点2
+     * @param t 参数（0到1）
+     * @returns 曲线上的点
+     */
+    static quadraticBezier(p0: Vector2, p1: Vector2, p2: Vector2, t: number): Vector2;
+    /**
+     * 贝塞尔三次曲线
+     * @param p0 控制点0
+     * @param p1 控制点1
+     * @param p2 控制点2
+     * @param p3 控制点3
+     * @param t 参数（0到1）
+     * @returns 曲线上的点
+     */
+    static cubicBezier(p0: Vector2, p1: Vector2, p2: Vector2, p3: Vector2, t: number): Vector2;
+    /**
+     * Catmull-Rom样条插值
+     * @param p0 控制点0
+     * @param p1 控制点1
+     * @param p2 控制点2
+     * @param p3 控制点3
+     * @param t 参数（0到1）
+     * @returns 插值结果点
+     */
+    static catmullRom(p0: Vector2, p1: Vector2, p2: Vector2, p3: Vector2, t: number): Vector2;
+    /**
+     * 简单伪随机噪声（基于种子）
+     * @param x 输入X
+     * @param y 输入Y
+     * @param seed 种子
+     * @returns 噪声值（0到1）
+     */
+    static noise(x: number, y?: number, seed?: number): number;
+    /**
+     * 平滑噪声
+     * @param x 输入X
+     * @param y 输入Y
+     * @param seed 种子
+     * @returns 平滑噪声值（0到1）
+     */
+    static smoothNoise(x: number, y?: number, seed?: number): number;
+    /**
+     * 将数值转换为指定精度
+     * @param value 数值
+     * @param precision 精度（小数位数）
+     * @returns 转换后的数值
+     */
+    static toPrecision(value: number, precision: number): number;
+    /**
+     * 检查数值是否在指定范围内
+     * @param value 数值
+     * @param min 最小值
+     * @param max 最大值
+     * @returns 是否在范围内
+     */
+    static inRange(value: number, min: number, max: number): boolean;
+    /**
+     * 获取数组中的最小值
+     * @param values 数值数组
+     * @returns 最小值
+     */
+    static min(...values: number[]): number;
+    /**
+     * 获取数组中的最大值
+     * @param values 数值数组
+     * @returns 最大值
+     */
+    static max(...values: number[]): number;
+    /**
+     * 计算数组的平均值
+     * @param values 数值数组
+     * @returns 平均值
+     */
+    static average(values: number[]): number;
+    /**
+     * 计算数组的中位数
+     * @param values 数值数组
+     * @returns 中位数
+     */
+    static median(values: number[]): number;
+}
+
+/**
+ * 碰撞信息接口
+ */
+interface CollisionInfo {
+    /** 是否发生碰撞 */
+    collided: boolean;
+    /** 碰撞法线（指向第二个对象） */
+    normal?: Vector2;
+    /** 穿透深度 */
+    penetration?: number;
+    /** 碰撞点 */
+    contactPoint?: Vector2;
+}
+/**
+ * 碰撞检测器
+ *
+ * 提供各种几何体之间的碰撞检测功能
+ */
+declare class CollisionDetector {
+    /**
+     * 点与圆形碰撞检测
+     * @param point 点
+     * @param circle 圆形
+     * @returns 碰撞信息
+     */
+    static pointCircle(point: Vector2, circle: Circle): CollisionInfo;
+    /**
+     * 点与矩形碰撞检测
+     * @param point 点
+     * @param rect 矩形
+     * @returns 碰撞信息
+     */
+    static pointRect(point: Vector2, rect: Rectangle): CollisionInfo;
+    /**
+     * 圆形与圆形碰撞检测
+     * @param circle1 第一个圆形
+     * @param circle2 第二个圆形
+     * @returns 碰撞信息
+     */
+    static circleCircle(circle1: Circle, circle2: Circle): CollisionInfo;
+    /**
+     * 圆形与矩形碰撞检测
+     * @param circle 圆形
+     * @param rect 矩形
+     * @returns 碰撞信息
+     */
+    static circleRect(circle: Circle, rect: Rectangle): CollisionInfo;
+    /**
+     * 矩形与矩形碰撞检测（AABB）
+     * @param rect1 第一个矩形
+     * @param rect2 第二个矩形
+     * @returns 碰撞信息
+     */
+    static rectRect(rect1: Rectangle, rect2: Rectangle): CollisionInfo;
+    /**
+     * 射线与圆形相交检测
+     * @param rayOrigin 射线起点
+     * @param rayDirection 射线方向（单位向量）
+     * @param circle 圆形
+     * @param maxDistance 最大检测距离，默认无限
+     * @returns 碰撞信息，包含距离信息
+     */
+    static rayCircle(rayOrigin: Vector2, rayDirection: Vector2, circle: Circle, maxDistance?: number): CollisionInfo & {
+        distance?: number;
+    };
+    /**
+     * 射线与矩形相交检测
+     * @param rayOrigin 射线起点
+     * @param rayDirection 射线方向（单位向量）
+     * @param rect 矩形
+     * @param maxDistance 最大检测距离，默认无限
+     * @returns 碰撞信息，包含距离信息
+     */
+    static rayRect(rayOrigin: Vector2, rayDirection: Vector2, rect: Rectangle, maxDistance?: number): CollisionInfo & {
+        distance?: number;
+    };
+    /**
+     * 线段与线段相交检测
+     * @param p1 第一条线段起点
+     * @param p2 第一条线段终点
+     * @param p3 第二条线段起点
+     * @param p4 第二条线段终点
+     * @returns 碰撞信息
+     */
+    static lineSegmentLineSegment(p1: Vector2, p2: Vector2, p3: Vector2, p4: Vector2): CollisionInfo;
+    /**
+     * 线段与圆形相交检测
+     * @param lineStart 线段起点
+     * @param lineEnd 线段终点
+     * @param circle 圆形
+     * @returns 碰撞信息
+     */
+    static lineSegmentCircle(lineStart: Vector2, lineEnd: Vector2, circle: Circle): CollisionInfo;
+    /**
+     * AABB包围盒快速排斥测试
+     * @param bounds1 第一个包围盒
+     * @param bounds2 第二个包围盒
+     * @returns 是否可能相交
+     */
+    static aabbTest(bounds1: Rectangle, bounds2: Rectangle): boolean;
+    /**
+     * 圆形包围盒快速排斥测试
+     * @param center1 第一个圆心
+     * @param radius1 第一个半径
+     * @param center2 第二个圆心
+     * @param radius2 第二个半径
+     * @returns 是否可能相交
+     */
+    static circleTest(center1: Vector2, radius1: number, center2: Vector2, radius2: number): boolean;
+}
+
+/**
+ * 缓动函数集合
+ *
+ * 提供各种常用的缓动函数，用于创建平滑的动画效果
+ * 所有函数接受时间参数 t (0-1)，返回缓动后的值 (通常0-1)
+ */
+declare class Easing {
+    /**
+     * 线性缓动（无缓动）
+     * @param t 时间参数 (0-1)
+     * @returns 缓动值
+     */
+    static linear(t: number): number;
+    /**
+     * 二次方缓入
+     * @param t 时间参数 (0-1)
+     * @returns 缓动值
+     */
+    static quadIn(t: number): number;
+    /**
+     * 二次方缓出
+     * @param t 时间参数 (0-1)
+     * @returns 缓动值
+     */
+    static quadOut(t: number): number;
+    /**
+     * 二次方缓入缓出
+     * @param t 时间参数 (0-1)
+     * @returns 缓动值
+     */
+    static quadInOut(t: number): number;
+    /**
+     * 三次方缓入
+     * @param t 时间参数 (0-1)
+     * @returns 缓动值
+     */
+    static cubicIn(t: number): number;
+    /**
+     * 三次方缓出
+     * @param t 时间参数 (0-1)
+     * @returns 缓动值
+     */
+    static cubicOut(t: number): number;
+    /**
+     * 三次方缓入缓出
+     * @param t 时间参数 (0-1)
+     * @returns 缓动值
+     */
+    static cubicInOut(t: number): number;
+    /**
+     * 四次方缓入
+     * @param t 时间参数 (0-1)
+     * @returns 缓动值
+     */
+    static quartIn(t: number): number;
+    /**
+     * 四次方缓出
+     * @param t 时间参数 (0-1)
+     * @returns 缓动值
+     */
+    static quartOut(t: number): number;
+    /**
+     * 四次方缓入缓出
+     * @param t 时间参数 (0-1)
+     * @returns 缓动值
+     */
+    static quartInOut(t: number): number;
+    /**
+     * 五次方缓入
+     * @param t 时间参数 (0-1)
+     * @returns 缓动值
+     */
+    static quintIn(t: number): number;
+    /**
+     * 五次方缓出
+     * @param t 时间参数 (0-1)
+     * @returns 缓动值
+     */
+    static quintOut(t: number): number;
+    /**
+     * 五次方缓入缓出
+     * @param t 时间参数 (0-1)
+     * @returns 缓动值
+     */
+    static quintInOut(t: number): number;
+    /**
+     * 正弦缓入
+     * @param t 时间参数 (0-1)
+     * @returns 缓动值
+     */
+    static sineIn(t: number): number;
+    /**
+     * 正弦缓出
+     * @param t 时间参数 (0-1)
+     * @returns 缓动值
+     */
+    static sineOut(t: number): number;
+    /**
+     * 正弦缓入缓出
+     * @param t 时间参数 (0-1)
+     * @returns 缓动值
+     */
+    static sineInOut(t: number): number;
+    /**
+     * 指数缓入
+     * @param t 时间参数 (0-1)
+     * @returns 缓动值
+     */
+    static expoIn(t: number): number;
+    /**
+     * 指数缓出
+     * @param t 时间参数 (0-1)
+     * @returns 缓动值
+     */
+    static expoOut(t: number): number;
+    /**
+     * 指数缓入缓出
+     * @param t 时间参数 (0-1)
+     * @returns 缓动值
+     */
+    static expoInOut(t: number): number;
+    /**
+     * 圆形缓入
+     * @param t 时间参数 (0-1)
+     * @returns 缓动值
+     */
+    static circIn(t: number): number;
+    /**
+     * 圆形缓出
+     * @param t 时间参数 (0-1)
+     * @returns 缓动值
+     */
+    static circOut(t: number): number;
+    /**
+     * 圆形缓入缓出
+     * @param t 时间参数 (0-1)
+     * @returns 缓动值
+     */
+    static circInOut(t: number): number;
+    /**
+     * 回弹缓入
+     * @param t 时间参数 (0-1)
+     * @param s 回弹强度，默认1.70158
+     * @returns 缓动值
+     */
+    static backIn(t: number, s?: number): number;
+    /**
+     * 回弹缓出
+     * @param t 时间参数 (0-1)
+     * @param s 回弹强度，默认1.70158
+     * @returns 缓动值
+     */
+    static backOut(t: number, s?: number): number;
+    /**
+     * 回弹缓入缓出
+     * @param t 时间参数 (0-1)
+     * @param s 回弹强度，默认1.70158
+     * @returns 缓动值
+     */
+    static backInOut(t: number, s?: number): number;
+    /**
+     * 弹性缓入
+     * @param t 时间参数 (0-1)
+     * @param amplitude 振幅，默认1
+     * @param period 周期，默认0.3
+     * @returns 缓动值
+     */
+    static elasticIn(t: number, amplitude?: number, period?: number): number;
+    /**
+     * 弹性缓出
+     * @param t 时间参数 (0-1)
+     * @param amplitude 振幅，默认1
+     * @param period 周期，默认0.3
+     * @returns 缓动值
+     */
+    static elasticOut(t: number, amplitude?: number, period?: number): number;
+    /**
+     * 弹性缓入缓出
+     * @param t 时间参数 (0-1)
+     * @param amplitude 振幅，默认1
+     * @param period 周期，默认0.45
+     * @returns 缓动值
+     */
+    static elasticInOut(t: number, amplitude?: number, period?: number): number;
+    /**
+     * 跳跃缓入
+     * @param t 时间参数 (0-1)
+     * @returns 缓动值
+     */
+    static bounceIn(t: number): number;
+    /**
+     * 跳跃缓出
+     * @param t 时间参数 (0-1)
+     * @returns 缓动值
+     */
+    static bounceOut(t: number): number;
+    /**
+     * 跳跃缓入缓出
+     * @param t 时间参数 (0-1)
+     * @returns 缓动值
+     */
+    static bounceInOut(t: number): number;
+    /**
+     * 创建自定义缓动函数（组合多个缓动）
+     * @param easingFunctions 缓动函数数组
+     * @param weights 权重数组，默认均等
+     * @returns 组合后的缓动函数
+     */
+    static combine(easingFunctions: ((t: number) => number)[], weights?: number[]): (t: number) => number;
+    /**
+     * 创建分段缓动函数
+     * @param segments 分段配置数组，每段包含 {duration, easing}
+     * @returns 分段缓动函数
+     */
+    static piecewise(segments: Array<{
+        duration: number;
+        easing: (t: number) => number;
+    }>): (t: number) => number;
+    /**
+     * 创建反向缓动函数
+     * @param easing 原缓动函数
+     * @returns 反向缓动函数
+     */
+    static reverse(easing: (t: number) => number): (t: number) => number;
+    /**
+     * 创建镜像缓动函数（先正向再反向）
+     * @param easing 原缓动函数
+     * @returns 镜像缓动函数
+     */
+    static mirror(easing: (t: number) => number): (t: number) => number;
+    /** 平滑进入（常用于UI动画） */
+    static readonly smoothIn: typeof Easing.quadOut;
+    /** 平滑退出（常用于UI动画） */
+    static readonly smoothOut: typeof Easing.quadIn;
+    /** 快速进入（常用于出现动画） */
+    static readonly quickIn: typeof Easing.cubicOut;
+    /** 快速退出（常用于消失动画） */
+    static readonly quickOut: typeof Easing.cubicIn;
+    /** 自然运动（模拟物理） */
+    static readonly natural: typeof Easing.quartOut;
+    /** 强调效果（吸引注意力） */
+    static readonly emphasize: typeof Easing.backOut;
+}
+
+/**
+ * 插值器类型定义
+ */
+type InterpolatorFunction<T> = (from: T, to: T, t: number) => T;
+/**
+ * 关键帧数据结构
+ */
+interface Keyframe<T> {
+    time: number;
+    value: T;
+    easing?: (t: number) => number;
+}
+/**
+ * 带缓存的插值器类
+ * 用于需要重复插值相同起始和目标值的情况
+ */
+declare class CachedInterpolator<T> {
+    private from?;
+    private to?;
+    private interpolator;
+    private cache;
+    constructor(interpolator: InterpolatorFunction<T>);
+    /**
+     * 设置插值范围
+     * @param from 起始值
+     * @param to 目标值
+     */
+    setRange(from: T, to: T): void;
+    /**
+     * 获取插值结果
+     * @param t 插值参数
+     * @returns 插值结果
+     */
+    get(t: number): T;
+    /**
+     * 清空缓存
+     */
+    clearCache(): void;
+}
+/**
+ * 插值工具类
+ *
+ * 提供各种类型的插值功能，用于创建平滑的数值变化
+ */
+declare class Interpolation {
+    /**
+     * 数值线性插值
+     * @param from 起始值
+     * @param to 目标值
+     * @param t 插值参数 (0-1)
+     * @returns 插值结果
+     */
+    static number(from: number, to: number, t: number): number;
+    /**
+     * 向量线性插值
+     * @param from 起始向量
+     * @param to 目标向量
+     * @param t 插值参数 (0-1)
+     * @returns 插值结果向量
+     */
+    static vector2(from: Vector2, to: Vector2, t: number): Vector2;
+    /**
+     * 角度插值（处理角度环绕）
+     * @param from 起始角度（弧度）
+     * @param to 目标角度（弧度）
+     * @param t 插值参数 (0-1)
+     * @returns 插值结果角度
+     */
+    static angle(from: number, to: number, t: number): number;
+    /**
+     * 颜色插值（RGB）
+     * @param from 起始颜色 [r, g, b, a?]
+     * @param to 目标颜色 [r, g, b, a?]
+     * @param t 插值参数 (0-1)
+     * @returns 插值结果颜色
+     */
+    static color(from: number[], to: number[], t: number): number[];
+    /**
+     * 三次样条插值
+     * @param p0 控制点0
+     * @param p1 控制点1（起点）
+     * @param p2 控制点2（终点）
+     * @param p3 控制点3
+     * @param t 插值参数 (0-1)
+     * @returns 插值结果
+     */
+    static cubicSpline(p0: number, p1: number, p2: number, p3: number, t: number): number;
+    /**
+     * Hermite插值
+     * @param p0 起始点
+     * @param m0 起始切线
+     * @param p1 结束点
+     * @param m1 结束切线
+     * @param t 插值参数 (0-1)
+     * @returns 插值结果
+     */
+    static hermite(p0: number, m0: number, p1: number, m1: number, t: number): number;
+    /**
+     * 球面线性插值（适用于方向向量）
+     * @param from 起始单位向量
+     * @param to 目标单位向量
+     * @param t 插值参数 (0-1)
+     * @returns 插值结果向量
+     */
+    static slerp(from: Vector2, to: Vector2, t: number): Vector2;
+    /**
+     * 创建带缓存的插值器
+     * 用于需要重复插值相同起始和目标值的情况
+     * @param interpolator 插值函数
+     * @returns 缓存插值器实例
+     */
+    static createCachedInterpolator<T>(interpolator: InterpolatorFunction<T>): CachedInterpolator<T>;
+    /**
+     * 样条曲线插值（通过多个控制点）
+     * @param points 控制点数组
+     * @param t 插值参数 (0-1)
+     * @returns 插值结果
+     */
+    static spline(points: number[], t: number): number;
+    /**
+     * 向量样条曲线插值
+     * @param points 控制点数组
+     * @param t 插值参数 (0-1)
+     * @returns 插值结果向量
+     */
+    static vectorSpline(points: Vector2[], t: number): Vector2;
+    /**
+     * 关键帧动画插值
+     * @param keyframes 关键帧数组（按时间排序）
+     * @param time 当前时间
+     * @param interpolator 插值函数
+     * @returns 插值结果
+     */
+    static keyframe<T>(keyframes: Keyframe<T>[], time: number, interpolator: InterpolatorFunction<T>): T;
+    /**
+     * 路径插值（沿着由点组成的路径）
+     * @param path 路径点数组
+     * @param t 插值参数 (0-1)
+     * @param closed 是否为闭合路径
+     * @returns 路径上的点
+     */
+    static pathInterpolation(path: Vector2[], t: number, closed?: boolean): Vector2;
+    /**
+     * 计算路径总长度
+     * @param path 路径点数组
+     * @param closed 是否为闭合路径
+     * @returns 路径总长度
+     */
+    static getPathLength(path: Vector2[], closed?: boolean): number;
+    /**
+     * 创建数值插值器
+     * @param from 起始值
+     * @param to 目标值
+     * @returns 插值器函数
+     */
+    static createNumberInterpolator(from: number, to: number): (t: number) => number;
+    /**
+     * 创建向量插值器
+     * @param from 起始向量
+     * @param to 目标向量
+     * @returns 插值器函数
+     */
+    static createVectorInterpolator(from: Vector2, to: Vector2): (t: number) => Vector2;
+    /**
+     * 创建组合插值器（插值多个值）
+     * @param interpolators 插值器数组
+     * @returns 组合插值器函数
+     */
+    static createCompositeInterpolator<T>(interpolators: InterpolatorFunction<T>[]): (from: T[], to: T[], t: number) => T[];
+}
+
+export { CachedInterpolator, Circle, CollisionDetector, Easing, Interpolation, MathUtils, Matrix3, Rectangle, Vector2 };
+export type { CollisionInfo, InterpolatorFunction, Keyframe };