kipphi 2.0.1 → 2.1.0

package/event.ts

@@ -1,5 +1,5 @@
 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, EventValueTypeOfType } 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";
@@ -10,9 +10,10 @@ 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;
@@ -23,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>;
 
 /**
  * 事件节点基类
@@ -43,10 +44,12 @@ 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 = TC.validateIp([...time]);
@@ -106,12 +109,11 @@ export abstract class EventNode<VT = number> extends EventNodeLike<NodeType.MIDD
         const right = data.easingRight;
         const wrap = (easing: Easing): EasedEvaluator<VT> => {
             if (typeof data.start === "number") {
-                return new NumericEasedEvaluator(easing) as EasedEvaluator<VT>;
+                return new NumericEasedEvaluator(easing) as unknown as EasedEvaluator<VT>;
             } else if (typeof data.start === "string") {
-                // @ts-expect-error
-                return new TextEasedEvaluator(easing, interpreteAs);
+                return new TextEasedEvaluator(easing, interpreteAs) as unknown as EasedEvaluator<VT>;
             } else {
-                return new ColorEasedEvaluator(easing) as EasedEvaluator<VT>;
+                return new ColorEasedEvaluator(easing) as unknown as EasedEvaluator<VT>;
             }
         };
         if ((left && right) && (left !== 0.0 || right !== 1.0)) {
@@ -173,9 +175,9 @@ export abstract class EventNode<VT = number> extends EventNodeLike<NodeType.MIDD
         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) {
@@ -188,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;
@@ -199,7 +201,7 @@ 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 err.CANNOT_INSERT_BEFORE_HEAD();
@@ -214,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
     }
     /**
@@ -222,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;
     }
     /**
@@ -233,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 {
@@ -248,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");
@@ -258,7 +260,7 @@ 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) {
@@ -267,7 +269,7 @@ export abstract class EventNode<VT = number> extends EventNodeLike<NodeType.MIDD
             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) => TC.gt(a.time, b.time) ? 1 : -1);
         const offset = TC.sub(dest, nodes[0].time)
@@ -302,9 +304,10 @@ export abstract class EventNode<VT = number> extends EventNodeLike<NodeType.MIDD
     // #endregion
 }
 
-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时刻到此节点的总积分
      */
@@ -325,16 +328,32 @@ 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))
         }
     }
+    dumpAsFinal(): FinalEventStartNodeDataKPA2<VT> {
+        return {
+            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)),
+        }
+    } 
     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);
     }
     getSpeedValueAt(this: EventStartNode<number>, beats: number) {
         if (this.next.type === NodeType.TAIL) {
@@ -384,7 +403,7 @@ export class EventStartNode<VT = number> extends EventNode<VT> {
 
 export type NonLastStartNode<VT extends EventValueESType> = EventStartNode<VT> & {next: EventEndNode<VT>}
 
-export class EventEndNode<VT = number> extends EventNode<VT> {
+export class EventEndNode<VT extends EventValueESType = number> extends EventNode<VT> {
     override next!: EventStartNode<VT>;
     override previous!: EventStartNode<VT>;
 
@@ -435,7 +454,7 @@ export enum Monotonicity {
  * 插入或删除节点时，需要更新跳数组。
  * Remember to update the jump array when inserting or deleting nodes.
  */
-export class EventNodeSequence<VT = number> { // 泛型的传染性这一块
+export class EventNodeSequence<VT extends EventValueESType = number> { // 泛型的传染性这一块
     /**
      * @deprecated 谱面属性未实装，以后有必要的时候会添加为其赋值的逻辑
      */
@@ -489,7 +508,18 @@ 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, pos: string, 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;
@@ -507,6 +537,7 @@ export class EventNodeSequence<VT = number> { // 泛型的传染性这一块
             lastEnd = end;
         }
 
+        // 当前仅用于检查时间递增
         let lastEndTime: TimeT = [0, 0, 1];
 
         // 读取事件列表
@@ -551,7 +582,7 @@ export class EventNodeSequence<VT = number> { // 泛型的传染性这一块
         const last = lastEnd;
         const tail = new EventStartNode(
             last.type === NodeType.HEAD ? [0, 0, 1] : last.time,
-            endValue ?? last.value
+            endValue ?? (last as EventEndNode<VT>).value
         );
         EventNode.connect(last, tail);
         // last can be a header, in which case easing is undefined.
@@ -565,12 +596,21 @@ export class EventNodeSequence<VT = number> { // 泛型的传染性这一块
         }
         return seq;
     }
+    /**
+     * 从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,
-        endValue?: VT
+        finalNodeData: FinalEventStartNodeDataKPA2<VT>
     )
     {
         const length = data.length;
@@ -602,7 +642,7 @@ export class EventNodeSequence<VT = number> { // 泛型的传染性这一块
         let lastEndTime: TimeT = [0, 0, 1];
         for (let index = 0; index < length; index++) {
             const event = data[index];
-            const [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
@@ -638,15 +678,25 @@ 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;
-        EventNode.connect(tail, seq.tail)
+        EventNode.connect(last, final);
+        EventNode.connect(final, seq.tail)
         seq.listLength = listLength;
         seq.initJump();
         if (type === EventType.speed) {
@@ -711,7 +761,7 @@ export class EventNodeSequence<VT = number> { // 泛型的传染性这一块
             (node: EventStartNode<VT>, beats: number) => {
                 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) => {
@@ -767,6 +817,10 @@ export class EventNodeSequence<VT = number> { // 泛型的传染性这一块
      * @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;
@@ -802,7 +856,7 @@ export class EventNodeSequence<VT = number> { // 泛型的传染性这一块
             type: this.type,
             events: nodes,
             id: this.id,
-            endValue: currentNode.value
+            final: currentNode.dumpAsFinal()
         };
     }