kipphi 2.0.0 → 2.1.0

package/event.ts

@@ -1,13 +1,19 @@
 import type { Chart } from "./chart";
-import { EventType, type TimeT, type EventDataKPA, type RGB, type EventDataRPELike, InterpreteAs, type ValueTypeOfEventType, type EventNodeSequenceDataKPA, type EventDataKPA2, type EventNodeSequenceDataKPA2, type EventValueESType, EventValueType } from "./chartTypes";
+import { EventType, type TimeT, type EventDataKPA, type RGB, type EventDataRPELike, InterpreteAs, type ValueTypeOfEventType, type EventNodeSequenceDataKPA, type EventDataKPA2, type EventNodeSequenceDataKPA2, type EventValueESType, EventValueType, EventValueTypeOfType, FinalEventStartNodeDataKPA2, EvaluatorType, EasingType } from "./chartTypes";
 import { TemplateEasingLib, BezierEasing, Easing, rpeEasingArray, SegmentedEasing, linearEasing, fixedEasing, TemplateEasing, NormalEasing } from "./easing";
 import { ColorEasedEvaluator, EasedEvaluator, ExpressionEvaluator, NumericEasedEvaluator, TextEasedEvaluator, type Evaluator } from "./evaluator";
 import { JumpArray } from "./jumparray";
-import { TimeCalculator, TC } from "./time";
+
+import TC from "./time";
+import { type TimeCalculator } from "./bpm";
 import { NodeType } from "./util";
 
+import { err, ERROR_IDS, KPAError } from "./env";
+import { JudgeLine } from "./judgeline";
+import { EventMacro, EventMacroTime, EventMacroValue, Macroable } from "./macro";
+
 /// #declaration:global
