kipphi 2.0.0 → 2.0.1

package/easing.ts

@@ -1,7 +1,8 @@
-import { type CustomEasingData, type EasingDataKPA2, EasingType, EventType, type SegmentedEasingData, type NormalEasingData, type BezierEasingData, type TemplateEasingData } from "./chartTypes";
-import { EventNodeSequence } from "./event";
+import { type TemplateEasingBodyData, type EasingDataKPA2, EasingType, EventType, type SegmentedEasingData, type NormalEasingData, type BezierEasingData, type TemplateEasingData, WrapperEasingData, WrapperEasingBodyData } from "./chartTypes";
+import { type EventNodeSequence } from "./event";
 import { type TupleCoord } from "./util";
 import Environment from "./env";
+import { type ExpressionEvaluator } from "./evaluator";
 
 
 /// #declaration:global
@@ -43,10 +44,6 @@ const easeOutBack = (x: number): number =>{
 }
 
 const linear = (x: number): number => x
-const linearLine: CurveDrawer = (context: CanvasRenderingContext2D, startX: number, startY: number, endX: number , endY: number) => 
-    drawLine(context, startX, startY, endX, endY);
-
-
 
 const easeOutSine = (x: number): number => Math.sin((x * Math.PI) / 2);
 
@@ -95,7 +92,12 @@ const easeInOutBack = toEaseInOut(easeInBack, easeOutBack);
 const easeInOutElastic = toEaseInOut(easeInElastic, easeOutElastic);
 const easeInOutBounce = toEaseInOut(easeInBounce, easeOutBounce);
 
-export const easingFnMap = {
+
+type FuncType = "linear" | "sine" | "quad" | "cubic" | "quart" | "quint" | "expo" | "circ" | "back" | "elastic" | "bounce"
+
+export const easingFnMap: {
+    [k in FuncType]: [(x: number) => number, (x: number) => number, (x: number) => number]
+} = {
     "linear": [linear, linear, linear],
     "sine": [easeInSine, easeOutSine, toEaseInOut(easeInSine, easeOutSine)],
     "quad": [easeInQuad, easeOutQuad, toEaseInOut(easeInQuad, easeOutQuad)],
@@ -134,24 +136,9 @@ export abstract class Easing {
         }
         return (t: number) => (this.getValue(easingLeft + timeDelta * t) - leftValue) / delta;
     }
-    drawCurve(context: CanvasRenderingContext2D, startX: number, startY: number, endX: number , endY: number): void {
-        const delta = endY - startY;
-        const timeDelta = endX - startX;
-        let last = startY;
-        context.beginPath()
-        context.moveTo(startX, last)
-        for (let t = 4; t <= timeDelta; t += 4) {
-            const ratio = t / timeDelta
-            const curPosY = this.getValue(ratio) * delta + startY;
-            context.lineTo(startX + t, curPosY);
-            last = curPosY;
-        }
-        context.stroke();
-    }
 }
 
 
