kipphi 2.0.0 → 2.1.0

package/note.ts

@@ -5,30 +5,17 @@ import type { Chart } from "./chart";
 import { NoteType, type NNListDataKPA, type NoteDataKPA, type NoteDataRPE, type NoteNodeDataKPA, type TimeT } from "./chartTypes";
 import type { JudgeLine } from "./judgeline";
 import { JumpArray } from "./jumparray";
-import { TimeCalculator } from "./time";
+import { type TimeCalculator } from "./bpm";
+import TC from "./time";
 import { hex2rgb, NodeType, rgb2hex } from "./util";
 
 /// #declaration:global
 
-const TC = TimeCalculator;
 
 export type HEX = number;
 
 
 
-const node2string = (node: AnyNN) => {
-    if (!node) {
-        return "" + node
-    }
-    if (node.type === NodeType.HEAD || node.type === NodeType.TAIL) {
-        return node.type === NodeType.HEAD ? "H" : node.type === NodeType.TAIL ? "T" : "???"
-    }
-    if (!node.notes) {
-        return "EventNode"
-    }
-    return `NN(${node.notes.length}) at ${node.startTime}`
-}
-
 
 
 export const notePropTypes = {
@@ -98,18 +85,18 @@ export class Note {
     // posNext?: Note;
     // posPreviousSibling?: Note;
     // posNextSibling: Note;
-    constructor(data: NoteDataRPE) {
+    constructor(data: NoteDataRPE | NoteDataKPA) {
         this.above = data.above === 1;
         this.alpha = data.alpha ?? 255;
-        this.endTime = data.type === NoteType.hold ? TimeCalculator.validateIp(data.endTime) : TimeCalculator.validateIp([...data.startTime]);
+        this.endTime = data.type === NoteType.hold ? TC.validateIp(data.endTime) : TC.validateIp([...data.startTime]);
         this.isFake = Boolean(data.isFake);
         this.positionX = data.positionX;
         this.size = data.size ?? 1.0;
         this.speed = data.speed ?? 1.0;
-        this.startTime = TimeCalculator.validateIp(data.startTime);
+        this.startTime = TC.validateIp(data.startTime);
         this.type = data.type;
         this.visibleTime = data.visibleTime;
-        // @ts-expect-error
+        // @ts-expect-error 若data是RPE数据，则为undefined，无影响。
         this.yOffset = data.absoluteYOffset ?? data.yOffset * this.speed;
         // @ts-expect-error 若data是RPE数据，则为undefined，无影响。
         // 当然也有可能是KPA数据但是就是没有给
@@ -137,7 +124,7 @@ export class Note {
             this.visibleBeats = Infinity;
             return;
         }
-        const hitBeats = TimeCalculator.toBeats(this.startTime);
+        const hitBeats = TC.toBeats(this.startTime);
         const hitSeconds = timeCalculator.toSeconds(hitBeats);
         const visabilityChangeSeconds = hitSeconds - this.visibleTime;
         const visabilityChangeBeats = timeCalculator.secondsToBeats(visabilityChangeSeconds);
@@ -150,8 +137,8 @@ export class Note {
      */
     clone(offset: TimeT) {
         const data = this.dumpKPA();
-        data.startTime = TimeCalculator.add(data.startTime, offset);
-        data.endTime = TimeCalculator.add(data.endTime, offset); // 踩坑
+        data.startTime = TC.add(data.startTime, offset);
+        data.endTime = TC.add(data.endTime, offset); // 踩坑
         return new Note(data);
     }
     /*
@@ -167,7 +154,7 @@ export class Note {
     dumpRPE(timeCalculator: TimeCalculator): NoteDataRPE {
         let visibleTime: number;
         if (this.visibleBeats !== Infinity) {
-            const beats = TimeCalculator.toBeats(this.startTime);
+            const beats = TC.toBeats(this.startTime);
             this.visibleBeats = timeCalculator.segmentToSeconds(beats - this.visibleBeats, beats);
         } else {
             visibleTime = 99999.0
@@ -198,7 +185,7 @@ export class Note {
             size: this.size,
             startTime: this.startTime,
             type: this.type,
-            visibleBeats: this.visibleBeats,
+            visibleBeats: this.visibleBeats === Infinity ? undefined : this.visibleBeats, // 无穷不要保存，节约空间
             yOffset: this.yOffset / this.speed,
             /** 新KPAJSON认为YOffset就应该是个绝对的值，不受速度影响 */
             /** 但是有历史包袱，所以加字段 */
@@ -211,7 +198,6 @@ export class Note {
     }
 }
 
-type Connectee = NoteNode | NNNode
 
 
 
@@ -254,13 +240,13 @@ export class NoteNode extends NoteNodeLike<NodeType.MIDDLE> {
     id: number;
     constructor(time: TimeT) {
         super(NodeType.MIDDLE);
-        this.startTime = TimeCalculator.validateIp([...time]);
+        this.startTime = TC.validateIp([...time]);
         this.notes = [];
         this.id = NoteNode.count++;
     }
     static fromKPAJSON(data: NoteNodeDataKPA, timeCalculator: TimeCalculator) {
         const node = new NoteNode(data.startTime);
-        for (let noteData of data.notes) {
+        for (const noteData of data.notes) {
             const note = Note.fromKPAJSON(noteData, timeCalculator);
             node.add(note);
         }
@@ -276,7 +262,7 @@ export class NoteNode extends NoteNodeLike<NodeType.MIDDLE> {
         return (this.notes.length === 0 || this.notes[0].type !== NoteType.hold) ? this.startTime : this.notes[0].endTime
     }
     add(note: Note) {
-        if (!TimeCalculator.eq(note.startTime, this.startTime)) {
+        if (!TC.eq(note.startTime, this.startTime)) {
             console.warn("Wrong addition!")
         }
         this.notes.push(note);
@@ -303,7 +289,7 @@ export class NoteNode extends NoteNodeLike<NodeType.MIDDLE> {
         const note = notes[index];
         for (let i = index; i > 0; i--) {
             const prev = notes[i - 1];
-            if (TimeCalculator.lt(prev.endTime, note.endTime)) {
+            if (TC.lt(prev.endTime, note.endTime)) {
                 // swap
                 notes[i] = prev;
                 notes[i - 1] = note;
@@ -313,7 +299,7 @@ export class NoteNode extends NoteNodeLike<NodeType.MIDDLE> {
         }
         for (let i = index; i < notes.length - 1; i++) {
             const next = notes[i + 1];
-            if (TimeCalculator.gt(next.endTime, note.endTime)) {
+            if (TC.gt(next.endTime, note.endTime)) {
                 // swap
                 notes[i] = next;
                 notes[i + 1] = note;
@@ -410,7 +396,7 @@ export class NNList {
             if (prev.type === NodeType.HEAD) {
                 return;
             }
-            this.effectiveBeats = TimeCalculator.toBeats(prev.endTime)
+            this.effectiveBeats = TC.toBeats(prev.endTime)
         }
         const effectiveBeats: number = this.effectiveBeats;
         this.jump = new JumpArray<AnyNN>(
@@ -423,12 +409,11 @@ export class NNList {
                     return [null, null]
                 }
                 const nextNode = node.next;
-                const startTime = (node.type === NodeType.HEAD) ? 0 : TimeCalculator.toBeats(node.startTime)
+                const startTime = (node.type === NodeType.HEAD) ? 0 : TC.toBeats(node.startTime)
                 return [startTime, nextNode]
             },
-            // @ts-ignore
             (note: NoteNode, beats: number) => {
-                return TimeCalculator.toBeats(note.startTime) >= beats ? false : <NoteNode>note.next; // getNodeAt有guard
+                return TC.toBeats(note.startTime) >= beats ? false : <NoteNode>note.next; // getNodeAt有guard
             })
     }
     /**
@@ -447,12 +432,12 @@ export class NNList {
      * @returns 
      */
     getNodeOf(time: TimeT): NoteNode {
-        let node = this.getNodeAt(TimeCalculator.toBeats(time), false)
+        let node = this.getNodeAt(TC.toBeats(time), false)
                     .previous;
 
 
-        let isEqual = node.type !== NodeType.HEAD && TimeCalculator.eq((node as NoteNode).startTime, time)
-        if (node.next.type !== NodeType.TAIL && TimeCalculator.eq((node.next as NoteNode).startTime, time)) {
+        let isEqual = node.type !== NodeType.HEAD && TC.eq((node as NoteNode).startTime, time)
+        if (node.next.type !== NodeType.TAIL && TC.eq((node.next as NoteNode).startTime, time)) {
             isEqual = true;
             node = node.next;
         }
@@ -567,14 +552,12 @@ export class HNList extends NNList {
                 if (node.type === NodeType.TAIL) {
                     return [null, null]
                 }
-                if (!node) debugger
                 const nextNode = node.next;
-                const endTime = node.type === NodeType.HEAD ? 0 : TimeCalculator.toBeats(node.endTime)
+                const endTime = node.type === NodeType.HEAD ? 0 : TC.toBeats(node.endTime)
                 return [endTime, nextNode]
             },
-            // @ts-ignore
             (node: NoteNode, beats: number) => {
-                return TimeCalculator.toBeats(node.endTime) >= beats ? false : <NoteNode>node.next; // getNodeAt有guard
+                return TC.toBeats(node.endTime) >= beats ? false : <NoteNode>node.next; // getNodeAt有guard
             }
         )
     }
@@ -596,7 +579,7 @@ export type NNNOrHead = NNNode | NNNodeLike<NodeType.HEAD>;
 export type NNNOrTail = NNNode | NNNodeLike<NodeType.TAIL>;
 type AnyNNN = NNNode | NNNodeLike<NodeType.HEAD> | NNNodeLike<NodeType.TAIL>;
 
-class NNNodeLike<T extends NodeType> {
+export class NNNodeLike<T extends NodeType> {
     previous: NNNOrHead;
     next: NNNOrTail;
     startTime: TimeT;
@@ -618,7 +601,7 @@ export class NNNode extends NNNodeLike<NodeType.MIDDLE> {
         super(NodeType.MIDDLE);
         this.noteNodes = []
         this.holdNodes = [];
-        this.startTime = TimeCalculator.validateIp([...time])
+        this.startTime = TC.validateIp([...time])
     }
     get endTime() {
         let latest: TimeT = this.startTime;
@@ -681,7 +664,7 @@ export class NNNList {
         const originalListLength = this.timesWithNotes || 512;
         /*
         if (!this.effectiveBeats) {
-            this.effectiveBeats = TimeCalculator.toBeats(this.tail.previous.endTime)
+            this.effectiveBeats = TC.toBeats(this.tail.previous.endTime)
         }
         */
         const effectiveBeats: number = this.effectiveBeats;
@@ -695,25 +678,19 @@ export class NNNList {
                     return [null, null]
                 }
                 const nextNode = node.next;
-                const startTime = node.type === NodeType.HEAD ? 0 : TimeCalculator.toBeats((node as NNNode).startTime)
+                const startTime = node.type === NodeType.HEAD ? 0 : TC.toBeats((node as NNNode).startTime)
                 return [startTime, nextNode]
             },
-            // @ts-ignore
             (note: NNNode, beats: number) => {
-                return TimeCalculator.toBeats(note.startTime) >= beats ? false : <NNNode>note.next; // getNodeAt有guard
-            }
-            /*,
-            (note: Note) => {
-                const prev = note.previous;
-                return prev.type === NodeType.HEAD ? note : prev
-            })*/)
+                return TC.toBeats(note.startTime) >= beats ? false : <NNNode>note.next; // getNodeAt有guard
+            })
     }
     getNodeAt(beats: number, beforeEnd=false): NNNode | NNNodeLike<NodeType.TAIL> {
         return this.jump.getNodeAt(beats) as NNNode | NNNodeLike<NodeType.TAIL>;
     }
     getNode(time: TimeT): NNNode {
-        const node = this.getNodeAt(TimeCalculator.toBeats(time), false).previous;
-        if (node.type === NodeType.HEAD || TimeCalculator.ne((node as NNNode).startTime, time)) {
+        const node = this.getNodeAt(TC.toBeats(time), false).previous;
+        if (node.type === NodeType.HEAD || TC.ne((node as NNNode).startTime, time)) {
             const newNode = new NNNode(time);
             const next = node.next
             NNNode.insert(node, newNode, next);

package/operation/basic.ts

@@ -0,0 +1,285 @@
+import { Chart } from "../chart";
+
+
+
+
+export type OpEventType = "do" | "undo" | "redo" | "error" | "needsupdate" | "maxcombochanged" | "noundo" | "noredo" | "firstmodified" | "needsreflow";
+
+// 最讲类型安全的一集（
+// 当然要有，不然的话编辑器那边检测的时候逆变会出问题
+
+interface DirectlyInstaciableEventMap {
+    "noundo": OpEvent;
+    "noredo": OpEvent;
+    "firstmodified": OpEvent;
+}
+
+// 创建一个类型来检测意外的 override
+// AI太好用了你知道吗
+type CheckFinalOverrides<T> = {
+    [K in keyof T]: K extends keyof OpEventMap ? 
+        T[K] extends OpEventMap[K] ? T[K] : never : 
+        T[K]
+};
+
+interface OpEventMap extends CheckFinalOverrides<DirectlyInstaciableEventMap> {
+    "error": OperationErrorEvent;
+    "maxcombochanged": MaxComboChangeEvent;
+    "undo": OperationEvent;
+    "redo": OperationEvent;
+    "do": OperationEvent;
+    "needsupdate": OperationEvent;
+    "needsreflow": NeedsReflowEvent;
+}
+
+
+class OpEvent extends Event {
+    protected constructor(type: OpEventType) {
+        super(type);
+    }
+    /**
+     * 如果这个类型没有对应子类应该用这个
+     */
+    static create(type: keyof DirectlyInstaciableEventMap) {
+        return new OpEvent(type);
+    }
+}
+
+export class NeedsReflowEvent extends OpEvent {
+    constructor(public condition: number) {
+        super("needsreflow");
+    }
+}
+
+export class OperationEvent extends OpEvent {
+    constructor(t: "do" | "undo" | "redo" | "error" | "needsupdate", public operation: Operation) {
+        super(t);
+    }
+}
+
+export class OperationErrorEvent extends OperationEvent {
+    constructor(operation: Operation, public error: Error) {
+        super("error", operation);
+    }
+}
+
+export class MaxComboChangeEvent extends OpEvent {
+    constructor(public comboDelta: number) {
+        super("maxcombochanged");
+    }
+}
+
+
+
+export class OperationList extends EventTarget {
+    operations: Operation[];
+    undoneOperations: Operation[];
+    constructor(public readonly chart: Chart) {
+        super()
+        this.operations = [];
+        this.undoneOperations = [];
+    }
+    undo() {
+        const op = this.operations.pop()
+        if (op) {
+            if (!this.chart.modified){
+                this.chart.modified = true;
+                this.dispatchEvent(OpEvent.create("firstmodified"))
+            }
+            
+            try {
+                op.undo(this.chart);
+            } catch (e) {
+                this.dispatchEvent(new OperationErrorEvent(op, e as Error))
+                return
+            }
+            this.undoneOperations.push(op)
+            this.dispatchEvent(new OperationEvent("undo", op))
+            this.processFlags(op);
+        } else {
+            this.dispatchEvent(OpEvent.create("noundo"))
+        }
+    }
+    redo() {
+        const op = this.undoneOperations.pop()
+        if (op) {
+            if (!this.chart.modified){
+                this.chart.modified = true;
+                this.dispatchEvent(OpEvent.create("firstmodified"))
+            }
+            
+            try {
+                op.do(this.chart);
+            } catch (e) {
+                this.dispatchEvent(new OperationErrorEvent(op, e as Error))
+                return
+            }
+            this.operations.push(op)
+            this.dispatchEvent(new OperationEvent("redo", op))
+            this.processFlags(op);
+        } else {
+            this.dispatchEvent(OpEvent.create("noredo"))
+        }
+    }
+    do(operation: Operation) {
+        if (operation.ineffective) {
+            return
+        }
+        if (!this.chart.modified){
+            this.chart.modified = true;
+            this.dispatchEvent(OpEvent.create("firstmodified"))
+        }
+        // 如果上一个操作是同一个构造器的，那么试图修改上一个操作而不是立即推入新的操作
+        if (this.operations.length !== 0) {
+                
+            const lastOp = this.operations[this.operations.length - 1]
+            if (operation.constructor === lastOp.constructor) {
+                // 返回值指示是否重写成功
+                if (lastOp.rewrite(operation, this.chart)) {
+                    this.processFlags(operation)
+                    return;
+                }
+            }
+        }
+        try {
+            operation.do(this.chart);
+        } catch (e) {
+            this.dispatchEvent(new OperationErrorEvent(operation, e as Error))
+            return
+        }
+        this.dispatchEvent(new OperationEvent("do", operation));
+        this.processFlags(operation);
+        this.operations.push(operation);
+    }
+    processFlags(operation: Operation) {
+
+        if (operation.updatesEditor) {
+            this.dispatchEvent(new OperationEvent("needsupdate", operation));
+        }
+        if (operation.comboDelta) {
+            this.dispatchEvent(new MaxComboChangeEvent(operation.comboDelta));
+        }
+        if (operation.reflows) {
+            this.dispatchEvent(new NeedsReflowEvent(operation.reflows))
+        }
+    }
+    clear() {
+        this.operations = [];
+    }
+    addEventListener<T extends OpEventType>(type: T, listener: (event: OpEventMap[T]) => void, options?: boolean | AddEventListenerOptions): void {
+        super.addEventListener(type, listener, options);
+    }
+}
+
+
+export abstract class Operation {
+    ineffective: boolean;
+    updatesEditor: boolean;
+    // 用于判定线编辑区的重排，若操作完成时的布局为这个值就会重排
+    reflows: number;
+    /** 
+     * 此操作对谱面总物量产生了多少影响，正增负减。
+     * 
+     * 如果操作自身无法评估，应返回NaN，导致全谱重新数清物量
+     */
+    comboDelta: number;
+    constructor() {
+
+    }
+    abstract do(chart: Chart): void
+    abstract undo(chart: Chart): void
+    rewrite(op: this, chart: Chart): boolean {return false;}
+    toString(): string {
+        return this.constructor.name;
+    }
+    static lazy<C extends new (...args: any[]) => any = typeof this>(this: C, ...args: ConstructorParameters<C>) {
+        return new LazyOperation<C>(this, ...args)
+    }
+}
+
+
+
+
+/**
+ * 懒操作，实例化的时候不记录任何数据，do的时候才执行真正实例化
+ * 防止连续的操作中状态改变导致的错误
+ */
+export class LazyOperation<C extends new (...args: any[]) => any> extends Operation {
+    public operationClass: C;
+    public args: ConstructorParameters<C>;
+    public operation: InstanceType<C> | null = null;
+    constructor(
+        operationClass: C,
+        ...args: ConstructorParameters<C>
+    ) {
+        super();
+        this.operationClass = operationClass;
+        this.args = args;
+    }
+    do(chart: Chart) {
+        this.operation = new this.operationClass(...this.args);
+        this.operation.do(chart);
+    }
+    undo(chart: Chart) {
+        this.operation.undo(chart);
+    }
+}
+
+
+/**
+ * C语言借来的概念
+ * 
+ * 一个不确定类型的子操作
+ * 
+ * 注意这个操作不懒，会在构造时就实例化子操作
+ */
+export class UnionOperation<T extends Operation> extends Operation {
+    operation: T;
+    constructor(matcher: () => T) {
+        super();
+        this.operation = matcher();
+        if (!this.operation) {
+            this.ineffective = true;
+        }
+    }
+    // 这样子写不够严密，如果要继承这个类，并且子操作需要谱面，就要重写这个方法的签名
+    do(chart?: Chart) {
+        this.operation?.do(chart);
+    }
+    undo(chart?: Chart) {
+        this.operation?.undo(chart);
+    }
+}
+
+
+export class ComplexOperation<T extends Operation[]> extends Operation {
+    subOperations: T;
+    length: number;
+    constructor(...sub: T) {
+        super()
+        this.subOperations = sub
+        this.length = sub.length
+        this.reflows = sub.reduce((prev, op) => prev | op.reflows, 0);
+        this.updatesEditor = sub.some((op) => op.updatesEditor);
+        this.comboDelta = sub.reduce((prev, op) => prev + op.comboDelta, 0);
+    }
+    // 这样子写不够严密，如果要继承这个类，并且子操作需要谱面，就要重写这个方法的签名
+    do(chart?: Chart) {
+        const length = this.length
+        for (let i = 0; i < length; i++) {
+            const op = this.subOperations[i]
+            if (op.ineffective) {
+                continue;
+            }
+            op.do(chart)
+        }
+    }
+    undo(chart?: Chart) {
+        const length = this.length
+        for (let i = length - 1; i >= 0; i--) {
+            const op = this.subOperations[i]
+            if (op.ineffective) { continue; }
+            op.undo(chart)
+        }
+    }
+}

package/operation/chart.ts

@@ -0,0 +1,21 @@
+import { Chart } from "../chart";
+import { Operation } from "./basic";
+
+export type ChartPropName = "name" | "level" | "composer" | "illustrator" | "charter" | "offset"
+
+export class ChartPropChangeOperation<T extends ChartPropName> extends Operation {
+    originalValue: Chart[T];
+    constructor(public chart: Chart, public field: T, public value: Chart[T]) {
+        super();
+        this.originalValue = chart[field];
+        if (field === "level" || field === "name") {
+            this.updatesEditor = true;
+        }
+    }
+    do() {
+        this.chart[this.field] = this.value;
+    }
+    undo() {
+        this.chart[this.field] = this.originalValue;
+    }
+}