-export class EventNodeLike<T extends NodeType, VT = number> {
+export class EventNodeLike<T extends NodeType, VT extends EventValueESType = number> {
     type: T;
     /** 后一个事件节点 */
     next: [EventStartNode<VT>, null, ENOrTail<VT>][T] | null = null;
@@ -18,10 +24,10 @@ export class EventNodeLike<T extends NodeType, VT = number> {
         this.type = type;
     }
 }
-export type ENOrTail<VT = number> = EventNode<VT> | EventNodeLike<NodeType.TAIL, VT>;
-export type ENOrHead<VT = number> = EventNode<VT> | EventNodeLike<NodeType.HEAD, VT>;
-export type AnyEN<VT = number> = EventNode<VT> | EventNodeLike<NodeType.HEAD, VT> | EventNodeLike<NodeType.TAIL, VT>;
-export type EvSoE<VT = number>    = EventEndNode<VT> | EventStartNode<VT>;
+export type ENOrTail<VT extends EventValueESType = number> = EventNode<VT> | EventNodeLike<NodeType.TAIL, VT>;
+export type ENOrHead<VT extends EventValueESType = number> = EventNode<VT> | EventNodeLike<NodeType.HEAD, VT>;
+export type AnyEN<VT extends EventValueESType = number> = EventNode<VT> | EventNodeLike<NodeType.HEAD, VT> | EventNodeLike<NodeType.TAIL, VT>;
+export type EvSoE<VT extends EventValueESType = number>    = EventEndNode<VT> | EventStartNode<VT>;
 
 /**
  * 事件节点基类
@@ -38,14 +44,16 @@ export type EvSoE<VT = number>    = EventEndNode<VT> | EventStartNode<VT>;
  * 与RPE不同的是，KPA使用两个节点来表示一个事件，而不是一个对象。
  * Different from that in RPE, KPA uses two nodes rather than one object to represent an event.
  */
-export abstract class EventNode<VT = number> extends EventNodeLike<NodeType.MIDDLE, VT> {
+export abstract class EventNode<VT extends EventValueESType = number> extends EventNodeLike<NodeType.MIDDLE, VT> {
     time: TimeT;
     value: VT;
     evaluator: Evaluator<VT>;
+    macroValue: EventMacroValue;
+    linkedMacros: Set<EventMacro<Macroable>> = new Set();
     constructor(time: TimeT, value: VT) {
         super(NodeType.MIDDLE);
-        this.time = TimeCalculator.validateIp([...time]);
-        // @ts-ignore 不清楚什么时候会是undefined，但是留着准没错
+        this.time = TC.validateIp([...time]);
+        // @ts-expect-error 不清楚什么时候会是undefined，但是留着准没错((
         this.value = value ?? 0;
         if (typeof value === "number") {
             this.evaluator = NumericEasedEvaluator.default as unknown as Evaluator<VT>;
@@ -57,7 +65,7 @@ export abstract class EventNode<VT = number> extends EventNodeLike<NodeType.MIDD
     }
     clone(offset: TimeT): EventStartNode<VT> | EventEndNode<VT> {
         const ret = new (this.constructor as (typeof EventStartNode | typeof EventEndNode))
-                        (offset ? TimeCalculator.add(this.time, offset) : this.time, this.value);
+                        (offset ? TC.add(this.time, offset) : this.time, this.value);
         ret.evaluator = this.evaluator;
         return ret;
     }
@@ -69,15 +77,15 @@ export abstract class EventNode<VT = number> extends EventNodeLike<NodeType.MIDD
      * @returns 
      * @deprecated
      */
-    static getEasing(data: EventDataKPA<any>, templates: TemplateEasingLib): Easing {
+    static getEasing(data: EventDataKPA<EventValueESType>, templates: TemplateEasingLib, notSegmented = false): Easing {
         const left = data.easingLeft;
         const right = data.easingRight;
-        if ((left && right) && (left !== 0.0 || right !== 1.0)) {
-            return new SegmentedEasing(EventNode.getEasing(data, templates), left, right)
+        if (!notSegmented && (left && right) && (left !== 0.0 || right !== 1.0)) {
+            return new SegmentedEasing(EventNode.getEasing(data, templates, true), left, right)
         }
         if (data.bezier) {
-            let bp = data.bezierPoints
-            let easing = new BezierEasing([bp[0], bp[1]], [bp[2], bp[3]]);
+            const bp = data.bezierPoints
+            const easing = new BezierEasing([bp[0], bp[1]], [bp[2], bp[3]]);
             return easing
         } else if (typeof data.easingType === "string") {
             return templates.get(data.easingType);
@@ -96,24 +104,24 @@ export abstract class EventNode<VT = number> extends EventNodeLike<NodeType.MIDD
      * @returns 
      * @deprecated
      */
-    static getEvaluator(data: EventDataKPA<any>, templates: TemplateEasingLib): Evaluator<any> {
+    static getEvaluator<VT extends EventValueESType>(data: EventDataKPA<VT>, templates: TemplateEasingLib, interpreteAs?: InterpreteAs): Evaluator<VT> {
         const left = data.easingLeft;
         const right = data.easingRight;
-        const wrap = (easing: Easing) => {
+        const wrap = (easing: Easing): EasedEvaluator<VT> => {
             if (typeof data.start === "number") {
-                return new NumericEasedEvaluator(easing);
+                return new NumericEasedEvaluator(easing) as unknown as EasedEvaluator<VT>;
             } else if (typeof data.start === "string") {
-                return new TextEasedEvaluator(easing, data.interpreteAs);
+                return new TextEasedEvaluator(easing, interpreteAs) as unknown as EasedEvaluator<VT>;
             } else {
-                return new ColorEasedEvaluator(easing);
+                return new ColorEasedEvaluator(easing) as unknown as EasedEvaluator<VT>;
             }
-        }
+        };
         if ((left && right) && (left !== 0.0 || right !== 1.0)) {
             return wrap(new SegmentedEasing(EventNode.getEasing(data, templates), left, right))
         }
         if (data.bezier) {
-            let bp = data.bezierPoints
-            let easing = new BezierEasing([bp[0], bp[1]], [bp[2], bp[3]]);
+            const bp = data.bezierPoints
+            const easing = new BezierEasing([bp[0], bp[1]], [bp[2], bp[3]]);
             return wrap(easing)
         } else if (data.isParametric) {
             if (typeof data.easingType !== "string") {
@@ -137,8 +145,8 @@ export abstract class EventNode<VT = number> extends EventNodeLike<NodeType.MIDD
      * @returns 
      */
     static fromEvent<VT extends RGB | number>(data: EventDataRPELike<VT>, chart: Chart): [EventStartNode<VT>, EventEndNode<VT>] {
-        let start = new EventStartNode(data.startTime, data.start)
-        let end = new EventEndNode(data.endTime, data.end);
+        const start = new EventStartNode(data.startTime, data.start)
+        const end = new EventEndNode(data.endTime, data.end);
         start.evaluator = EventNode.getEvaluator(data, chart.templateEasingLib);
         EventNode.connect(start, end);
         return [start, end]
@@ -161,16 +169,15 @@ export abstract class EventNode<VT = number> extends EventNodeLike<NodeType.MIDD
                 interpreteAs = InterpreteAs.int;
             }
         }
-        let start = new EventStartNode<string>(data.startTime, startValue);
-        let end = new EventEndNode<string>(data.endTime, endValue);
-        start.interpretedAs = interpreteAs;
-        start.evaluator = EventNode.getEvaluator(data, templates);
+        const start = new EventStartNode<string>(data.startTime, startValue);
+        const end = new EventEndNode<string>(data.endTime, endValue);
+        start.evaluator = EventNode.getEvaluator(data, templates, (data as unknown as EventDataKPA).interpreteAs ?? interpreteAs);
         EventNode.connect(start, end)
         return [start, end]
     }
-    static connect<VT>(node1: EventStartNode<VT>, node2: EventEndNode<VT> | EventNodeLike<NodeType.TAIL, VT>): void
-    static connect<VT>(node1: EventEndNode<VT> | EventNodeLike<NodeType.HEAD, VT>, node2: EventStartNode<VT>): void
-    static connect<VT>(node1: ENOrHead<VT>, node2: ENOrTail<VT>): void {
+    static connect<VT extends EventValueESType>(node1: EventStartNode<VT>, node2: EventEndNode<VT> | EventNodeLike<NodeType.TAIL, VT>): void
+    static connect<VT extends EventValueESType>(node1: EventEndNode<VT> | EventNodeLike<NodeType.HEAD, VT>, node2: EventStartNode<VT>): void
+    static connect<VT extends EventValueESType>(node1: ENOrHead<VT>, node2: ENOrTail<VT>): void {
         node1.next = node2;
         node2.previous = node1;
         if (node1 && node2) {
@@ -183,7 +190,7 @@ export abstract class EventNode<VT = number> extends EventNodeLike<NodeType.MIDD
      * @param startNode 
      * @returns 应该在何范围内更新跳数组
      */
-    static removeNodePair<VT>(endNode: EventEndNode<VT>, startNode: EventStartNode<VT>): [EventStartNode<VT> | EventNodeLike<NodeType.HEAD, VT>, EventStartNode<VT> | EventNodeLike<NodeType.TAIL,VT>] {
+    static removeNodePair<VT extends EventValueESType>(endNode: EventEndNode<VT>, startNode: EventStartNode<VT>): [EventStartNode<VT> | EventNodeLike<NodeType.HEAD, VT>, EventStartNode<VT> | EventNodeLike<NodeType.TAIL,VT>] {
         const prev = endNode.previous;
         const next = startNode.next;
         prev.next = next;
@@ -194,10 +201,10 @@ export abstract class EventNode<VT = number> extends EventNodeLike<NodeType.MIDD
         startNode.parentSeq = null; // 每亩的东西（
         return [this.previousStartOfStart(prev), this.nextStartOfEnd(next)]
     }
-    static insert<VT>(node: EventStartNode<VT>, tarPrev: EventStartNode<VT>): [EventNodeLike<NodeType.HEAD, VT> | EventStartNode<VT>, EventStartNode<VT> | EventNodeLike<NodeType.TAIL, VT>] {
+    static insert<VT extends EventValueESType>(node: EventStartNode<VT>, tarPrev: EventStartNode<VT>): [EventNodeLike<NodeType.HEAD, VT> | EventStartNode<VT>, EventStartNode<VT> | EventNodeLike<NodeType.TAIL, VT>] {
         const tarNext = tarPrev.next;
         if (node.previous.type === NodeType.HEAD) {
-            throw new Error("Cannot insert a head node before any node");
+            throw err.CANNOT_INSERT_BEFORE_HEAD();
         }
         this.connect(tarPrev, node.previous);
         node.parentSeq = node.previous.parentSeq;
@@ -209,7 +216,7 @@ export abstract class EventNode<VT = number> extends EventNodeLike<NodeType.MIDD
      * @param node 
      * @returns the next node if it is a tailer, otherwise the next start node
      */
-    static nextStartOfStart<VT>(node: EventStartNode<VT>) {
+    static nextStartOfStart<VT extends EventValueESType>(node: EventStartNode<VT>) {
         return node.next.type === NodeType.TAIL ? node.next : node.next.next
     }
     /**
@@ -217,10 +224,10 @@ export abstract class EventNode<VT = number> extends EventNodeLike<NodeType.MIDD
      * @param node 
      * @returns itself if node is a tailer, otherwise the next start node
      */
-    static nextStartOfEnd<VT>(node: EventEndNode<VT> | EventNodeLike<NodeType.TAIL, VT>) {
+    static nextStartOfEnd<VT extends EventValueESType>(node: EventEndNode<VT> | EventNodeLike<NodeType.TAIL, VT>) {
         return node.type === NodeType.TAIL ? node : node.next
     }
-    static previousStartOfStart<VT>(node: EventStartNode<VT>): EventStartNode<VT> | EventNodeLike<NodeType.HEAD, VT> {
+    static previousStartOfStart<VT extends EventValueESType>(node: EventStartNode<VT>): EventStartNode<VT> | EventNodeLike<NodeType.HEAD, VT> {
         return node.previous.type === NodeType.HEAD ? node.previous : node.previous.previous;
     }
     /**
@@ -228,10 +235,10 @@ export abstract class EventNode<VT = number> extends EventNodeLike<NodeType.MIDD
      * @param node 
      * @returns 
      */
-    static secondPreviousStartOfEnd<VT>(node: EventEndNode<VT>): EventStartNode<VT> | EventNodeLike<NodeType.HEAD, VT> {
+    static secondPreviousStartOfEnd<VT extends EventValueESType>(node: EventEndNode<VT>): EventStartNode<VT> | EventNodeLike<NodeType.HEAD, VT> {
         return this.previousStartOfStart(node.previous);
     }
-    static nextStartInJumpArray<VT>(node: EventStartNode<VT>): EventStartNode<VT> | EventNodeLike<NodeType.TAIL, VT> {
+    static nextStartInJumpArray<VT extends EventValueESType>(node: EventStartNode<VT>): EventStartNode<VT> | EventNodeLike<NodeType.TAIL, VT> {
         if ((node.next as EventEndNode<VT>).next.isLastStart()) {
             return node.next.next.next as EventNodeLike<NodeType.TAIL, VT>;
         } else {
@@ -243,7 +250,7 @@ export abstract class EventNode<VT = number> extends EventNodeLike<NodeType.MIDD
      * @param node 
      * @returns 
      */
-    static getEndStart<VT>(node: EventStartNode<VT> | EventEndNode<VT>): [EventEndNode<VT>, EventStartNode<VT>] {
+    static getEndStart<VT extends EventValueESType>(node: EventStartNode<VT> | EventEndNode<VT>): [EventEndNode<VT>, EventStartNode<VT>] {
         if (node instanceof EventStartNode) {
             if (node.isFirstStart()) {
                 throw new Error("Cannot get previous start node of the first start node");
@@ -253,23 +260,23 @@ export abstract class EventNode<VT = number> extends EventNodeLike<NodeType.MIDD
             return [node, node.next]
         }
     }
-    static getStartEnd<VT>(node: EventStartNode<VT> | EventEndNode<VT>): [EventStartNode<VT>, EventEndNode<VT>] {
+    static getStartEnd<VT extends EventValueESType>(node: EventStartNode<VT> | EventEndNode<VT>): [EventStartNode<VT>, EventEndNode<VT>] {
         if (node instanceof EventStartNode) {
             return [node, <EventEndNode<VT>>node.next]
         } else if (node instanceof EventEndNode) {
             return [<EventStartNode<VT>>node.previous, node]
         } else {
-            throw new Error("Invalid node type")
+            throw new Error("unreachable");
         }
     }
-    static setToNewOrderedArray<VT>(dest: TimeT, set: Set<EventStartNode<VT>>): [EventStartNode<VT>[], EventStartNode<VT>[]] {
+    static setToNewOrderedArray<VT extends EventValueESType>(dest: TimeT, set: Set<EventStartNode<VT>>): [EventStartNode<VT>[], EventStartNode<VT>[]] {
         const nodes = [...set]
-        nodes.sort((a, b) => TimeCalculator.gt(a.time, b.time) ? 1 : -1);
-        const offset = TimeCalculator.sub(dest, nodes[0].time)
+        nodes.sort((a, b) => TC.gt(a.time, b.time) ? 1 : -1);
+        const offset = TC.sub(dest, nodes[0].time)
         return [nodes, nodes.map(node => node.clonePair(offset))]
     }
     static belongToSequence(nodes: Set<EventStartNode>, sequence: EventNodeSequence): boolean {
-        for (let each of nodes) {
+        for (const each of nodes) {
             if (each.parentSeq !== sequence) {
                 return false;
             }
@@ -297,76 +304,16 @@ export abstract class EventNode<VT = number> extends EventNodeLike<NodeType.MIDD
     // #endregion
 }
 
-
-const getValueFns = [
-    (current: number, timeDelta: number, value: number, nextVal: number, easing: Easing) => {
-        
-        // @ts-ignore TSC脑壳有问题
-        const valueDelta = nextVal - value
-        // 其他类型，包括普通缓动和非钩定模板缓动
-        return value + easing.getValue(current / timeDelta) * valueDelta
-    },
-    (current: number, timeDelta: number, value: string, nextVal: string, easing: Easing, interpretedAs: InterpreteAs): string => {
-
-        if (interpretedAs === InterpreteAs.float) {
-            const start = parseFloat(value);
-            const delta = parseFloat(nextVal as string) - start;
-            return start + easing.getValue(current / timeDelta) * delta + "";
-        } else if (interpretedAs === InterpreteAs.int) {
-            const start = parseInt(value);
-            const delta = parseInt(nextVal as string) - start;
-            return start + Math.round(easing.getValue(current / timeDelta) * delta) + "";
-        } else if (value.startsWith(nextVal as string)) {
-            const startLen = (nextVal as string).length;
-            const deltaLen = value.length - startLen;
-            const len = startLen + Math.floor(deltaLen * easing.getValue(current / timeDelta));
-            return value.substring(0, len);
-        } else if ((nextVal as string).startsWith(value)) {
-            const startLen = value.length;
-            const deltaLen = (nextVal as string).length - startLen;
-            const len = startLen + Math.floor(deltaLen * easing.getValue(current / timeDelta));
-            return (nextVal as string).substring(0, len);
-        } else {
-            return value;
-        }
-
-    },
-    (current: number, timeDelta: number, value: RGB, nextValue: RGB, easing: Easing) => {
-        return (value as RGB).map((v, i) => {
-            const nextVal = nextValue[i];
-            const value = v;
-            if (nextVal === value) {
-                return value;
-            } else {
-                const delta = nextVal - value;
-                return value + easing.getValue(current / timeDelta) * delta;
-            }
-        })
-    }
-] as const;
-
-
-
-export class EventStartNode<VT = number> extends EventNode<VT> {
+export class EventStartNode<VT extends EventValueESType = number> extends EventNode<VT> {
     override next: EventEndNode<VT> | EventNodeLike<NodeType.TAIL, VT>;
     override previous: EventEndNode<VT> | EventNodeLike<NodeType.HEAD, VT>;
+    macroTime: EventMacroTime | null = null;
     /** 
-     * 对于速度事件，从计算时的时刻到此节点的总积分
+     * 对于速度事件，从0时刻到此节点的总积分
      */
-    cachedIntegral?: number;
+    floorPosition: number = 0;
     constructor(time: TimeT, value: VT) {
         super(time, value);
-        // 最史的一集，what can i say
-        if (typeof value === "number") {
-            // @ts-ignore
-            this.getValueFn = getValueFns[0];
-        } else if (typeof value === "string") {
-            // @ts-ignore
-            this.getValueFn = getValueFns[1];
-        } else {
-            // @ts-ignore
-            this.getValueFn = getValueFns[2];
-        }
     }
     override parentSeq: EventNodeSequence<VT>;
     /**
@@ -381,74 +328,56 @@ export class EventStartNode<VT = number> extends EventNode<VT> {
             end: endNode.value,
             startTime: this.time,
             endTime: endNode.time,
-            evaluator: this.evaluator.dump(),
+            evaluator: this.evaluator.dumpFor(this),
+            macroStart: this.macroValue?.dumpForNode(this),
+            macroEnd: this.macroValue?.dumpForNode(endNode),
+            macroStartTime: this.macroTime?.dumpForNode(this),
+            // 没有macroEndTime
+            startLinkedMacro: [...this.linkedMacros].map(macro => macro.dumpLinkForNode(this)),
+            endLinkedMacro: [...endNode.linkedMacros].map(macro => macro.dumpLinkForNode(endNode))
         }
     }
-    /**
-     * 产生一个一拍长的短钩定事件
-     * 仅用于编译至RPE时解决最后一个StartNode的问题
-     * 限最后一个StartNode使用
-     * @returns 
-     * /
-    dumpAsLast(): EventDataRPELike<VT> {
-        const isSegmented = this.easingIsSegmented
-        const easing = isSegmented ? (this.easing as SegmentedEasing).easing : this.easing;
+    dumpAsFinal(): FinalEventStartNodeDataKPA2<VT> {
         return {
-            bezier: easing instanceof BezierEasing ? 1 : 0,
-            bezierPoints: easing instanceof BezierEasing ?
-                [easing.cp1[0], easing.cp1[1], easing.cp2[0], easing.cp2[1]] : // 修正了这里 cp2.y 的引用
-                [0, 0, 0, 0],
-            easingLeft: isSegmented ? (this.easing as SegmentedEasing).left : 0.0,
-            easingRight: isSegmented ? (this.easing as SegmentedEasing).right : 1.0,
-            easingType: easing instanceof TemplateEasing ?
-                (easing.name) :
-                easing instanceof NormalEasing ?
-                    easing.rpeId :
-                    null,
-            end: this.value,
-            endTime: TimeCalculator.add(this.time, [1, 0, 1]),
-            linkgroup: 0, // 假设默认值为 0
             start: this.value,
             startTime: this.time,
+            evaluator: this.evaluator.dumpFor(this),
+            macro: this.macroValue?.dumpForNode(this),
+            macroTime: this.macroTime?.dumpForNode(this),
+            linkedMacro: [...this.linkedMacros].map(macro => macro.dumpLinkForNode(this)),
         }
-    }//*/
-    interpretedAs: InterpreteAs = InterpreteAs.str;
+    } 
     getValueAt(beats: number): VT {
         // 除了尾部的开始节点，其他都有下个节点
         // 钩定型缓动也有
         if (this.next.type === NodeType.TAIL) {
             return this.value;
         }
-        return this.evaluator.eval(this, beats);
+        return this.evaluator.eval(this as NonLastStartNode<VT>, beats);
     }
-    private getValueFn: (current: number, timeDelta: number, value: VT, nextVal: VT, easing: Easing, interpreteAs?: InterpreteAs) => VT
     getSpeedValueAt(this: EventStartNode<number>, beats: number) {
         if (this.next.type === NodeType.TAIL) {
-            return this.value
-        }
-        let timeDelta = TimeCalculator.getDelta(this.next.time, this.time)
-        let valueDelta = this.next.value - this.value
-        let current = beats - TimeCalculator.toBeats(this.time)
-        if (current > timeDelta || current < 0) {
-            console.warn("超过事件时间范围！", this, beats)
-            // debugger
+            return this.value;
         }
+        const timeDelta = TC.getDelta(this.next.time, this.time);
+        const valueDelta = this.next.value - this.value;
+        const current = beats - TC.toBeats(this.time);
         return this.value + linearEasing.getValue(current / timeDelta) * valueDelta;
     }
     /**
      * 积分获取位移
      */
-    getIntegral(this: EventStartNode<number>, beats: number, timeCalculator: TimeCalculator) {
-        return timeCalculator.segmentToSeconds(TimeCalculator.toBeats(this.time), beats) * (this.value + this.getSpeedValueAt(beats)) / 2 * 120 // 每单位120px
+    getLocalFloorPos(this: EventStartNode<number>, beats: number, timeCalculator: TimeCalculator) {
+        return timeCalculator.segmentToSeconds(TC.toBeats(this.time), beats) * (this.value + this.getSpeedValueAt(beats)) / 2 * 120 // 每单位120px
     }
-    getFullIntegral(this: EventStartNode<number>, timeCalculator: TimeCalculator) {
+    getFullLocalFloorPos(this: EventStartNode<number>, timeCalculator: TimeCalculator) {
         if (this.next.type === NodeType.TAIL) {
             console.log(this)
-            throw new Error("getFullIntegral不可用于尾部节点")
+            throw err.CANNOT_GET_FULL_INTEGRAL_OF_FINAL_START_NODE();
         }
-        let end = this.next;
-        let endBeats = TimeCalculator.toBeats(end.time)
-        let startBeats = TimeCalculator.toBeats(this.time)
+        const end = this.next;
+        const endBeats = TC.toBeats(end.time)
+        const startBeats = TC.toBeats(this.time)
         // 原来这里写反了，气死偶咧！
         return timeCalculator.segmentToSeconds(startBeats, endBeats) * (this.value + end.value) / 2 * 120
     }
@@ -458,6 +387,9 @@ export class EventStartNode<VT = number> extends EventNode<VT> {
     isLastStart() {
         return this.next && this.next.type === NodeType.TAIL
     }
+    isSpeed() {
+        return this.parentSeq.type === EventType.speed;
+    }
     override clone(offset?: TimeT): EventStartNode<VT> {
         return super.clone(offset) as EventStartNode<VT>;
     };
@@ -467,32 +399,15 @@ export class EventStartNode<VT = number> extends EventNode<VT> {
         EventNode.connect(endNode, startNode);
         return startNode;
     };
-
-    
-    drawCurve(context: CanvasRenderingContext2D, startX: number, startY: number, endX: number , endY: number, matrix: Matrix): void {
-        if (!(this.easing instanceof ParametricEquationEasing)) {
-            return this.easing.drawCurve(context, startX, startY, endX, endY);
-        }
-        const getValue = (ratio: number) => {
-            return matrix.ymul(0, this.easing.getValue(ratio))
-        }
-        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 = getValue(ratio);
-            context.lineTo(startX + t, curPosY);
-            last = curPosY;
-        }
-        context.stroke();
-    }
 }
 
-export class EventEndNode<VT = number> extends EventNode<VT> {
+export type NonLastStartNode<VT extends EventValueESType> = EventStartNode<VT> & {next: EventEndNode<VT>}
+
+export class EventEndNode<VT extends EventValueESType = number> extends EventNode<VT> {
     override next!: EventStartNode<VT>;
     override previous!: EventStartNode<VT>;
+
+    // @ts-expect-error 这里没有类型安全问题
     override get parentSeq(): EventNodeSequence<VT> {return this.previous?.parentSeq || null}
     override set parentSeq(_parent: EventNodeSequence<VT>) {}
     constructor(time: TimeT, value: VT) {
@@ -507,6 +422,12 @@ export class EventEndNode<VT = number> extends EventNode<VT> {
 }
 
 
+export enum Monotonicity {
+    increasing,
+    decreasing,
+    swinging
+}
+
 /**
  * 为一个链表结构。会有一个数组进行快跳。
  * is the list of event nodes, but not purely start nodes.
@@ -533,32 +454,52 @@ export class EventEndNode<VT = number> extends EventNode<VT> {
  * 插入或删除节点时，需要更新跳数组。
  * Remember to update the jump array when inserting or deleting nodes.
  */
-export class EventNodeSequence<VT = number> { // 泛型的传染性这一块
+export class EventNodeSequence<VT extends EventValueESType = number> { // 泛型的传染性这一块
+    /**
+     * @deprecated 谱面属性未实装，以后有必要的时候会添加为其赋值的逻辑
+     */
     chart: Chart;
-    /** id follows the format `#${lineid}.${layerid}.${typename}` by default */
+    /** 标识名默认遵循`#${lineid}.${layerid}.${typename}`格式
+     * id follows the format `#${lineid}.${layerid}.${typename}` by default
+     */
     id: string;
-    /** has no time or value */
     head: EventNodeLike<NodeType.HEAD, VT>;
-    /** has no time or value */
     tail: EventNodeLike<NodeType.TAIL, VT>;
     jump?: JumpArray<AnyEN<VT>>;
     listLength: number;
     /** 一定是二的幂，避免浮点误差 */
     jumpAverageBeats: number;
-    // nodes: EventNode[];
-    // startNodes: EventStartNode[];
-    // endNodes: EventEndNode[];
-    // eventTime: Float64Array;
+
+    /**
+     * 用于速度事件优化
+     */
+    monotonicity: Monotonicity = Monotonicity.swinging;
+
+    /**
+     * 使用了该序列的判定线，当前仅用于速度事件对fp的更新
+     */
+    consumerLines = new Set<JudgeLine>;
+
     constructor(public type: EventType, public effectiveBeats: number) {
         this.head = new EventNodeLike(NodeType.HEAD);
         this.tail = new EventNodeLike(NodeType.TAIL);
         this.head.parentSeq = this.tail.parentSeq = this;
         this.listLength = 1;
-        // this.head = this.tail = new EventStartNode([0, 0, 0], 0)
-        // this.nodes = [];
-        // this.startNodes = [];
-        // this.endNodes = [];
     }
+    /**
+     * 获取指定事件类型的事件默认值。
+     * Get the default value of the specified event type.
+     * 
+     * 对于文字事件，默认值为空字符串。
+     * 
+     * 对于缩放事件，默认值为1.0。
+     * 
+     * 对于颜色事件，默认值为黑色（[0, 0, 0]）。
+     * 
+     * 对于速度事件，默认值为10（1200像素/秒）。
+     * 
+     * 对于一般数值事件，默认值为0。
+     */
     static getDefaultValueFromEventType(type: EventType) {
         
         return type === EventType.speed                               ? 10  :
@@ -567,15 +508,26 @@ export class EventNodeSequence<VT = number> { // 泛型的传染性这一块
                type === EventType.color                               ? [0, 0, 0] :
                0
     }
-    static fromRPEJSON<T extends EventType, VT = number>(type: T, data: EventDataRPELike<VT>[], chart: Chart, endValue?: number) {
+    /**
+     * 从RPEJSON数据创建一个事件序列。
+     * 
+     * KPAJSON 1.x也会使用此接口
+     * @param type 事件类型（不是数值类型，也不是数值ECMAScript类型）
+     * @param data 事件数据的数组
+     * @param chart 
+     * @param pos 当前事件序列应当具有什么ID（用于报错和警告，外部调用可以写空字符串）
+     * @param endValue 结束值（RPEJSON没有）
+     * @returns 
+     */
+    static fromRPEJSON<T extends EventType, VT extends EventValueESType = number>(type: T, data: EventDataRPELike<VT>[], chart: Chart, pos: string, endValue?: number) {
         const {templateEasingLib: templates} = chart
         const length = data.length;
         // const isSpeed = type === EventType.Speed;
         // console.log(isSpeed)
-        const seq = new EventNodeSequence<VT>(type, type === EventType.easing ? TimeCalculator.toBeats(data[length - 1].endTime) : chart.effectiveBeats);
+        const seq = new EventNodeSequence<VT>(type, type === EventType.easing ? TC.toBeats(data[length - 1].endTime) : chart.effectiveBeats);
         let listLength = length;
         let lastEnd: EventEndNode<VT> | EventNodeLike<NodeType.HEAD, VT> = seq.head;
-        // 如果第一个事件不从0时间开始，那么添加一对面对面节点来垫背
+        // 如果第一个事件不从0时间开始，那么添加一对面对面节点来垫底
         if (data[0] && TC.ne(data[0].startTime, [0, 0, 1])) {
             const value = data[0].start
             const start = new EventStartNode<VT>([0, 0, 1], value as VT);
@@ -585,59 +537,90 @@ export class EventNodeSequence<VT = number> { // 泛型的传染性这一块
             lastEnd = end;
         }
 
-        let lastIntegral: number = 0;
+        // 当前仅用于检查时间递增
+        let lastEndTime: TimeT = [0, 0, 1];
+
+        // 读取事件列表
         for (let index = 0; index < length; index++) {
             const event = data[index];
-            // @ts-ignore
-            let [start, end] = (type === EventType.text ? EventNode.fromTextEvent(event, templates) : EventNode.fromEvent(event, templates)) as unknown as [EventStartNode<VT>, EventEndNode<VT>];
+            if (TC.lt(event.startTime, lastEndTime)) { // event.startTime < lastEndTime
+                err.EVENT_NODE_TIME_NOT_INCREMENTAL(`${pos}.events[${index}] and the previous`).warn()
+            }
+            if (!TC.lt(event.startTime, event.endTime)) {
+                err.EVENT_NODE_TIME_NOT_INCREMENTAL(`${pos}.events[${index}]`).warn()
+            }
+            lastEndTime = event.endTime;
+            const [start, end] = (type === EventType.text
+                                ? EventNode.fromTextEvent(event as EventDataRPELike<string>, templates)
+                                : EventNode.fromEvent(event as EventDataRPELike<number | RGB>, chart)) as unknown as [EventStartNode<VT>, EventEndNode<VT>];
+            // 刚开始时，上个节点是头
             if (lastEnd.type === NodeType.HEAD) {
                 EventNode.connect(lastEnd, start)
             // 如果上一个是钩定事件，那么一块捋平
             } else if (lastEnd.value === lastEnd.previous.value && lastEnd.previous.evaluator instanceof EasedEvaluator) {
                 lastEnd.time = start.time
                 EventNode.connect(lastEnd, start)
-            } else if (TimeCalculator.toBeats(lastEnd.time) !== TimeCalculator.toBeats(start.time)) {
-                let val = lastEnd.value;
-                let midStart = new EventStartNode(lastEnd.time, val);
-                let midEnd = new EventEndNode(start.time, val);
+            
+            // 如果上一个事件的结束时间和下一个事件的开始时间不一样，那么中间插入一对面对面节点
+            } else if (TC.toBeats(lastEnd.time) !== TC.toBeats(start.time)) {
+                const val = lastEnd.value;
+                const midStart = new EventStartNode(lastEnd.time, val);
+                const midEnd = new EventEndNode(start.time, val);
                 midStart.evaluator = lastEnd.previous.evaluator;
                 EventNode.connect(lastEnd, midStart);
                 EventNode.connect(midStart, midEnd);
                 EventNode.connect(midEnd, start)
-                // seq.startNodes.push(midStart);
-                // seq.endNodes.push(midEnd);
                 listLength++;
+            // 最后应该就是上一个事件和这个事件首尾相接的情况
             } else {
                 
                 EventNode.connect(lastEnd, start)
             }
             
-            // seq.startNodes.push(start);
-            // seq.endNodes.push(end);
             lastEnd = end;
-            // seq.nodes.push(start, end);
         }
         const last = lastEnd;
         const tail = new EventStartNode(
             last.type === NodeType.HEAD ? [0, 0, 1] : last.time,
-            last.type === NodeType.HEAD ? endValue : last.value
+            endValue ?? (last as EventEndNode<VT>).value
         );
         EventNode.connect(last, tail);
         // last can be a header, in which case easing is undefined.
         // then we use the easing that initialized in the EventStartNode constructor.
         tail.evaluator = last.previous?.evaluator ?? tail.evaluator;
-        tail.cachedIntegral = lastIntegral
         EventNode.connect(tail, seq.tail)
         seq.listLength = listLength;
         seq.initJump();
+        if (type === EventType.speed) {
+            (seq as SpeedENS).updateFloorPositionAfter((seq as SpeedENS).head.next, chart.timeCalculator)
+        }
         return seq;
     }
-    static fromKPA2JSON<T extends EventType, VT extends EventValueESType = number>(type: T, data: EventDataKPA2<VT>[], chart: Chart, endValue?: number) {
-        const {templateEasingLib: templates} = chart
+    /**
+     * 从KPAJSON 2.x数据创建一个事件序列。
+     * @param type 事件类型（不是数值类型，也不是数值ECMAScript类型）
+     * @param data 事件数据的数组
+     * @param chart 
+     * @param pos 当前事件序列应当具有什么ID（用于报错和警告）
+     * @param finalNodeData 最终节点数据
+     * @returns 
+     */
+    static fromKPA2JSON<T extends EventType, VT extends EventValueESType = number>(
+        type: T,
+        data: EventDataKPA2<VT>[],
+        chart: Chart,
+        pos: string,
+        finalNodeData: FinalEventStartNodeDataKPA2<VT>
+    )
+    {
         const length = data.length;
         // const isSpeed = type === EventType.Speed;
         // console.log(isSpeed)
-        const seq = new EventNodeSequence<VT>(type, type === EventType.easing ? TimeCalculator.toBeats(data[length - 1].endTime) : chart.effectiveBeats);
+        const seq = new EventNodeSequence<VT>(
+            type,
+            type === EventType.easing
+                ? TC.toBeats(data[length - 1].endTime)
+                : chart.effectiveBeats);
         let listLength = length;
         let lastEnd: EventEndNode<VT> | EventNodeLike<NodeType.HEAD, VT> = seq.head;
         // 如果第一个事件不从0时间开始，那么添加一对面对面节点来垫背
@@ -650,24 +633,38 @@ export class EventNodeSequence<VT = number> { // 泛型的传染性这一块
             lastEnd = end;
         }
 
-        const valueType = type === EventType.color ? EventValueType.color
+        const valueType = (type === EventType.color ? EventValueType.color
                         : type === EventType.text  ? EventValueType.text
-                        : EventValueType.numeric;
+                        : EventValueType.numeric) as EventValueTypeOfType<VT>;
+
+
 
-        let lastIntegral: number = 0;
+        let lastEndTime: TimeT = [0, 0, 1];
         for (let index = 0; index < length; index++) {
             const event = data[index];
-            let [start, end] = chart.createEventFromData<VT>(event, valueType);
+            const [start, end] = chart.createEventFromData<VT>(event, valueType, `${pos}.events[${index}]`);
+            // 从前面复制了，复用性减一
+            // KPA2没有更改RPE的按事件存储的机制。
+            if (TC.lt(event.startTime, lastEndTime)) { // event.startTime < lastEndTime
+                err.EVENT_NODE_TIME_NOT_INCREMENTAL(`${pos}.events[${index}] and the previous`).warn()
+            }
+            if (!TC.lt(event.startTime, event.endTime)) {
+                err.EVENT_NODE_TIME_NOT_INCREMENTAL(`${pos}.events[${index}]`).warn()
+            }
+            lastEndTime = event.endTime;
             if (lastEnd.type === NodeType.HEAD) {
                 EventNode.connect(lastEnd, start)
             // 如果上一个是钩定事件，那么一块捋平
-            } else if (lastEnd.value === lastEnd.previous.value && lastEnd.previous.evaluator instanceof EasedEvaluator) {
+            } else if (
+                   lastEnd.value === lastEnd.previous.value
+                && lastEnd.previous.evaluator instanceof EasedEvaluator
+            ) {
                 lastEnd.time = start.time
                 EventNode.connect(lastEnd, start)
-            } else if (TimeCalculator.toBeats(lastEnd.time) !== TimeCalculator.toBeats(start.time)) {
-                let val = lastEnd.value;
-                let midStart = new EventStartNode(lastEnd.time, val);
-                let midEnd = new EventEndNode(start.time, val);
+            } else if (TC.eq(lastEnd.time, start.time)) {
+                const val = lastEnd.value;
+                const midStart = new EventStartNode(lastEnd.time, val);
+                const midEnd = new EventEndNode(start.time, val);
                 midStart.evaluator = lastEnd.previous.evaluator;
                 EventNode.connect(lastEnd, midStart);
                 EventNode.connect(midStart, midEnd);
@@ -681,18 +678,30 @@ export class EventNodeSequence<VT = number> { // 泛型的传染性这一块
             lastEnd = end;
         }
         const last = lastEnd;
-        const tail = new EventStartNode(
-            last.type === NodeType.HEAD ? [0, 0, 1] : last.time,
-            last.type === NodeType.HEAD ? endValue : last.value
+        const final = chart.createFinalEventStartNodeFromData(
+            finalNodeData || {
+                // @ts-expect-error 简化写法
+                start: last.value ?? this.getDefaultValueFromEventType(type),
+                // @ts-expect-error 极其边缘情况，finalNodeData只有在内测的谱面里面才可能为null，且last一般都有值
+                startTime: last.time,
+                evaluator: {
+                    type: EvaluatorType.eased,
+                    easing: {
+                        type: EasingType.normal,
+                        identifier: linearEasing.rpeId
+                    }
+                }
+            } satisfies FinalEventStartNodeDataKPA2<any>,
+            valueType,
+            pos + ".finalNode"
         );
-        EventNode.connect(last, tail);
-        // last can be a header, in which case easing is undefined.
-        // then we use the easing that initialized in the EventStartNode constructor.
-        tail.evaluator = last.previous?.evaluator ?? tail.evaluator;
-        tail.cachedIntegral = lastIntegral
-        EventNode.connect(tail, seq.tail)
+        EventNode.connect(last, final);
+        EventNode.connect(final, seq.tail)
         seq.listLength = listLength;
         seq.initJump();
+        if (type === EventType.speed) {
+            (seq as SpeedENS).updateFloorPositionAfter((seq as SpeedENS).head.next, chart.timeCalculator)
+        }
         return seq;
     }
     /**
@@ -702,11 +711,16 @@ export class EventNodeSequence<VT = number> { // 泛型的传染性这一块
      * @param effectiveBeats 
      * @returns 
      */
-    static newSeq<T extends EventType>(type: T, effectiveBeats: number): EventNodeSequence<ValueTypeOfEventType<T>> {
+    static newSeq<T extends EventType>(
+        type: T,
+        effectiveBeats: number
+    ): EventNodeSequence<ValueTypeOfEventType<T>>
+    {
         type V = ValueTypeOfEventType<T>
         const sequence = new EventNodeSequence<V>(type, effectiveBeats);
         const node = new EventStartNode<V>(
-            [0, 0, 1], EventNodeSequence.getDefaultValueFromEventType(type) as V
+            [0, 0, 1],
+            EventNodeSequence.getDefaultValueFromEventType(type) as V
         );
         EventNode.connect(sequence.head, node)
         EventNode.connect(node, sequence.tail)
@@ -736,7 +750,7 @@ export class EventNodeSequence<VT = number> { // 泛型的传染性这一块
                     return [0, node.next]
                 }
                 const endNode = (node as EventStartNode<VT>).next as EventEndNode<VT>;
-                const time = TimeCalculator.toBeats(endNode.time);
+                const time = TC.toBeats(endNode.time);
                 const nextNode = endNode.next;
                 if (nextNode.next.type === NodeType.TAIL) {
                     return [time, nextNode.next] // Tailer代替最后一个StartNode去占位
@@ -745,9 +759,9 @@ export class EventNodeSequence<VT = number> { // 泛型的传染性这一块
                 }
             },
             (node: EventStartNode<VT>, beats: number) => {
-                return TimeCalculator.toBeats((node.next as EventEndNode<VT>).time) > beats ? false : EventNode.nextStartInJumpArray(node)
+                return TC.toBeats((node.next as EventEndNode<VT>).time) > beats ? false : EventNode.nextStartInJumpArray(node)
             },
-            (node: EventStartNode) => {
+            (node: AnyEN<VT>) => {
                 return node.next && node.next.type === NodeType.TAIL ? node.next : node;
             }
             /*(node: EventStartNode) => {
@@ -762,12 +776,10 @@ export class EventNodeSequence<VT = number> { // 泛型的传染性这一块
 
         }
         this.jump.updateRange(from, to);
-    }
-    insert() {
-
     }
     getNodeAt(beats: number, usePrev: boolean = false): EventStartNode<VT> {
-        let node = this.jump?.getNodeAt(beats) as (EventStartNode<VT> | EventNodeLike<NodeType.TAIL, VT>)
+        let node 
+            = this.jump?.getNodeAt(beats) as (EventStartNode<VT> | EventNodeLike<NodeType.TAIL, VT>)
                 || this.head.next as (EventStartNode<VT> | EventNodeLike<NodeType.TAIL, VT>);
         if (node.type === NodeType.TAIL) {
             if (usePrev) {
@@ -776,13 +788,13 @@ export class EventNodeSequence<VT = number> { // 泛型的传染性这一块
             // 最后一个事件节点本身具有无限延伸的特性
             return node.previous;
         }
-        if (usePrev && TimeCalculator.toBeats(node.time) === beats) {
+        if (usePrev && TC.toBeats(node.time) === beats) {
             const prev = node.previous;
             if (!(prev.type === NodeType.HEAD)) {
                 node = prev.previous;
             }
         }
-        if (TimeCalculator.toBeats(node.time) > beats && beats >= 0) {
+        if (TC.toBeats(node.time) > beats && beats >= 0) {
             console.warn("Got a node after the given beats. This would only happen when the given beats is negative. Beats and Node:", beats, node)
         }
         return node;
@@ -790,20 +802,44 @@ export class EventNodeSequence<VT = number> { // 泛型的传染性这一块
     getValueAt(beats: number, usePrev: boolean = false): VT {
         return this.getNodeAt(beats, usePrev).getValueAt(beats);
     }
-    getIntegral(this: EventNodeSequence<number>, beats: number, timeCalculator: TimeCalculator) {
+    getFloorPositionAt(this: EventNodeSequence<number>, beats: number, timeCalculator: TimeCalculator) {
         const node: EventStartNode<number> = this.getNodeAt(beats);
-        return node.getIntegral(beats, timeCalculator) + node.cachedIntegral
+        const value = node.getLocalFloorPos(beats, timeCalculator) + node.floorPosition;
+        if (isNaN(value)) {
+            debugger;
+        }
+        return value
     }
-    updateNodesIntegralFrom(this: EventNodeSequence<number>, beats: number, timeCalculator: TimeCalculator) {
-        let previousStartNode = this.getNodeAt(beats);
-        previousStartNode.cachedIntegral = -previousStartNode.getIntegral(beats, timeCalculator);
-        let totalIntegral: number = previousStartNode.cachedIntegral
-        let endNode: EventEndNode | EventNodeLike<NodeType.TAIL>;
-        while ((endNode = previousStartNode.next).type !== NodeType.TAIL) {
-            const currentStartNode = endNode.next
-            totalIntegral += previousStartNode.getFullIntegral(timeCalculator);
-            currentStartNode.cachedIntegral = totalIntegral;
-            previousStartNode = currentStartNode;
+    /**
+     * 更新某个速度节点之后的FP
+     * 
+     * 注意，修改节点并不会影响它的FP，而是它后面的所有节点的FP，节点存的是它所在位置的FP，节点在事件头部
+     * @param this 
+     * @param node 
+     * @param tc 
+     * 
+     * @example
+     * node.value += 1;
+     * (node.parentSequence as SpeedENS).updateFloorPositionAfter(node, tc);
+     */
+    updateFloorPositionAfter(this: SpeedENS, node: EventStartNode, tc: TimeCalculator): void {
+        let currentFP: number;
+        if (node.floorPosition) {
+            currentFP = node.floorPosition;
+        } else if (node.previous.type !== NodeType.HEAD) {
+            const prevStart = node.previous.previous;
+            currentFP = prevStart.floorPosition + prevStart.getFullLocalFloorPos(tc);
+        } else {
+            currentFP = 0;
+        }
+        while (true) {
+            const canBeEnd = node.next;
+            if (canBeEnd.type === NodeType.TAIL) {
+                break;
+            }
+            currentFP += node.getFullLocalFloorPos(tc);
+            node = canBeEnd.next;
+            node.floorPosition = currentFP
         }
     }
     dump(): EventNodeSequenceDataKPA2<VT> {
@@ -820,12 +856,12 @@ export class EventNodeSequence<VT = number> { // 泛型的传染性这一块
             type: this.type,
             events: nodes,
             id: this.id,
-            endValue: currentNode.value
+            final: currentNode.dumpAsFinal()
         };
     }
 
-    getNodesFromOneAndRangeRight(node: EventStartNode<VT>, rangeRight: TimeT) {
-        const arr = []
+    getNodesFromOneAndRangeRight(node: EventStartNode<VT>, rangeRight: TimeT): EventStartNode<VT>[] {
+        const arr: EventStartNode<VT>[] = []
         for (; !TC.gt(node.time, rangeRight); ) {
             const next = node.next;
             arr.push(node);
@@ -836,8 +872,8 @@ export class EventNodeSequence<VT = number> { // 泛型的传染性这一块
         }
         return arr;
     }
-    getNodesAfterOne(node: EventStartNode<VT>) {
-        const arr = []
+    getNodesAfterOne(node: EventStartNode<VT>): EventStartNode<VT>[] {
+        const arr: EventStartNode<VT>[] = []
         while (true) {
             const next = node.next;
             if (next.type === NodeType.TAIL) {
@@ -848,6 +884,72 @@ export class EventNodeSequence<VT = number> { // 泛型的传染性这一块
         }
         return arr;
     }
+//    connectLine(consumer: JudgeLine) {
+//        this.consumerLines.add(consumer);
+//    }
+//    disconnectLine(consumer: JudgeLine) {
+//        this.consumerLines.delete(consumer);
+//    }
+    /**
+     * 将多个事件层上的数值性事件节点序列合为一个
+     * 
+     * 目前仅用于速度序列，因为就他是线性的（
+     * 
+     * 会创建新序列
+     * @param sequences 
+     * @throws {KPAError<ERROR_IDS.NEEDS_AT_LEAST_ONE_ENS>}
+     */
+    static mergeSequences(sequences: EventNodeSequence[]) {
+        if (sequences.length < 1) {
+            throw err.NEEDS_AT_LEAST_ONE_ENS();
+        }
+        const dest = EventNodeSequence.newSeq(EventType.speed, sequences[0].effectiveBeats);
+        dest.head.next.value = 0;
+        dest.id = sequences[0].id + "_merged";
+        for (const seq of sequences) {
+            if (seq.type !== EventType.speed) {
+                throw err.SEQUENCE_TYPE_NOT_CONSISTENT("speed", EventType[seq.type]);
+            }
+            const nodesToChange: [EventStartNode | EventEndNode, number][] = [];
+            const inserts: [toInsert: EventStartNode, targetBeats: number][] = [];
+            let endNode = seq.head.next.next;
+            // 这里是背靠背遍历，不是面对面遍历
+            // 我把节点关系都写这里了，通义灵码还不会看，乱给补全，罚他看114514遍
+            while (endNode.type !== NodeType.TAIL) {
+                const startNode = endNode.next;
+                const endTime = endNode.time;
+                const endBeats = TC.toBeats(endTime);
+                const targetStart = dest.getNodeAt(endBeats)
+                if (TC.eq(targetStart.time, endTime)) {
+                    const targetEnd = targetStart.previous as EventEndNode;
+                    nodesToChange.push([targetStart, startNode.value]);
+                    nodesToChange.push([targetEnd, endNode.value]);
+                } else {
+                    const newEnd = new EventEndNode(endTime, endNode.value + targetStart.getValueAt(endBeats));
+                    const newStart = new EventStartNode(endTime, startNode.value + targetStart.getValueAt(endBeats));
+                    EventNode.connect(newEnd, newStart);
+                    inserts.push([newStart, endBeats]);
+                }
+                endNode = startNode.next;
+            }
+            dest.head.next.value += seq.head.next.value;
+            const len1 = nodesToChange.length;
+            for (let i = 0; i < len1; i++) {
+                const tup = nodesToChange[i];
+                tup[0].value += tup[1];
+            }
+            const len2 = inserts.length;
+            for (let i = 0; i < len2; i++) {
+                const tup = inserts[i];
+                // 这都updateJump
+                dest.updateJump(...EventNode.insert(tup[0], dest.getNodeAt(tup[1])));
+            }
+        }
+        dest.initJump();
+        return dest;
+    }
 }
 
+export type SpeedENS = EventNodeSequence<number> & { type: EventType.speed };
+
 /// #enddeclaration