kipphi 2.1.3-beta.2 → 2.1.4-beta.1

package/event.ts

@@ -391,7 +391,7 @@ export class EventStartNode<VT extends EventValueESType = number> extends EventN
         return super.clone(offset) as EventStartNode<VT>;
     };
     clonePair(offset: TimeT): EventStartNode<VT> {
-        const endNode = this.previous.type !== NodeType.HEAD ? this.previous.clone(offset) : new EventEndNode(this.time, this.value);
+        const endNode = this.previous.type !== NodeType.HEAD ? this.previous.clone(offset) : null;
         const startNode = this.clone(offset);
         EventNode.connect(endNode, startNode);
         return startNode;
@@ -518,6 +518,7 @@ export class EventNodeSequence<VT extends EventValueESType = number> { // 泛型
      */
     static fromRPEJSON<T extends EventType, VT extends EventValueESType = number>(type: T, data: EventDataRPELike<VT>[], chart: Chart, pos: string, endValue?: number) {
         const {templateEasingLib: templates} = chart
+        data.sort((a, b) => TC.cmp(a.startTime, b.startTime));
         const length = data.length;
         // const isSpeed = type === EventType.Speed;
         // console.log(isSpeed)

package/index.d.ts

@@ -553,7 +553,7 @@ declare module "chartTypes" {
     export type ExtendedEventTypeName = "scaleX" | "scaleY" | "text" | "color";
 }
 declare module "version" {
-    export const VERSION = 213;
+    export const VERSION = 214;
     export const SCHEMA = "https://cdn.jsdelivr.net/npm/kipphi@2.1.0/chartType2.schema.json";
 }
 declare module "util" {
@@ -1081,133 +1081,6 @@ declare module "judgeline" {
         cachedFloorPositions: Float64Array;
         computeCurrentFloorPosition(beats: number, timeCalculator: TimeCalculator): void;
         getRelativeFloorPositionAt(beats: number, timeCalculator: TimeCalculator): number;
-        /**
-         * 通过速度序列的FloorPosition反解出一个时间范围。
-         *
-         * KPA内核代码中最大的一坨史山，没有之一。
-         *
-         * 谱面渲染时最耗时的函数
-         *
-         * startY and endY must not be negative
-         * @param beats
-         * @param timeCalculator
-         * @param startY
-         * @param endY
-         * @returns
-         * /
-        computeTimeRange(beats: number, timeCalculator: TimeCalculator , startY: number, endY: number): [number, number][] {
-            //return [[0, Infinity]]
-            //*
-            // 提取所有有变化的时间点
-            let times: number[] = [];
-            const result: [number, number][] = [];
-            for (const eventLayer of this.eventLayers) {
-                const sequence = eventLayer?.speed;
-                if (!sequence) {
-                    continue;
-                }
-                let node: EventStartNode = sequence.getNodeAt(beats);
-                let endNode: EventEndNode | EventNodeLike<NodeType.TAIL>
-                while (true) {
-                    times.push(TC.toBeats(node.time))
-                    if ((endNode = node.next).type === NodeType.TAIL) {
-                        break;
-                    }
-    
-                    node = endNode.next
-                }
-            }
-            times = [...new Set(times)].sort((a, b) => a - b)
-            const len = times.length;
-            let nextTime = times[0]
-            let nextPosY = this.getStackedFloorPosition(nextTime, timeCalculator)
-            let nextSpeed = this.getStackedValue("speed", nextTime, true)
-            let range: [number, number] = [undefined, undefined];
-            // console.log(times)
-            const computeTime = (speed: number, currentPos: number, fore: number) => timeCalculator.secondsToBeats(currentPos / (speed * 120) + timeCalculator.toSeconds(fore));
-            for (let i = 0; i < len - 1;) {
-                const thisTime = nextTime;
-                const thisPosY = nextPosY;
-                let thisSpeed = this.getStackedValue("speed", thisTime);
-                if (Math.abs(thisSpeed) < 1e-8) {
-                    thisSpeed = 0; // 不这样做可能导致下面异号判断为真从而死循环
-                }
-                nextTime = times[i + 1]
-                nextPosY = this.getStackedFloorPosition(nextTime, timeCalculator);
-                nextSpeed = this.getStackedValue("speed", nextTime, true)
-                // console.log(thisSpeed, nextSpeed, thisSpeed * nextSpeed < 0, i, [...result])
-                if (thisSpeed * nextSpeed < 0) { // 有变号零点，再次切断，保证处理的每个区间单调性
-                    //debugger;
-                    nextTime = (nextTime - thisTime) * (0 - thisSpeed) / (nextSpeed - thisSpeed) + thisTime;
-                    nextSpeed = 0
-                    nextPosY = this.getStackedFloorPosition(nextTime, timeCalculator)
-                    //debugger
-                } else {
-                    // console.log("i++")
-                    i++
-                }
-                if (range[0] === undefined) {
-                    // 变速区间直接全部囊括，匀速要算一下，因为好算
-                    /*
-                    设两个时间点的位置为a,b
-                    开始结束点为s,e
-                    选中小段一部分在区间内：
-                    a < s <= b
-                    或a > e >= b
-                    全部在区间内
-                    s <= a <= b
-                    * /
-                    if (thisPosY < startY && startY <= nextPosY
-                    || thisPosY > endY && endY >= nextPosY) {
-                        range[0] = thisSpeed !== nextSpeed ? thisTime : computeTime(
-                            thisSpeed,
-                            (thisPosY < nextPosY ? startY : endY) - thisPosY, thisTime)
-                    } else if (startY <= thisPosY && thisPosY <= endY) {
-                        range[0] = thisTime;
-                    }
-                }
-                // 要注意这里不能合成双分支if因为想要的Y片段可能在一个区间内
-                if (range[0] !== undefined) {
-                    if (thisPosY < endY && endY <= nextPosY || thisPosY > startY && startY >= nextPosY) {
-                        range[1] = thisSpeed !== nextSpeed ? nextTime : computeTime(
-                            thisSpeed,
-                            (thisPosY > nextPosY ? startY : endY) - thisPosY, thisTime)
-                        result.push(range)
-                        range = [undefined, undefined];
-                    }
-                }
-            }
-            const thisPosY = nextPosY;
-            const thisTime = nextTime;
-            const thisSpeed = this.getStackedValue("speed", thisTime);
-            const inf = thisSpeed > 0 ? Infinity : (thisSpeed < 0 ? -Infinity : thisPosY)
-            if (range[0] === undefined) {
-                // 变速区间直接全部囊括，匀速要算一下，因为好算
-                if (thisPosY < startY && startY <= inf || thisPosY >= endY && endY > inf) {
-                    range[0] = computeTime(
-                        thisSpeed,
-                        (thisPosY < inf ? startY : endY) - thisPosY,
-                        thisTime)
-                } else if (thisSpeed === 0) {
-                    range[0] = 0;
-                }
-            }
-            // 要注意这里不能合成双分支if因为想要的Y片段可能在一个区间内
-            if (range[0] !== undefined) {
-                if (thisPosY < endY && endY <= inf || thisPosY >= startY && startY > inf) {
-                    range[1] = computeTime(
-                        thisSpeed,
-                        (thisPosY > inf ? startY : endY) - thisPosY,
-                        thisTime)
-                    result.push(range)
-                } else if (thisSpeed === 0) {
-                    range[1] = Infinity;
-                    result.push(range)
-                }
-            }
-            return result;
-            //* /
-        }*/
         /**
           * 通过速度序列的FloorPosition反解出一个时间范围。
           *
@@ -2415,6 +2288,7 @@ declare module "time" {
         static gt(beaT1: TimeT, beaT2: TimeT): boolean;
         /** @returns beaT1 < beaT2 */
         static lt(beaT1: TimeT, beaT2: TimeT): boolean;
+        static cmp(beaT1: TimeT, beaT2: TimeT): number;
         /** @returns beaT1 != beaT2 */
         static ne(beaT1: TimeT, beaT2: TimeT): boolean;
         /**
@@ -2608,6 +2482,9 @@ declare module "operation/event" {
         overlapping: boolean;
         constructor(node: EventStartNode<VT>, targetPrevious: EventStartNode<VT>, updatesFP?: boolean);
     }
+    export class EventNodePairAutoInsertOperation<VT extends EventValueESType> extends EventNodePairInsertOperation<VT> {
+        constructor(node: EventStartNode<VT>, parentSeq: EventNodeSequence<VT>, updatesFP?: boolean);
+    }
     export class EventNodeValueChangeOperation<VT extends EventValueESType> extends Operation {
         updatesEditor: boolean;
         node: EventNode<VT>;
@@ -3082,7 +2959,7 @@ declare module "rpeChartCompiler" {
     import type { Chart } from "chart";
     import { type TimeT, type ChartDataRPE, type JudgeLineDataRPE, type EventDataRPELike, type NoteDataRPE, type EventValueESType } from "chartTypes";
     import { type EasedEvaluatorOfType } from "evaluator";
-    import { EventEndNode, EventNodeSequence, EventStartNode } from "event";
+    import { EventEndNode, EventNodeSequence, EventStartNode, SpeedENS } from "event";
     import type { JudgeLine } from "judgeline";
     import type { NNList, HNList } from "note";
     /**
@@ -3100,6 +2977,7 @@ declare module "rpeChartCompiler" {
             evaluator: EasedEvaluatorOfType<VT>;
         }, getValue: (node: EventStartNode<VT> | EventEndNode<VT>) => VT): EventDataRPELike<VT>;
         dumpEventNodeSequence<VT extends EventValueESType>(sequence: EventNodeSequence<VT>): EventDataRPELike<VT>[];
+        dumpSpeedENS(seq: SpeedENS): EventDataRPELike<number>[];
         compileNNLists(nnLists: NNList[], hnLists: HNList[]): NoteDataRPE[];
         /**
          * 倒序转换为数组

package/index.js

@@ -24,6 +24,61 @@ var checkType = (value, type) => {
   if (Array.isArray(type)) {
     return Array.isArray(value) && value.length === type.length && type.every((t, i) => checkType(value[i], t));
   } else if (typeof type === "string") {
+    if (type.startsWith("int")) {
+      if (typeof value !== "number" || !Number.isInteger(value)) {
+        return false;
+      }
+      const match = type.match(/^int(\(|\[)(\-?\d+),(\-?\d+|\+)(\)|\])$/);
+      if (!match) {
+        return true;
+      }
+      const [, leftBrac, left, right, rightBrac] = match;
+      if (!leftBrac) {
+        return true;
+      }
+      const leftN = left === "-" ? -Infinity : Number(left);
+      const rightN = right === "+" ? Infinity : Number(right);
+      if (value < leftN) {
+        return false;
+      }
+      if (leftBrac === "(" && value === leftN) {
+        return false;
+      }
+      if (value > rightN) {
+        return false;
+      }
+      if (rightBrac === ")" && value === rightN) {
+        return false;
+      }
+      return true;
+    } else if (type.startsWith("number")) {
+      if (typeof value !== "number") {
+        return false;
+      }
+      const match = type.match(/^number(\(|\[)(\-?\d+),(\-?\d+|\+)(\)|\])$/);
+      if (!match) {
+        return true;
+      }
+      const [, leftBrac, left, right, rightBrac] = match;
+      if (!leftBrac) {
+        return true;
+      }
+      const leftN = left === "-" ? -Infinity : Number(left);
+      const rightN = right === "+" ? Infinity : Number(right);
+      if (value < leftN) {
+        return false;
+      }
+      if (leftBrac === "(" && value === leftN) {
+        return false;
+      }
+      if (value > rightN) {
+        return false;
+      }
+      if (rightBrac === ")" && value === rightN) {
+        return false;
+      }
+      return true;
+    }
     return typeof value === type;
   } else {
     return value instanceof type;
@@ -195,6 +250,16 @@ class TC2 {
   static lt(beaT1, beaT2) {
     return beaT1[0] < beaT2[0] || beaT1[0] === beaT2[0] && beaT1[1] * beaT2[2] < beaT1[2] * beaT2[1];
   }
+  static cmp(beaT1, beaT2) {
+    if (beaT1[0] > beaT2[0]) {
+      return 1;
+    } else if (beaT1[0] < beaT2[0]) {
+      return -1;
+    } else {
+      return beaT1[1] * beaT2[2] > beaT1[2] * beaT2[1] ? 1 : -1;
+    }
+    return 0;
+  }
   static ne(beaT1, beaT2) {
     return beaT1[0] !== beaT2[0] || beaT1[1] * beaT2[2] !== beaT1[2] * beaT2[1];
   }
@@ -1645,7 +1710,7 @@ class EventStartNode extends EventNode {
     return super.clone(offset);
   }
   clonePair(offset) {
-    const endNode = this.previous.type !== 0 /* HEAD */ ? this.previous.clone(offset) : new EventEndNode(this.time, this.value);
+    const endNode = this.previous.type !== 0 /* HEAD */ ? this.previous.clone(offset) : null;
     const startNode = this.clone(offset);
     EventNode.connect(endNode, startNode);
     return startNode;
@@ -1701,6 +1766,7 @@ class EventNodeSequence {
   }
   static fromRPEJSON(type, data, chart, pos, endValue) {
     const { templateEasingLib: templates } = chart;
+    data.sort((a, b) => TC2.cmp(a.startTime, b.startTime));
     const length = data.length;
     const seq = new EventNodeSequence(type, type === 5 /* easing */ ? TC2.toBeats(data[length - 1].endTime) : chart.effectiveBeats);
     let listLength = length;
@@ -2280,7 +2346,12 @@ class NoteNode extends NoteNodeLike {
     }
   }
   remove(note) {
-    this.notes.splice(this.notes.indexOf(note), 1);
+    const index = this.notes.indexOf(note);
+    if (index === -1) {
+      console.warn("Note not found in this node!");
+      return;
+    }
+    this.notes.splice(index, 1);
     note.parentNode = null;
   }
   static disconnect(note1, note2) {
@@ -3319,7 +3390,7 @@ class TimeCalculator {
   }
 }
 // src/version.ts
-var VERSION = 213;
+var VERSION = 214;
 var SCHEMA = "https://cdn.jsdelivr.net/npm/kipphi@2.1.0/chartType2.schema.json";
 
 // src/chart.ts
@@ -3857,6 +3928,7 @@ __export(exports_operation, {
   EventNodePairRemoveOperation: () => EventNodePairRemoveOperation,
   EventNodePairInsertOrOverwriteOperation: () => EventNodePairInsertOrOverwriteOperation,
   EventNodePairInsertOperation: () => EventNodePairInsertOperation,
+  EventNodePairAutoInsertOperation: () => EventNodePairAutoInsertOperation,
   EventNodeMacroTimeReevaluateOperation: () => EventNodeMacroTimeReevaluateOperation,
   EventNodeEvaluatorChangeOperation: () => EventNodeEvaluatorChangeOperation,
   EventInterpolationOperation: () => EventInterpolationOperation,
@@ -4192,6 +4264,12 @@ class EventNodePairInsertOrOverwriteOperation extends UnionOperation {
   }
 }
 
+class EventNodePairAutoInsertOperation extends EventNodePairInsertOperation {
+  constructor(node, parentSeq, updatesFP = true) {
+    super(node, parentSeq.getNodeAt(TC2.toBeats(node.time)), updatesFP);
+  }
+}
+
 class EventNodeValueChangeOperation extends Operation {
   updatesEditor = true;
   node;
@@ -4404,6 +4482,9 @@ class EncapsuleOperation extends ComplexOperation {
     const sequence = easing.eventNodeSequence;
     sequence.effectiveBeats = TC2.toBeats(nodeArray[nodeArray.length - 1].time);
     new MultiNodeAddOperation(nodeArray, sequence).do();
+    const first = sequence.head.next;
+    first.evaluator = nodeArray[0].evaluator;
+    first.value = nodeArray[0].value;
     return new EncapsuleOperation(oldArray, easing);
   }
 }
@@ -5343,8 +5424,20 @@ class RPEChartCompiler {
   compileChart() {
     const chart2 = this.chart;
     const judgeLineGroups = chart2.judgeLineGroups.map((group) => group.name);
+    const hasNotes = (nnList) => {
+      let node = nnList.head.next;
+      while (true) {
+        if (node.type === 1 /* TAIL */) {
+          return false;
+        }
+        if (node.notes.length > 0) {
+          return true;
+        }
+        node = node.next;
+      }
+    };
     const filter = this.deletesEmptyLines ? (line2) => {
-      return line2.nnLists.size > 0 || line2.hnLists.size > 0 || line2.eventLayers.length > 0 || ["moveX", "moveY", "rotate", "alpha"].some((evType) => {
+      return [...line2.nnLists].some(([_, l]) => hasNotes(l)) || [...line2.hnLists].some(([_, l]) => hasNotes(l)) || line2.eventLayers.length > 0 && ["moveX", "moveY", "rotate", "alpha"].some((evType) => {
         const seq = line2.eventLayers[0][evType];
         let node = seq.head.next;
         for (let i = 0;i < 2; i++) {
@@ -5427,7 +5520,7 @@ class RPEChartCompiler {
         moveYEvents: layer.moveY ? this.dumpEventNodeSequence(layer.moveY) : undefined,
         rotateEvents: layer.rotate ? this.dumpEventNodeSequence(layer.rotate) : undefined,
         alphaEvents: layer.alpha ? this.dumpEventNodeSequence(layer.alpha) : undefined,
-        speedEvents: index === 0 ? this.dumpEventNodeSequence(judgeLine.speedSequence) : undefined
+        speedEvents: index === 0 ? this.dumpSpeedENS(judgeLine.speedSequence) : undefined
       })),
       extended: {
         scaleXEvents: judgeLine.extendedLayer.scaleX ? this.dumpEventNodeSequence(judgeLine.extendedLayer.scaleX) : undefined,
@@ -5525,6 +5618,32 @@ class RPEChartCompiler {
     nodes.push(this.compileEasedEvent(newStart, getValue));
     return nodes;
   }
+  dumpSpeedENS(seq) {
+    const ret = [];
+    let node = seq.head.next;
+    while (true) {
+      const end = node.next;
+      if (end.type === 1 /* TAIL */) {
+        break;
+      }
+      ret.push({
+        start: node.value,
+        end: end.value,
+        startTime: node.time,
+        endTime: end.time,
+        linkgroup: 0
+      });
+      node = end.next;
+    }
+    ret.push({
+      start: node.value,
+      end: node.value,
+      startTime: node.time,
+      endTime: TC2.vadd(node.time, [1, 0, 1]),
+      linkgroup: 0
+    });
+    return ret;
+  }
   compileNNLists(nnLists, hnLists) {
     const noteLists = nnLists.map((list) => this.nnListToArray(list));
     const holdLists = hnLists.map((list) => this.nnListToArray(list));
@@ -5608,8 +5727,8 @@ class RPEChartCompiler {
           srcStart = srcSeq.head.next.value;
           srcEnd = srcSeq.tail.previous.value;
           leftDividedNodeSrc = srcSeq.head.next;
-          rightDividedNodeSrc = srcSeq.tail.previous;
-          toStopAt = rightDividedNodeSrc;
+          rightDividedNodeSrc = srcSeq.tail.previous.previous.previous;
+          toStopAt = srcSeq.tail.previous;
           srcStartTime = srcSeq.head.next.time;
           srcTimeDelta = TC2.sub(srcSeq.tail.previous.time, srcStartTime);
         }
@@ -5656,13 +5775,13 @@ class RPEChartCompiler {
           if (rightDividedNodeSrc.evaluator instanceof ExpressionEvaluator) {
             throw err.CANNOT_DIVIDE_EXPRESSION_EVALUATOR(seq.id);
           } else {
-            first.evaluator = evaluator.deriveWithEasing(new SegmentedEasing(rightDividedNodeSrc.evaluator.easing, 0, newRight));
+            prev.evaluator = evaluator.deriveWithEasing(new SegmentedEasing(rightDividedNodeSrc.evaluator.easing, 0, newRight));
           }
         } else {
           if (rightDividedNodeSrc.evaluator instanceof ExpressionEvaluator) {
             throw err.CANNOT_DIVIDE_EXPRESSION_EVALUATOR(seq.id);
           } else {
-            first.evaluator = evaluator.deriveWithEasing(rightDividedNodeSrc.evaluator.easing);
+            prev.evaluator = evaluator.deriveWithEasing(rightDividedNodeSrc.evaluator.easing);
           }
         }
         const endNode2 = currentNode.next.clone();

package/judgeline.ts

@@ -405,133 +405,6 @@ export class JudgeLine {
     getRelativeFloorPositionAt(beats: number, timeCalculator: TimeCalculator) {
         return this.speedSequence.getFloorPositionAt(beats, timeCalculator) - this.currentFloorPosition;
     }
-    /**
-     * 通过速度序列的FloorPosition反解出一个时间范围。
-     * 
-     * KPA内核代码中最大的一坨史山，没有之一。
-     * 
-     * 谱面渲染时最耗时的函数
-     * 
-     * startY and endY must not be negative
-     * @param beats 
-     * @param timeCalculator 
-     * @param startY 
-     * @param endY 
-     * @returns 
-     * /
-    computeTimeRange(beats: number, timeCalculator: TimeCalculator , startY: number, endY: number): [number, number][] {
-        //return [[0, Infinity]]
-        //*
-        // 提取所有有变化的时间点
-        let times: number[] = [];
-        const result: [number, number][] = [];
-        for (const eventLayer of this.eventLayers) {
-            const sequence = eventLayer?.speed;
-            if (!sequence) {
-                continue;
-            }
-            let node: EventStartNode = sequence.getNodeAt(beats);
-            let endNode: EventEndNode | EventNodeLike<NodeType.TAIL>
-            while (true) {
-                times.push(TC.toBeats(node.time))
-                if ((endNode = node.next).type === NodeType.TAIL) {
-                    break;
-                }
-
-                node = endNode.next
-            }
-        }
-        times = [...new Set(times)].sort((a, b) => a - b)
-        const len = times.length;
-        let nextTime = times[0]
-        let nextPosY = this.getStackedFloorPosition(nextTime, timeCalculator)
-        let nextSpeed = this.getStackedValue("speed", nextTime, true)
-        let range: [number, number] = [undefined, undefined];
-        // console.log(times)
-        const computeTime = (speed: number, currentPos: number, fore: number) => timeCalculator.secondsToBeats(currentPos / (speed * 120) + timeCalculator.toSeconds(fore));
-        for (let i = 0; i < len - 1;) {
-            const thisTime = nextTime;
-            const thisPosY = nextPosY;
-            let thisSpeed = this.getStackedValue("speed", thisTime);
-            if (Math.abs(thisSpeed) < 1e-8) {
-                thisSpeed = 0; // 不这样做可能导致下面异号判断为真从而死循环
-            }
-            nextTime = times[i + 1]
-            nextPosY = this.getStackedFloorPosition(nextTime, timeCalculator);
-            nextSpeed = this.getStackedValue("speed", nextTime, true)
-            // console.log(thisSpeed, nextSpeed, thisSpeed * nextSpeed < 0, i, [...result])
-            if (thisSpeed * nextSpeed < 0) { // 有变号零点，再次切断，保证处理的每个区间单调性
-                //debugger;
-                nextTime = (nextTime - thisTime) * (0 - thisSpeed) / (nextSpeed - thisSpeed) + thisTime;
-                nextSpeed = 0
-                nextPosY = this.getStackedFloorPosition(nextTime, timeCalculator)
-                //debugger
-            } else {
-                // console.log("i++")
-                i++
-            }
-            if (range[0] === undefined) {
-                // 变速区间直接全部囊括，匀速要算一下，因为好算
-                /*
-                设两个时间点的位置为a,b
-                开始结束点为s,e
-                选中小段一部分在区间内：
-                a < s <= b
-                或a > e >= b
-                全部在区间内
-                s <= a <= b
-                * /
-                if (thisPosY < startY && startY <= nextPosY
-                || thisPosY > endY && endY >= nextPosY) {
-                    range[0] = thisSpeed !== nextSpeed ? thisTime : computeTime(
-                        thisSpeed,
-                        (thisPosY < nextPosY ? startY : endY) - thisPosY, thisTime)
-                } else if (startY <= thisPosY && thisPosY <= endY) {
-                    range[0] = thisTime;
-                }
-            }
-            // 要注意这里不能合成双分支if因为想要的Y片段可能在一个区间内
-            if (range[0] !== undefined) {
-                if (thisPosY < endY && endY <= nextPosY || thisPosY > startY && startY >= nextPosY) {
-                    range[1] = thisSpeed !== nextSpeed ? nextTime : computeTime(
-                        thisSpeed,
-                        (thisPosY > nextPosY ? startY : endY) - thisPosY, thisTime)
-                    result.push(range)
-                    range = [undefined, undefined];
-                }
-            }
-        }
-        const thisPosY = nextPosY;
-        const thisTime = nextTime;
-        const thisSpeed = this.getStackedValue("speed", thisTime);
-        const inf = thisSpeed > 0 ? Infinity : (thisSpeed < 0 ? -Infinity : thisPosY)
-        if (range[0] === undefined) {
-            // 变速区间直接全部囊括，匀速要算一下，因为好算
-            if (thisPosY < startY && startY <= inf || thisPosY >= endY && endY > inf) {
-                range[0] = computeTime(
-                    thisSpeed,
-                    (thisPosY < inf ? startY : endY) - thisPosY,
-                    thisTime)
-            } else if (thisSpeed === 0) {
-                range[0] = 0;
-            }
-        }
-        // 要注意这里不能合成双分支if因为想要的Y片段可能在一个区间内
-        if (range[0] !== undefined) {
-            if (thisPosY < endY && endY <= inf || thisPosY >= startY && startY > inf) {
-                range[1] = computeTime(
-                    thisSpeed,
-                    (thisPosY > inf ? startY : endY) - thisPosY,
-                    thisTime)
-                result.push(range)
-            } else if (thisSpeed === 0) {
-                range[1] = Infinity;
-                result.push(range)
-            }
-        }
-        return result;
-        //* /
-    }*/
    /**
      * 通过速度序列的FloorPosition反解出一个时间范围。
      * 

package/note.ts

@@ -307,7 +307,12 @@ export class NoteNode extends NoteNodeLike<NodeType.MIDDLE> {
         }
     }
     remove(note: Note) {
-        this.notes.splice(this.notes.indexOf(note), 1)
+        const index = this.notes.indexOf(note);
+        if (index === -1) {
+            console.warn("Note not found in this node!")
+            return;
+        }
+        this.notes.splice(index, 1)
         note.parentNode = null
     }
     static disconnect(note1: NNOrHead, note2: NNOrTail) {

package/operation/event.ts

@@ -117,7 +117,11 @@ extends UnionOperation<LazyOperation<typeof EventNodePairInsertOperation<VT>> |
     }
 }
 
-
+export class EventNodePairAutoInsertOperation<VT extends EventValueESType> extends EventNodePairInsertOperation<VT> {
+    constructor(node: EventStartNode<VT>, parentSeq: EventNodeSequence<VT>, updatesFP = true) {
+        super(node, parentSeq.getNodeAt(TC.toBeats(node.time)), updatesFP);
+    }
+}
 
 export class EventNodeValueChangeOperation <VT extends EventValueESType> extends Operation {
     updatesEditor = true
@@ -362,6 +366,10 @@ export class EncapsuleOperation extends ComplexOperation<[MultiNodeDeleteOperati
         // 直接do，这个不需要做成可撤销的
         // @ts-expect-error 这里序列类型确定，为easing，不需要传入谱面
         new MultiNodeAddOperation(nodeArray, sequence).do();
+        // 上面这个操作不能顶替原来的第一个startnode，所以手动来一遍
+        const first = sequence.head.next;
+        first.evaluator = nodeArray[0].evaluator;
+        first.value = nodeArray[0].value;
 
         return new EncapsuleOperation(oldArray, easing); 
     }

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "kipphi",
     "description": "Parse your Phigros Chart(.rpe.json or .kpa.json) into an editor-friendly format.",
-    "version": "2.1.3-beta.2",
+    "version": "2.1.4-beta.1",
     "author": "Team Zincs (https://github.com/TeamZincs)",
     "license": "MIT",
     "repository": {

package/rpeChartCompiler.ts

@@ -4,7 +4,7 @@ import { type TimeT, type ChartDataRPE, type MetaData, type JudgeLineDataRPE, ty
 import { SegmentedEasing, BezierEasing, NormalEasing, fixedEasing, TemplateEasing, Easing } from "./easing";
 import { err } from "./env";
 import { EasedEvaluator, Evaluator, ExpressionEvaluator, NumericEasedEvaluator, TextEasedEvaluator, type EasedEvaluatorConstructorOfType, type EasedEvaluatorOfType } from "./evaluator";
-import { EventEndNode, EventNode, EventNodeSequence, EventStartNode, type EventNodeLike } from "./event";
+import { EventEndNode, EventNode, EventNodeSequence, EventStartNode, SpeedENS, type EventNodeLike } from "./event";
 import type { JudgeLine } from "./judgeline";
 import type { NNList, HNList, NNOrHead } from "./note";
 import TC from "./time";
@@ -31,11 +31,23 @@ export class RPEChartCompiler {
         // console.time("compileChart")
         const chart = this.chart;
         const judgeLineGroups = chart.judgeLineGroups.map(group => group.name);
+        const hasNotes = (nnList: NNList) => {
+            let node = nnList.head.next;
+            while (true) {
+                if (node.type === NodeType.TAIL) {
+                    return false;
+                }
+                if (node.notes.length > 0) {
+                    return true;
+                }
+                node = node.next;
+            }
+        }
         const filter = this.deletesEmptyLines ? (line: JudgeLine) => {
-            return line.nnLists.size > 0
-                || line.hnLists.size > 0
+            return [...line.nnLists].some(([_, l]) => hasNotes(l))
+                || [...line.hnLists].some(([_, l]) => hasNotes(l))
                 || line.eventLayers.length > 0
-                || (["moveX", "moveY", "rotate", "alpha"] as const).some((evType) => {
+                  && (["moveX", "moveY", "rotate", "alpha"] as const).some((evType) => {
                     const seq = line.eventLayers[0][evType];
                     let node = seq.head.next;
                     for (let i = 0; i < 2; i++) {
@@ -128,7 +140,7 @@ export class RPEChartCompiler {
                 moveYEvents: layer.moveY ? this.dumpEventNodeSequence(layer.moveY) : undefined,
                 rotateEvents: layer.rotate ? this.dumpEventNodeSequence(layer.rotate) : undefined,
                 alphaEvents: layer.alpha ? this.dumpEventNodeSequence(layer.alpha) : undefined,
-                speedEvents: index === 0 ? this.dumpEventNodeSequence(judgeLine.speedSequence) : undefined
+                speedEvents: index === 0 ? this.dumpSpeedENS(judgeLine.speedSequence) : undefined
             })),
             extended: {
                 scaleXEvents: judgeLine.extendedLayer.scaleX ? this.dumpEventNodeSequence(judgeLine.extendedLayer.scaleX) : undefined,
@@ -249,6 +261,32 @@ export class RPEChartCompiler {
 
         return nodes
     }
+    dumpSpeedENS(seq: SpeedENS): EventDataRPELike<number>[] {
+        const ret: EventDataRPELike<number>[] = [];
+        let node = seq.head.next;
+        while (true) {
+            const end = node.next;
+            if (end.type === NodeType.TAIL) {
+                break;
+            }
+            ret.push({
+                start: node.value,
+                end: end.value,
+                startTime: node.time,
+                endTime: end.time,
+                linkgroup: 0
+            } as EventDataRPELike<number>);
+            node = end.next;
+        }
+        ret.push({
+            start: node.value,
+            end: node.value,
+            startTime: node.time,
+            endTime: TC.vadd(node.time, [1, 0, 1]),
+            linkgroup: 0
+        } as EventDataRPELike<number>);
+        return ret;
+    }
 
     compileNNLists(nnLists: NNList[], hnLists: HNList[]): NoteDataRPE[] {
         const noteLists = nnLists.map(list => this.nnListToArray(list));
@@ -367,8 +405,8 @@ export class RPEChartCompiler {
                     srcStart = srcSeq.head.next!.value;
                     srcEnd = srcSeq.tail.previous!.value;
                     leftDividedNodeSrc = srcSeq.head.next!;
-                    rightDividedNodeSrc = srcSeq.tail.previous!;
-                    toStopAt = rightDividedNodeSrc;
+                    rightDividedNodeSrc = srcSeq.tail.previous!.previous.previous!;
+                    toStopAt = srcSeq.tail.previous!;
                     srcStartTime = srcSeq.head.next!.time;
                     srcTimeDelta = TC.sub(srcSeq.tail.previous!.time, srcStartTime);
                 }
@@ -450,7 +488,7 @@ export class RPEChartCompiler {
                         throw err.CANNOT_DIVIDE_EXPRESSION_EVALUATOR(seq.id);
                     } else {
                         // 否则就是带缓动求值器
-                        first.evaluator = evaluator.deriveWithEasing(
+                        prev.evaluator = evaluator.deriveWithEasing(
                             new SegmentedEasing((rightDividedNodeSrc.evaluator as NumericEasedEvaluator).easing, 0.0, newRight)
                         ) as unknown as Evaluator<VT>;
                         // TypeScript Compiler我*你娘啊
@@ -460,7 +498,7 @@ export class RPEChartCompiler {
                     if (rightDividedNodeSrc.evaluator instanceof ExpressionEvaluator) {
                         throw err.CANNOT_DIVIDE_EXPRESSION_EVALUATOR(seq.id);
                     } else {
-                        first.evaluator = evaluator.deriveWithEasing(
+                        prev.evaluator = evaluator.deriveWithEasing(
                             (rightDividedNodeSrc.evaluator as NumericEasedEvaluator).easing
                         ) as unknown as Evaluator<VT>;
                     }

package/time.ts

@@ -25,6 +25,16 @@ export default class TC {
     static lt(beaT1:TimeT, beaT2: TimeT): boolean {
         return beaT1[0] < beaT2[0] || beaT1[0] === beaT2[0] && beaT1[1] * beaT2[2] < beaT1[2] * beaT2[1]
     }
+    static cmp(beaT1: TimeT, beaT2: TimeT): number {
+        if (beaT1[0] > beaT2[0]) {
+            return 1;
+        } else if (beaT1[0] < beaT2[0]) {
+            return -1;
+        } else {
+            return beaT1[1] * beaT2[2] > beaT1[2] * beaT2[1] ? 1 : -1;
+        }
+        return 0;
+    }
     /** @returns beaT1 != beaT2 */
     static ne(beaT1:TimeT, beaT2: TimeT): boolean {
         return beaT1[0] !== beaT2[0] || beaT1[1] * beaT2[2] !== beaT1[2] * beaT2[1]

package/util.ts

@@ -20,6 +20,56 @@ export const checkType = (value: unknown, type: string | (string | typeof Functi
         && value.length === type.length
         && type.every((t, i) => checkType(value[i], t))
     } else if (typeof type === "string") {
+        if (type.startsWith("int")) {
+            if (typeof value !== "number" || !Number.isInteger(value)) {
+                return false;
+            }
+            const match = type.match(/^int(\(|\[)(\-?\d+),(\-?\d+|\+)(\)|\])$/);
+            if (!match) { return true; }
+            const [,leftBrac, left, right, rightBrac] = match
+            if (!leftBrac) { return true; }
+            const leftN = left === "-" ? -Infinity : Number(left);
+            const rightN = right === "+" ? +Infinity : Number(right);
+            if (value < leftN) {
+                return false;
+            }
+            if (leftBrac === "(" && value === leftN) {
+                return false;
+            }
+            
+            if (value > rightN) {
+                return false;
+            }
+            if (rightBrac === ")" && value === rightN) {
+                return false;
+            }
+            return true;
+        } else if (type.startsWith("number")) {
+            
+            if (typeof value !== "number") {
+                return false;
+            }
+            const match  = type.match(/^number(\(|\[)(\-?\d+),(\-?\d+|\+)(\)|\])$/)
+            if (!match) { return true; }
+            const [, leftBrac, left, right, rightBrac] = match
+            if (!leftBrac) { return true; }
+            const leftN = left === "-" ? -Infinity : Number(left);
+            const rightN = right === "+" ? +Infinity : Number(right);
+            if (value < leftN) {
+                return false;
+            }
+            if (leftBrac === "(" && value === leftN) {
+                return false;
+            }
+            
+            if (value > rightN) {
+                return false;
+            }
+            if (rightBrac === ")" && value === rightN) {
+                return false;
+            }
+            return true;
+        }
         return typeof value === type
     } else {
         return value instanceof type

package/version.ts

@@ -2,7 +2,7 @@
 
 /// #declaration:global
 
-export const VERSION = 213;
+export const VERSION = 214;
 export const SCHEMA = "https://cdn.jsdelivr.net/npm/kipphi@2.1.0/chartType2.schema.json"