-type CurveDrawer = (context: CanvasRenderingContext2D, startX: number, startY: number, endX: number , endY: number) => void
 
 
 /**
@@ -191,15 +178,11 @@ export class NormalEasing extends Easing {
     funcType: string;
     easeType: string;
     _getValue: (t: number) => number;
-    _drawCurve: CurveDrawer;
     constructor(fn: (t: number) => number);
-    constructor(fn: (t: number) => number, curveDrawer?: CurveDrawer);
-    constructor(fn: (t: number) => number, curveDrawer?: CurveDrawer) {
+    constructor(fn: (t: number) => number);
+    constructor(fn: (t: number) => number) {
         super()
         this._getValue = fn;
-        if (curveDrawer) {
-            this._drawCurve = curveDrawer;
-        }
     }
     getValue(t: number): number {
         if (t > 1 || t < 0) {
@@ -216,13 +199,6 @@ export class NormalEasing extends Easing {
             identifier: this.rpeId
         }
     }
-    drawCurve(context: CanvasRenderingContext2D, startX: number, startY: number, endX: number , endY: number) {
-        if (this._drawCurve) {
-            this._drawCurve(context, startX, startY, endX, endY)
-        } else {
-            super.drawCurve(context, startX, startY, endX, endY);
-        }
-    }
 }
 
 
@@ -234,18 +210,18 @@ export class NormalEasing extends Easing {
  * uses the Bezier curve formula to describe an easing.
  */
 export class BezierEasing extends Easing {
-    readonly xs: readonly number[];
-    readonly ys: readonly number[];
-    readonly jumper: readonly number[];
+    readonly xs: Float64Array;
+    readonly ys: Float64Array;
+    readonly jumper: Uint8Array;
     constructor(public readonly cp1: TupleCoord, public readonly cp2: TupleCoord) {
         super()
         const BEZIER_INTERPOLATION_DENSITY = Environment.BEZIER_INTERPOLATION_DENSITY;
         const BEZIER_INTERPOLATION_STEP = 1 / BEZIER_INTERPOLATION_DENSITY;
         // 插值，把贝塞尔曲线近似成256段折线
-        const xs: number[] = new Array(BEZIER_INTERPOLATION_DENSITY - 1);
-        const ys: number[] = new Array(BEZIER_INTERPOLATION_DENSITY - 1);
+        const xs = new Float64Array(BEZIER_INTERPOLATION_DENSITY - 1);
+        const ys = new Float64Array(BEZIER_INTERPOLATION_DENSITY - 1);
         /** 一把尺子，刻度均匀，从`插值步长*下标`映射到xs里面的下标 */
-        const jumper: number[] = new Array(BEZIER_INTERPOLATION_DENSITY);
+        const jumper = new Uint8Array(BEZIER_INTERPOLATION_DENSITY);
         let nextToFill = 0;
         for (let i = 1; i < BEZIER_INTERPOLATION_DENSITY; i++) {
             // 这个t是贝塞尔曲线生成参数
@@ -261,9 +237,9 @@ export class BezierEasing extends Easing {
         for (; 1 > nextToFill * BEZIER_INTERPOLATION_STEP; nextToFill++) {
             jumper[nextToFill] = BEZIER_INTERPOLATION_DENSITY - 1;
         }
-        this.xs = Object.freeze(xs);
-        this.ys = Object.freeze(ys);
-        this.jumper = Object.freeze(jumper);
+        this.xs = xs;
+        this.ys = ys;
+        this.jumper = jumper;
     }
     /**
      * 从横坐标获得纵坐标
@@ -296,19 +272,6 @@ export class BezierEasing extends Easing {
             bezier: [this.cp1[0], this.cp1[1], this.cp2[0], this.cp2[1]]
         }
     }
-    drawCurve(context: CanvasRenderingContext2D, startX: number, startY: number, endX: number , endY: number): void {
-        const [cp1x, cp1y] = this.cp1;
-        const [cp2x, cp2y] = this.cp2
-        const delta = endY - startY;
-        const timeDelta = endX - startX;
-        drawBezierCurve(
-            context,
-            startX, startY,
-            endX, endY,
-            startX + cp1x * timeDelta, startY + cp1y * delta,
-            startX + cp2x * timeDelta, startY + cp2y * delta,
-        )
-    }
 }
 
 /**
@@ -341,7 +304,7 @@ export class TemplateEasing extends Easing {
         }
     }
     get valueDelta(): number {
-        let seq = this.eventNodeSequence;
+        const seq = this.eventNodeSequence;
         return seq.tail.previous.value - seq.head.next.value;
     }
     get headValue(): number {
@@ -349,6 +312,24 @@ export class TemplateEasing extends Easing {
     }
 }
 
+export class WrapperEasing extends Easing {
+    // 需要一对面对面节点
+    constructor(public evaluator: ExpressionEvaluator<number>, public start: number, public end: number, public name: string) {
+        super()
+    }
+    getValue(t: number): number {
+        const end = this.end;
+        const start = this.start;
+        return (this.evaluator.func(t) - start) / (end - start);
+    }
+    dump(): WrapperEasingData {
+        return {
+            type: EasingType.wrapper,
+            identifier: this.name
+        }
+    }
+}
+
 
 
 
@@ -356,8 +337,10 @@ export class TemplateEasing extends Easing {
  * 缓动库
  * 用于管理模板缓动
  * for template easing management
+ * 
  * 谱面的一个属性
  * a property of chart
+ * 
  * 加载谱面时，先加载事件序列，所需的模板缓动会被加入到缓动库，但并不立即实现，在读取模板缓动时，才实现缓动。
  * To load a chart, the eventNodeSquences will be first loaded, during which process
  * the easings will be added to the easing library but not implemented immediately.
@@ -365,31 +348,42 @@ export class TemplateEasing extends Easing {
  * 
  */
 export class TemplateEasingLib {
-    easings: {
-        [name: string]: TemplateEasing
-    }
-    constructor() {
-        this.easings = {};
+    easings = new Map<string, TemplateEasing>();
+    wrapperEasings = new Map<string, WrapperEasing>();
+    // 被迫给一个静态方法进行依赖注入，恨死你了，ESM
+    constructor(public getNewSequence: (type: EventType, effectiveBeats: number) => EventNodeSequence<number>, public ExpressionEvaluatorCon: typeof ExpressionEvaluator) {
     }
     getOrNew(name: string): TemplateEasing {
         const DEFAULT_TEMPLATE_LENGTH = Environment.DEFAULT_TEMPLATE_LENGTH;
-        if (this.easings[name]) {
-            return this.easings[name];
+        if (this.easings.has(name)) {
+            return this.easings.get(name);
         } else {
-            const easing = new TemplateEasing(name, EventNodeSequence.newSeq(EventType.easing, DEFAULT_TEMPLATE_LENGTH));
+            const easing = new TemplateEasing(name, this.getNewSequence(EventType.easing, DEFAULT_TEMPLATE_LENGTH));
             easing.eventNodeSequence.id = "*" + name;
-            return this.easings[name] = easing;
+            this.easings.set(name, easing)
+            return easing;
+        }
+    }
+    readWrapperEasings(data: WrapperEasingBodyData[]) {
+        const len = data.length;
+        for (let i = 0; i < len; i++) {
+            const datum = data[i];
+            // 属于是油饼
+            this.wrapperEasings.set(datum.id, new WrapperEasing(new this.ExpressionEvaluatorCon(datum.jsExpr), datum.start, datum.end, datum.id))
         }
     }
+    getWrapper(name: string): WrapperEasing {
+        return this.wrapperEasings.get(name);
+    }
     /**
      * 注册一个模板缓动，但不会实现它
      * register a template easing when reading eventNodeSequences, but does not implement it immediately
      */
     require(name: string) {
-        this.easings[name] = new TemplateEasing(name, null);
+        this.easings.set(name, new TemplateEasing(name, null));
     }
     implement(name: string, sequence: EventNodeSequence) {
-        this.easings[name].eventNodeSequence = sequence;
+        this.easings.get(name).eventNodeSequence = sequence;
     }
     /**
      * 检查所有模板缓动是否实现
@@ -398,20 +392,19 @@ export class TemplateEasingLib {
      * should be invoked after all template easings are read
      */
     check() {
-        for (let key in this.easings) {
-            if (!this.easings[key].eventNodeSequence) {
-                console.warn(`未实现的缓动：${key}`);
+        for (const [name, easing] of this.easings) {
+            if (!easing.eventNodeSequence) {
+                console.warn(`未实现的缓动：${name}`);
             }
         }
     }
     get(key: string): TemplateEasing | undefined {
-        return this.easings[key];
+        return this.easings.get(key);
     }
     
-    dump(eventNodeSequences: Set<EventNodeSequence>): CustomEasingData[] {
-        const customEasingDataList: CustomEasingData[] = [];
-        for (let key in this.easings) {
-            const templateEasing = this.easings[key];
+    dump(eventNodeSequences: Set<EventNodeSequence>): TemplateEasingBodyData[] {
+        const customEasingDataList: TemplateEasingBodyData[] = [];
+        for (const [key, templateEasing] of this.easings) {
             const eventNodeSequence = templateEasing.eventNodeSequence;
             if (eventNodeSequences.has(eventNodeSequence)) {
                 continue;
@@ -419,16 +412,26 @@ export class TemplateEasingLib {
             eventNodeSequences.add(eventNodeSequence);
             customEasingDataList.push({
                 name: key,
-                content: eventNodeSequence.id, // 这里只存储编号，具体内容在保存时再编码
-                usedBy: [],
-                dependencies: []
+                content: eventNodeSequence.id // 这里只存储编号，具体内容在保存时再编码
             });
         }
         return customEasingDataList;
     }
+    dumpWrapperEasings(): WrapperEasingBodyData[] {
+        const wrapperEasingDataList: WrapperEasingBodyData[] = [];
+        for (const [key, wrapperEasing] of this.wrapperEasings) {
+            wrapperEasingDataList.push({
+                id: key,
+                jsExpr: wrapperEasing.evaluator.jsExpr,
+                start: wrapperEasing.start,
+                end: wrapperEasing.end
+            })
+        }
+        return wrapperEasingDataList;
+    }
 }
 
-export const linearEasing = new NormalEasing(linear, linearLine);
+export const linearEasing = new NormalEasing(linear);
 export const fixedEasing = new NormalEasing((x: number): number => (x === 1 ? 1 : 0));
 
 export const easingMap = {
@@ -446,8 +449,8 @@ export const easingMap = {
     "bounce": {in: new NormalEasing(easeInBounce), out: new NormalEasing(easeOutBounce), inout: new NormalEasing(easeInOutBounce)}
 }
 
-for (let funcType in easingMap) {
-    for (let easeType in easingMap[funcType]) {
+for (const funcType in easingMap) {
+    for (const easeType in easingMap[funcType]) {
         const easing = easingMap[funcType][easeType];
         easing.funcType = funcType;
         easing.easeType = easeType;
@@ -539,5 +542,8 @@ rpeEasingArray.forEach((easing, index) => {
     }
     easing.rpeId = index;
 })
+// 强行添加，避免存储不了这些缓动
+easingMap.expo.inout.rpeId = 101;
+easingMap.quint.inout.rpeId = 102;
 
 /// #enddeclaration

package/env.ts

@@ -1,7 +1,180 @@
 
+// chart              1
+// bpm                2
+// nnnlist            3
+// judgeline          4
+// nnList             5
+// EventNodeSequence  6
+// notenode           7
+// eventnode          8
+// evaluator          9
+// easing             a
+// note               b
+
+
+// 就挺神奇的！明明typeof后面跟值，这里却可以写成类型导入
+import { type TimeT, type EventValueType } from "./chartTypes";
+import { toTimeString } from "./util";
+
+// occupied 1
+// invalid data 2
+// invalid usage 3
+
+const
+    CHART = 0x100,
+    BPM = 0x200,
+    NNN_LIST = 0x300,
+    JUDGE_LINE = 0x400,
+    NN_LIST = 0x500,
+    ENS = 0x600,
+    NOTE_NODE = 0x700,
+    EVENT_NODE = 0x800,
+    EVALUATOR = 0x900,
+    EASING = 0xA00,
+    NOTE = 0xB00,
+    TC = 0xC00,
+    INTERNAL = 0xF00,
+
+    OCCPIED = 0x10,
+    INVALID_DATA = 0x20, // 一般是指读取谱面时的无效事件类型、缓动号等等
+    INVALID_USAGE = 0x30, // 不知道归入哪里就放这吧（（（
+    INVALID_TYPE = 0x40 // 这里的type指ECMAScript数据类型，事件类型错误可以归入此类
+    ;
+
+
+
+export enum ERROR_IDS {
+    UI_OCCUPIED =                                   CHART      | OCCPIED,
+
+
+    SEQUENCE_NAME_OCCUPIED =                        ENS        | OCCPIED       | 0,
+    SEQUENCE_NODE_TIME_OCCUPIED =                   ENS        | OCCPIED       | 1,
+    INVALID_EVENT_NODE_SEQUENCE_TYPE =              ENS        | INVALID_DATA  | 0,
+    EVENT_NODE_TIME_NOT_INCREMENTAL =               ENS        | INVALID_DATA  | 1,
+    PARENT_SEQUENCE_NOT_FOUND =                     ENS        | INVALID_USAGE | 1,
+    NEEDS_AT_LEAST_ONE_ENS =                        ENS        | INVALID_USAGE | 2,
+    SEQUENCE_TYPE_NOT_CONSISTENT =                  ENS        | INVALID_USAGE | 3,
+    
+    EXPECTED_TYPED_ENS =                            ENS        | INVALID_TYPE  | 0,
+
+    CANNOT_SUBSTITUTE_EXPRESSION_EVALUATOR =        EVENT_NODE | INVALID_USAGE | 0,
+    CANNOT_INSERT_BEFORE_HEAD =                     EVENT_NODE | INVALID_USAGE | 1,
+    CANNOT_GET_FULL_INTEGRAL_OF_FINAL_START_NODE =  EVENT_NODE | INVALID_USAGE | 2,
+    CANNOT_INTERPOLATE_TAILING_START_NODE =         EVENT_NODE | INVALID_USAGE | 3,
+
+    INVALID_EASING_ID =                             EASING     | INVALID_DATA  | 0,
+    CANNOT_IMPLEMENT_TEMEAS_WITH_NON_EASING_ENS =   EASING     | INVALID_DATA  | 1,
+    CANNOT_IMPLEMENT_TEMEAS_WITH_NON_NUMERIC_ENS =  EASING     | INVALID_DATA  | 2,
+    MUST_INTERPOLATE_TEMPLATE_EASING =              EASING     | INVALID_USAGE | 0,
+    NODES_NOT_CONTINUOUS =                          EASING     | INVALID_USAGE | 1,
+    NODES_NOT_BELONG_TO_SAME_SEQUENCE =             EASING     | INVALID_USAGE | 2,
+    NODES_HAS_ZERO_DELTA =                          EASING     | INVALID_USAGE | 3,
+
+    CANNOT_DIVIDE_EXPRESSION_EVALUATOR =            EVALUATOR  | INVALID_USAGE | 0,
+    
+    
+
+    INVALID_NOTE_PROP_TYPE =                        NOTE       | INVALID_TYPE  | 0,
+
+
+    INVALID_TIME_TUPLE =                            TC         | INVALID_DATA  | 0
+}
+
+export const ERRORS = {
+    UI_OCCUPIED: (name: string) =>
+        `UI '${name}' is occupied`,
+
+    
+    SEQUENCE_NAME_OCCUPIED: (name: string) =>
+        `Sequence name '${name}' is occupied`,
+    SEQUENCE_NODE_TIME_OCCUPIED: (time: TimeT, id: string) => 
+        `Time ${toTimeString(time)} already has a node (in sequence ${id})`,
+    INVALID_EVENT_NODE_SEQUENCE_TYPE: (type: any) =>
+        `Invalid event node sequence type: '${type}'`,
+    EXPECTED_TYPED_ENS: (typeStr: keyof typeof EventValueType, id: string, value: unknown) =>
+        `Expected EventNodeSequence for ${typeStr} but seen value ${value} (Processing ${id})`,
+    EVENT_NODE_TIME_NOT_INCREMENTAL: (pos: string) =>
+        `EventNode time is not incremental (at ${pos})`,
+    PARENT_SEQUENCE_NOT_FOUND: (nodeTime: TimeT) =>
+        `Parent EventNodeSequence not found for an EventNode at time ${toTimeString(nodeTime)} (Did you forget to add it to a sequence?)`,
+    NEEDS_AT_LEAST_ONE_ENS: () =>
+        `Needs at least one EventNodeSequence`,
+    SEQUENCE_TYPE_NOT_CONSISTENT: (typeStr: string, but: string) =>
+        `EventNodeSequence type is not consistent (expected ${typeStr} but seen value ${but})`,
+    
+    
+    CANNOT_SUBSTITUTE_EXPRESSION_EVALUATOR: () =>
+        `Cannot substitute ExpressionEvaluator`,
+    CANNOT_INSERT_BEFORE_HEAD: () =>
+        "Cannot insert before the first EventStartNode",
+    CANNOT_GET_FULL_INTEGRAL_OF_FINAL_START_NODE: () =>
+        "Cannot get full integral of final start node",
+    CANNOT_INTERPOLATE_TAILING_START_NODE: () =>
+        "Cannot interpolate tailing start node",
+
+    INVALID_EASING_ID: (id: string) =>
+        `Invalid easing id: '${id}'`,
+    CANNOT_IMPLEMENT_TEMEAS_WITH_NON_EASING_ENS: (temEasName: string) =>
+        `Cannot implement TemplateEasing with a non-easing-typed EventNodeSequence (Processing template '${temEasName}')`, 
+    CANNOT_IMPLEMENT_TEMEAS_WITH_NON_NUMERIC_ENS: (temEasName: string) =>
+        `Cannot implement TemplateEasing with a non-numeric EventNodeSequence (Processing template '${temEasName}')`, 
+    MUST_INTERPOLATE_TEMPLATE_EASING: () =>
+        "Must interpolate template easing",
+    
+    NODES_NOT_CONTINUOUS: () =>
+        "The EventNodes to encapsulate are not continuous",
+    NODES_NOT_BELONG_TO_SAME_SEQUENCE: () =>
+        "The EventNodes to encapsulate does not belong to same sequence",
+    NODES_HAS_ZERO_DELTA: () =>
+        "The EventNodes to encapsulate has zero delta",
+
+    INVALID_NOTE_PROP_TYPE: (prop: string, value: any, type: any) =>
+        `Invalid type for ${prop}. Got *${value}*, expected ${type}`,
+
+    INVALID_TIME_TUPLE: (tuple: any) =>
+        `Invalid time tuple: '${typeof tuple === "undefined" ? 'undefined' : tuple.valueOf()}'`,
+
+
+
+
+    CANNOT_DIVIDE_EXPRESSION_EVALUATOR: (id: string) =>
+        `Cannot divide ExpressionEvaluator (Compiling ${id})`,
+
+} satisfies Record<keyof typeof ERROR_IDS, (...args: any[]) => string>
+
+export class KPAError<ET extends ERROR_IDS> extends Error {
+    constructor(message: string, public id: ET) {
+        super(message);
+    }
+    /**
+     * 对于解析谱面等场景，有时可能需要找出全部的错误，不宜直接抛出错误中断代码执行
+     * 
+     * 此时可以调用该方法，该方法会输出错误并把它保存到KPAError的一个`buffer`静态属性下。
+     */
+    warn() {
+        console.warn(this.stack);
+        KPAError.buffer.push(this);
+    }
+    static buffer: KPAError<ERROR_IDS>[] = [];
+    static flush() {
+        KPAError.buffer = [];
+    }
+}
+
+export const err = new Proxy(ERRORS, {
+    get(target, name) {
+        return (...args: any[]) => new KPAError(target[name](...args) + `(KP${ERROR_IDS[name].toString(16)})`, ERROR_IDS[name]);
+    }
+}) as unknown as { [key in keyof typeof ERRORS]: (...args: Parameters<typeof ERRORS[key]>) => KPAError<typeof ERROR_IDS[key]>};
+
 export default {
     DEFAULT_TEMPLATE_LENGTH: 16,
     BEZIER_INTERPOLATION_DENSITY: 256,
     NNLIST_Y_OFFSET_HALF_SPAN: 100,
+    JUMPARRAY_MIN_LENGTH: 64,
+    JUMPARRAY_MAX_LENGTH: 4096,
+    JUMPARRAY_MINOR_SCALE_COUNT: 16,
+    ERROR_IDS,
+    err,
     freeze() { Object.freeze(this); }
 }

package/evaluator.ts

@@ -6,11 +6,10 @@ import {
 } from "./easing";
 
 
-import { TimeCalculator as TC } from "./time" 
+import TC from "./time";
 
-import type { Chart } from "./chart";
-import type { EventEndNode, EventStartNode } from "./event";
-import { EvaluatorType, EventValueType, InterpreteAs, type ColorEasedEvaluatorKPA2, type EasedEvaluatorDataOfType, type EvaluatorDataKPA2, type EventValueESType, type EventValueTypeOfType, type ExpressionEvaluatorDataKPA2, type NumericEasedEvaluatorKPA2, type RGB, type TextEasedEvaluatorKPA2 } from "./chartTypes";
+import type { EventEndNode, EventStartNode, NonLastStartNode } from "./event";
+import { EvaluatorType, InterpreteAs, type ColorEasedEvaluatorKPA2, type EvaluatorDataKPA2, type EventValueESType, type ExpressionEvaluatorDataKPA2, type NumericEasedEvaluatorKPA2, type RGB, type TextEasedEvaluatorKPA2 } from "./chartTypes";
 
 
 /// #declaration:global
@@ -30,13 +29,13 @@ export abstract class Evaluator<T> {
 }
 
 
-export abstract class EasedEvaluator<T> extends Evaluator<T> {
+export abstract class EasedEvaluator<T extends EventValueESType> extends Evaluator<T> {
     readonly easing: Easing;
     constructor(easing: Easing) {
         super();
         this.easing = easing;
     }
-    override eval(startNode: EventStartNode<T> & { next: EventEndNode }, beats: number): T {
+    override eval(startNode: NonLastStartNode<T>, beats: number): T {
         const next = startNode.next;
         const timeDelta = TC.getDelta(next.time, startNode.time)
         const current = beats - TC.toBeats(startNode.time)
@@ -48,7 +47,13 @@ export abstract class EasedEvaluator<T> extends Evaluator<T> {
         // 其他类型，包括普通缓动和非钩定模板缓动
         return this.convert(value, nextValue, this.easing.getValue(current / timeDelta));
     }
-    abstract convert(start: T, end: T, t: number): T;
+    abstract convert(start: T, end: T, progress: number): T;
+    /**
+     * 派生一个类型相同但使用不同缓动的求值器
+     * @param easing 
+     * @returns 
+     */
+    abstract deriveWithEasing(easing: Easing): EasedEvaluator<T>;
 }
 
 export type EasedEvaluatorOfType<T extends EventValueESType> = T extends number ? NumericEasedEvaluator : T extends RGB ? ColorEasedEvaluator : TextEasedEvaluator;
@@ -70,6 +75,13 @@ export class NumericEasedEvaluator extends EasedEvaluator<number> {
     }
     static default = new NumericEasedEvaluator(linearEasing);
     static evaluatorsOfNormalEasing: NumericEasedEvaluator[] = rpeEasingArray.map(easing => new NumericEasedEvaluator(easing));
+    override deriveWithEasing(easing: Easing): NumericEasedEvaluator {
+        if (easing instanceof NormalEasing) {
+            return NumericEasedEvaluator.evaluatorsOfNormalEasing[easing.rpeId];
+        } else {
+            return new NumericEasedEvaluator(easing);
+        }
+    }
 }
 
 export class ColorEasedEvaluator extends EasedEvaluator<RGB> {
@@ -90,6 +102,13 @@ export class ColorEasedEvaluator extends EasedEvaluator<RGB> {
     }
     static default = new ColorEasedEvaluator(linearEasing);
     static evaluatorsOfNormalEasing: ColorEasedEvaluator[] = rpeEasingArray.map(easing => new ColorEasedEvaluator(easing));
+    override deriveWithEasing(easing: Easing): ColorEasedEvaluator {
+        if (easing instanceof NormalEasing) {
+            return ColorEasedEvaluator.evaluatorsOfNormalEasing[easing.rpeId];
+        } else {
+            return new ColorEasedEvaluator(easing);
+        }
+    }
 }
 
 
@@ -102,8 +121,7 @@ export class ColorEasedEvaluator extends EasedEvaluator<RGB> {
  */
 export class TextEasedEvaluator extends EasedEvaluator<string> {
     constructor(easing: Easing,
-        public readonly interpretedAs: InterpreteAs = InterpreteAs.str,
-        public readonly font: string = "cmdysj.ttf"
+        public readonly interpretedAs: InterpreteAs = InterpreteAs.str
     )
     {
         super(easing);
@@ -112,8 +130,7 @@ export class TextEasedEvaluator extends EasedEvaluator<string> {
         return {
             type: EvaluatorType.eased,
             easing: this.easing.dump(),
-            interpretedAs: this.interpretedAs,
-            font: this.font
+            interpretedAs: this.interpretedAs
         }
     }
     override convert(value: string, nextValue: string, progress: number): string {
@@ -148,6 +165,13 @@ export class TextEasedEvaluator extends EasedEvaluator<string> {
         new TextEasedEvaluator(easing, InterpreteAs.int),
         new TextEasedEvaluator(easing, InterpreteAs.float),
     ]);
+    override deriveWithEasing(easing: Easing): EasedEvaluator<string> {
+        if (easing instanceof NormalEasing) {
+            return TextEasedEvaluator.evaluatorsOfNoEzAndItpAs[easing.rpeId][this.interpretedAs];
+        } else {
+            return new TextEasedEvaluator(easing, this.interpretedAs);
+        }
+    }
 }
 
 export class ExpressionEvaluator<T> extends Evaluator<T> {