kipphi 2.0.1 → 2.1.0

package/index.ts

@@ -3,6 +3,7 @@ export {default as TC} from "./time";
 export * from "./chartTypes";
 export * from "./easing";
 export * from "./evaluator";
+export * from "./macro"
 export * from "./event";
 export * from "./note";
 export * from "./judgeline";
@@ -10,5 +11,7 @@ export * from "./bpm";
 export * from "./util";
 export * from "./chart";
 export * from "./jumparray";
-export * as Op from "./operation";
-export { default as Environment } from "./env";
+export * as Op from "./operation/index";
+export * from "./version";
+export { default as Environment, KPAError } from "./env";
+export { RPEChartCompiler } from "./rpeChartCompiler";

package/judgeline.ts

@@ -1,5 +1,5 @@
 import type { Chart, JudgeLineGroup } from "./chart";
-import { EventType, EventValueType, JudgeLineDataKPA2, NoteType, type EventDataRPELike, type EventLayerDataKPA, type JudgeLineDataKPA, type JudgeLineDataRPE, type NNListDataKPA, type NoteDataRPE, type RGB, type TimeT, type ValueTypeOfEventType } from "./chartTypes";
+import { EventType, EventValueESType, EventValueType, JudgeLineDataKPA2, NoteType, type EventDataRPELike, type EventLayerDataKPA, type JudgeLineDataKPA, type JudgeLineDataRPE, type NNListDataKPA, type NoteDataRPE, type RGB, type TimeT, type ValueTypeOfEventType } from "./chartTypes";
 import type { TemplateEasingLib } from "./easing";
 import { EventEndNode, EventNode, EventNodeLike, EventNodeSequence, EventStartNode, Monotonicity, SpeedENS } from "./event";
 import { HNList, NNList, Note, NoteNode, NNNList } from "./note";
@@ -50,13 +50,7 @@ export class JudgeLine {
     father: JudgeLine;
     children: Set<JudgeLine> = new Set();
 
-    moveX: number;
-    moveY: number;
-    rotate: number;
-    alpha: number;
-    transformedX: number;
-    transformedY: number;
-    optimized: boolean = false;
+
 
     zOrder: number = 0;
 
@@ -72,6 +66,9 @@ export class JudgeLine {
      */
     // renderMatrix: Matrix;
 
+    /**
+     * 是否随父线旋转
+     */
     rotatesWithFather: boolean = false;
 
     id: number;
@@ -90,7 +87,7 @@ export class JudgeLine {
         line.name = data.Name;
         chart.judgeLineGroups[data.Group].add(line);
         line.cover = Boolean(data.isCover);
-        line.rotatesWithFather = data.rotateWithFather;
+        line.rotatesWithFather = data.rotateWithFather ?? false;
         line.anchor = data.anchor ?? [0.5, 0.5];
         line.texture = data.Texture || "line.png";
         line.zOrder = data.zOrder ?? 0;
@@ -186,7 +183,8 @@ export class JudgeLine {
             line.speedSequence = EventNodeSequence.mergeSequences(speedSequences) as SpeedENS;
             line.speedSequence.updateFloorPositionAfter(line.speedSequence.head.next, timeCalculator);
         } else {
-            line.speedSequence = chart.createEventNodeSequence(EventType.speed, `#${id}.speed`) as SpeedENS;
+            line.speedSequence = speedSequences[0]
+            chart.registerEventNodeSequence(EventType.speed, `#${id}.speed`, speedSequences[0]);
         }
         if (data.extended) {
             if (data.extended.scaleXEvents) {
@@ -226,7 +224,7 @@ export class JudgeLine {
         const line = new JudgeLine(chart)
         line.id = id;
         line.name = lowerCaseNameAndTexture ? (data as JudgeLineDataKPA2).name : (data as JudgeLineDataKPA).Name;
-        line.rotatesWithFather = data.rotatesWithFather;
+        line.rotatesWithFather = data.rotatesWithFather ?? false;
         line.anchor = data.anchor ?? [0.5, 0.5];
         line.texture = (lowerCaseNameAndTexture ? (data as JudgeLineDataKPA2).texture : (data as JudgeLineDataKPA).Texture)  ?? "line.png";
         line.cover = data.cover ?? true;
@@ -255,9 +253,11 @@ export class JudgeLine {
             }
         }
         for (const child of data.children) {
-            line.children.add(JudgeLine.fromKPAJSON(version, chart, child.id, child, templates, timeCalculator));
+            const childLine = JudgeLine.fromKPAJSON(version, chart, child.id, child, templates, timeCalculator)
+            childLine.father = line;
+            line.children.add(childLine);
         }
-        const unwrap = <VT>(sequence: EventNodeSequence<unknown>, predicate: (value: unknown) => boolean, typeStr: keyof typeof EventValueType) => {
+        const unwrap = <VT extends EventValueESType>(sequence: EventNodeSequence<EventValueESType>, predicate: (value: unknown) => boolean, typeStr: keyof typeof EventValueType) => {
             const value = sequence.head.next.value
             if (!predicate(value)) {
                 throw err.EXPECTED_TYPED_ENS(typeStr, sequence.id, value);
@@ -289,16 +289,19 @@ export class JudgeLine {
                     ly.speed = null;
                 }
             }
-            let seq: EventNodeSequence<number>;
-            if (oldSequences.length > 0) {
+            let seq: SpeedENS;
+            if (oldSequences.length > 1) {
                 
                 seq = EventNodeSequence.mergeSequences(
                     oldSequences
-                );
-                (seq as SpeedENS).updateFloorPositionAfter((seq as SpeedENS).head.next, timeCalculator);
+                ) as SpeedENS;
+                seq.updateFloorPositionAfter((seq as SpeedENS).head.next, timeCalculator);
+            } else if (oldSequences.length === 1) {
+                chart.registerEventNodeSequence(EventType.speed, `#${line.id}.speed`, oldSequences[0]);
+                seq = oldSequences[0];
+                seq.updateFloorPositionAfter(seq.head.next, timeCalculator);
             } else {
-                seq = chart.createEventNodeSequence(EventType.speed, `#${line.id}.speed`);
-
+                seq = chart.createEventNodeSequence(EventType.speed, `#${line.id}.speed`) as SpeedENS;
             }
             line.speedSequence = seq as SpeedENS;
         }
@@ -562,7 +565,7 @@ export class JudgeLine {
         let startNode: EventStartNode<number> = this.speedSequence.getNodeAt(beats);
         let range: [number, number] = [undefined, undefined];
         // 启用遮罩时，两个Y边界都是正数，直接返回空数组
-        if (lineMonotonicity === Monotonicity.decreasing && startY >= 0 && endY > 0) {
+        if (lineMonotonicity === Monotonicity.increasing && startY >= 0 && endY > 0) {
 
             return result;
         }
@@ -781,7 +784,7 @@ export class JudgeLine {
                 return list;
             }
         }
-        const list = isHold ? new HNList(speed, medianYOffset, this.chart.timeCalculator.duration) : new NNList(speed, medianYOffset, this.chart.timeCalculator.duration)
+        const list = isHold ? new HNList(speed, medianYOffset, this.chart.effectiveBeats) : new NNList(speed, medianYOffset, this.chart.effectiveBeats)
         list.parentLine = this;
         NoteNode.connect(list.head, list.tail)
         if (initsJump) list.initJump();
@@ -843,6 +846,7 @@ export class JudgeLine {
         if (this.extendedLayer.text) {
             eventNodeSequences.add(this.extendedLayer.text);
         }
+        eventNodeSequences.add(this.speedSequence); // 忘了这个，特此留念（
         return {
             group: judgeLineGroups.indexOf(this.group),
             id: this.id,

package/jumparray.ts

@@ -219,7 +219,6 @@ export class JumpArray<T extends TwoDirectionNodeLike> {
         }
         let next: T | false;
         // console.log(this)
-        // eslint-disable-next-line no-cond-assign
         while (next = nextFn(node, beats)) {
             node = next;
             if (node.type === NodeType.TAIL) {

package/line.ts

@@ -0,0 +1,246 @@
+import { Chart, JudgeLineGroup, BasicEventName, UIName } from "../chart";
+import { ExtendedEventTypeName, RGB } from "../chartTypes";
+import { EventNodeSequence } from "../event";
+import { JudgeLine, ExtendedLayer } from "../judgeline";
+import { Operation } from "./basic";
+
+
+
+// 有点怪异，感觉破坏了纯净性。不管了（
+enum JudgeLinesEditorLayoutType {
+    ordered = 0b001,
+    tree    = 0b010,
+    grouped = 0b100
+}
+
+
+export class JudgeLineInheritanceChangeOperation extends Operation {
+    originalValue: JudgeLine | null;
+    updatesEditor = true;
+    static REFLOWS = JudgeLinesEditorLayoutType.tree;
+    reflows = JudgeLineInheritanceChangeOperation.REFLOWS;
+    constructor(public chart: Chart, public judgeLine: JudgeLine, public value: JudgeLine | null) {
+        super();
+        this.originalValue = judgeLine.father;
+        // 这里只会让它静默失败，外面调用的时候能够在判断一次并抛错误才是最好的
+        if (JudgeLine.checkinterdependency(judgeLine, value)) {
+            this.ineffective = true;
+        }
+    }
+    do() {
+        const line = this.judgeLine;
+        line.father = this.value;
+        if (this.originalValue) {
+            this.originalValue.children.delete(line);
+        } else {
+            const index = this.chart.orphanLines.indexOf(line);
+            if (index >= 0) // Impossible to be false, theoretically
+                this.chart.orphanLines.splice(index, 1)
+        }
+        if (this.value) {
+            this.value.children.add(line);
+        } else {
+            this.chart.orphanLines.push(line);
+        }
+    }
+    undo() {
+        const line = this.judgeLine;
+        line.father = this.originalValue;
+        if (this.originalValue) {
+            this.originalValue.children.add(line);
+        } else {
+            this.chart.orphanLines.push(line);
+        }
+        if (this.value) {
+            this.value.children.delete(line);
+        } else {
+            const index = this.chart.orphanLines.indexOf(line);
+            if (index >= 0) // Impossible to be false, theoretically
+                this.chart.orphanLines.splice(index, 1)
+        }
+    }
+}
+
+export class JudgeLineRenameOperation extends Operation { 
+    updatesEditor = true;
+    originalValue: string;
+    constructor(public judgeLine: JudgeLine, public value: string) {
+        super();
+        this.originalValue = judgeLine.name;
+    }
+    do() {
+        this.judgeLine.name = this.value;
+    }
+    undo() {
+        this.judgeLine.name = this.originalValue;
+    }
+}
+
+type JudgeLinePropName = "name" | "rotatesWithFather" | "anchor" | "texture" | "cover" | "zOrder";
+
+export class JudgeLinePropChangeOperation<T extends JudgeLinePropName> extends Operation {
+    updatesEditor = true;
+    originalValue: JudgeLine[T];
+    constructor(public judgeLine: JudgeLine, public field: T, public value: JudgeLine[T]) {
+        super();
+        this.originalValue = judgeLine[field];
+    }
+    do() {
+        this.judgeLine[this.field] = this.value;
+    }
+    undo() {
+        this.judgeLine[this.field] = this.originalValue;
+    }
+}
+
+export class JudgeLineRegroupOperation extends Operation {
+    updatesEditor = true;
+    reflows = JudgeLinesEditorLayoutType.grouped;
+    originalValue: JudgeLineGroup;
+    constructor(public judgeLine: JudgeLine, public value: JudgeLineGroup) {
+        super();
+        this.originalValue = judgeLine.group;
+    }
+    do() {
+        this.judgeLine.group = this.value;
+        this.value.add(this.judgeLine);
+        this.originalValue.remove(this.judgeLine);
+    }
+    undo() {
+        this.judgeLine.group = this.originalValue;
+        this.originalValue.add(this.judgeLine);
+        this.value.remove(this.judgeLine);
+    }
+}
+
+export class JudgeLineCreateOperation extends Operation {
+    reflows = JudgeLinesEditorLayoutType.grouped | JudgeLinesEditorLayoutType.tree | JudgeLinesEditorLayoutType.ordered;
+    // 之前把=写成了:半天不知道咋错了
+    constructor(public chart: Chart, public judgeLine: JudgeLine) {
+        super();
+    }
+    do() {
+        const id = this.chart.judgeLines.length;
+        this.judgeLine.id = id;
+        this.chart.judgeLines.push(this.judgeLine);
+        this.chart.orphanLines.push(this.judgeLine);
+        this.chart.judgeLineGroups[0].add(this.judgeLine);
+    }
+    undo() {
+        this.chart.judgeLineGroups[0].remove(this.judgeLine);
+        this.chart.judgeLines.splice(this.chart.judgeLines.indexOf(this.judgeLine), 1);
+        this.chart.orphanLines.splice(this.chart.orphanLines.indexOf(this.judgeLine), 1);
+    }
+}
+
+export class JudgeLineDeleteOperation extends Operation {
+    readonly originalGroup: JudgeLineGroup;
+    constructor(public chart: Chart, public judgeLine: JudgeLine) {
+        super();
+        if (!this.chart.judgeLines.includes(this.judgeLine)) {
+            this.ineffective = true;
+        }
+        this.originalGroup = judgeLine.group;
+    }
+    do() {
+        this.chart.judgeLines.splice(this.chart.judgeLines.indexOf(this.judgeLine), 1);
+        if (this.chart.orphanLines.includes(this.judgeLine)) {
+            this.chart.orphanLines.splice(this.chart.orphanLines.indexOf(this.judgeLine), 1);
+        }
+        this.originalGroup.remove(this.judgeLine);
+    }
+    undo() {
+        this.chart.judgeLines.push(this.judgeLine);
+        this.chart.orphanLines.push(this.judgeLine);
+        this.originalGroup.add(this.judgeLine);
+    }
+}
+
+
+
+export class JudgeLineENSChangeOperation extends Operation {
+    originalValue: EventNodeSequence;
+    constructor(public judgeLine: JudgeLine, public layerId: number, public typeStr: BasicEventName, public value: EventNodeSequence) {
+        super();
+        this.originalValue = judgeLine.eventLayers[layerId][typeStr];
+    }
+    do() {
+        this.judgeLine.eventLayers[this.layerId][this.typeStr] = this.value;
+    }
+    undo() {
+        this.judgeLine.eventLayers[this.layerId][this.typeStr] = this.originalValue;
+    }
+}
+
+
+export type ENSOfTypeName<T extends ExtendedEventTypeName> = {
+    "scaleX": EventNodeSequence<number>,
+    "scaleY": EventNodeSequence<number>
+    "text": EventNodeSequence<string>,
+    "color": EventNodeSequence<RGB> 
+}[T]
+export class JudgeLineExtendENSChangeOperation<T extends ExtendedEventTypeName> extends Operation {
+    originalValue: ENSOfTypeName<T>;
+    constructor(public judgeLine: JudgeLine, public typeStr: T, public value: ENSOfTypeName<T> | null) {
+        super();
+        this.originalValue = judgeLine.extendedLayer[typeStr satisfies keyof ExtendedLayer] as ENSOfTypeName<T>;
+    }
+    do() {
+        this.judgeLine.extendedLayer[this.typeStr] = this.value
+    }
+    undo() {
+        this.judgeLine.extendedLayer[this.typeStr] = this.originalValue
+    }
+
+}
+
+export class UIAttachOperation extends Operation {
+    updatesEditor = true;
+    constructor(public chart: Chart, public judgeLine: JudgeLine, public ui: UIName) {
+        super();
+    }
+    do() {
+        this.chart.attachUIToLine(this.ui, this.judgeLine);
+    }
+    undo() {
+        this.chart.detachUI(this.ui);
+    }
+}
+
+export class UIDetachOperation extends Operation {
+    updatesEditor = true;
+    judgeLine: JudgeLine;
+    constructor(public chart: Chart, public ui: UIName) {
+        super();
+        if (chart[`${ui}Attach` satisfies keyof Chart]) {
+            this.judgeLine = chart[`${ui}Attach` satisfies keyof Chart];
+        } else {
+            this.ineffective = true;
+        }
+    }
+    do() {
+        this.chart.detachUI(this.ui);
+    }
+    undo() {
+        this.chart.attachUIToLine(this.ui, this.judgeLine);
+    }
+}
+
+export class JudgeLineDetachAllUIOperation extends Operation {
+    updatesEditor = true;
+    uinames: UIName[];
+    constructor(public chart: Chart, public judgeLine: JudgeLine) {
+        super();
+        this.uinames = chart.queryJudgeLineUI(this.judgeLine);
+    }
+    do() {
+        for (const ui of this.uinames) {
+            this.chart.detachUI(ui);
+        }
+    }
+    undo() {
+        for (const ui of this.uinames) {
+            this.chart.attachUIToLine(ui, this.judgeLine);
+        }
+    }
+}

package/macro.ts

@@ -0,0 +1,215 @@
+import type { Chart } from "./chart";
+import type { EventValueESType, MacroData, MacroEvaluatorBodyData, MacroLink, MacroTimeBodyData, MacroValueBodyData, RGB, TimeT } from "./chartTypes";
+import { err, ERROR_IDS, KPAError } from "./env";
+import { MacroEvaluator } from "./evaluator";
+import type { EventNode, EventStartNode } from "./event";
+import type { JudgeLine } from "./judgeline";
+import { Note } from "./note";
+
+
+const getLine = (node: EventStartNode<EventValueESType>, chart: Chart) => {
+    const canBeId = node.parentSeq.id.match(/#(\d+)/);
+    if (!canBeId) {
+        return null;
+    }
+    return chart.judgeLines[parseInt(canBeId[1])]
+}
+
+
+// 添加表达式宏，通过@表示。如@line.id表示判定线ID，会在构造函数中被替换为实际值
+export const EVENT_MACROS = {
+    "line.id": (node: EventStartNode<EventValueESType>, chart: Chart) => getLine(node, chart)?.id,
+    "line.name": (node: EventStartNode<EventValueESType>, chart: Chart) => getLine(node, chart)?.name,
+    "line.group": (node: EventStartNode<EventValueESType>, chart: Chart) => getLine(node, chart)?.group,
+    "node.time": (node: EventStartNode<EventValueESType>) => node.time,
+    "node.value": (node: EventStartNode<EventValueESType>) => node.value,
+    "seq.id": (node: EventStartNode<EventValueESType>) => node.parentSeq.id,
+    "seq.type": (node: EventStartNode<EventValueESType>) => node.parentSeq.type
+}
+
+export type Macroable = number | string | TimeT | RGB | boolean;
+export type Macroee = EventNode<EventValueESType> | Note;
+
+export abstract class Macro<T extends Macroable, C extends Macroee, P extends Macroee> {
+    public readonly consumers: Map<C, number> = new Map();
+    /**
+     * **原形节点**
+     * 
+     * 作为参数，向其他节点派生数值。
+     * 
+     * 需要parametric为true。
+     * 
+     * 如：若节点A存在于这个数组，下标为1：
+     * 
+     * 节点B设有数值宏，即这个宏，宏表达式： @proto.value + 2。
+     * 
+     * 那么评估B的宏时可以调用节点A的数值。
+     * 
+     * 在转储时，是节点存储宏的ID，而不是宏去找节点，因为节点并没有全谱面编号系统。
+     */
+    public readonly protoNodes: P[] = [];
+    /**
+     * 
+     * @param macro 
+     * @param id 
+     * @param parametric 是否为参数宏，即是否可以把一个节点作为参数。     
+     */
+    constructor(public macro: string, public id: string, public readonly parametric: boolean) {
+    }
+    abstract eval(consumer: C, chart: Chart): T;
+}
+
+export abstract class EventMacro<T extends Macroable> extends Macro<T, EventNode<EventValueESType>, EventNode<EventValueESType>> {
+    eval(node: EventNode<EventValueESType>, chart: Chart): T {
+        let jsExpr = this.parametric ? this.macro.replace(/@proto\.(value|time)/, (k) => {
+            return JSON.stringify(this.protoNodes[this.consumers.get(node)!][k]) + " "
+        }): this.macro;
+        jsExpr =  this.macro.replace(/@([a-z]+\.[a-z])/, (k) => {
+            return JSON.stringify(EVENT_MACROS[k](node, chart)) + " "
+        });
+        return new Function("return " + jsExpr)() as T;
+    }
+    checkSyntax(): KPAError<ERROR_IDS.PROTO_PRESENT_IN_NONPARAMETRIC | ERROR_IDS.UNKNOWN_MACRO_EXPRESSION | ERROR_IDS.JAVASCRIPT_SYNTAX_ERROR> | null {
+        let jsExpr: string;
+        if (this.parametric) {
+            jsExpr = this.macro.replace(/@proto\.(value|time)/, (k) => {
+                return '"aaa" '
+            });
+        } else {
+            if (/@proto/.test(this.macro)) {
+                return err.PROTO_PRESENT_IN_NONPARAMETRIC(this.id);
+            }
+        }
+        try {
+            jsExpr =  this.macro.replace(/@([a-z]+\.[a-z])/, (k) => {
+                if (!(k in EVENT_MACROS)) {
+                    throw err.UNKNOWN_MACRO_EXPRESSION(k, this.id);
+                }
+                return '"aaa" '
+            });
+        } catch (e) {
+            if (e instanceof KPAError) {
+                return e;
+            } else {
+                throw e;
+            }
+        }
+        try {
+            new Function("return " + jsExpr); // 仅检查语法，不执行
+        } catch (e) {
+            return err.JAVASCRIPT_SYNTAX_ERROR(e, this.id);
+        }
+    }
+    bindNode(node: EventNode<EventValueESType>, macroData: MacroData, pos?: string) {
+        if (this.parametric) {
+            if (typeof macroData === "string") {
+                throw err.PARAMETRIC_MACRO_REQUIRES_PROTO_KEY(pos)
+            }
+            this.consumers.set(node, macroData[1]);
+        } else {
+            if (Array.isArray(macroData)) {
+                throw err.MACRO_NOT_PARAMETRIC(this.id, pos);
+            }
+            this.consumers.set(node, -1);
+        }
+    }
+    linkProtoNode(node: EventNode<EventValueESType>, id: number): void {
+        this.protoNodes[id] = node;
+        node.linkedMacros.add(this);
+    }
+    dumpContent(): MacroValueBodyData {
+        return {
+            id: this.id,
+            macro: this.macro,
+            parametric: this.parametric ? true : undefined
+        }
+    }
+    /**
+     * 为单个节点导出宏名称和参数（若有）
+     * @param node 
+     * @example
+     * return {
+     *     start: node.value,
+     *     end: node.next.value,
+     *     macroStart: node.valueMacro.dumpForNode(node),
+     *     macroEnd: node.valueMacro.dumpForNode(node.next),
+     *     ...
+     * } satisfies EvenDataKPA2
+     * 
+     */
+    dumpForNode(node: EventNode<EventValueESType>): MacroData {
+        if (this.parametric) {
+            return [this.id, this.consumers.get(node)!]
+        } else {
+            return this.id
+        }
+    }
+    abstract dumpLinkForNode(node: EventNode<EventValueESType>): MacroLink;
+}
+
+export class EventMacroValue extends EventMacro<EventValueESType> {
+    dumpLinkForNode(node: EventNode<EventValueESType>): MacroLink {
+        return [`value:${this.id}`, this.protoNodes.indexOf(node)];
+    }
+}
+
+export class EventMacroTime extends EventMacro<TimeT> {
+    dumpLinkForNode(node: EventNode<EventValueESType>): MacroLink {
+        return [`time:${this.id}`, this.protoNodes.indexOf(node)];
+    }
+}
+
+export class MacroLib {
+    timeMacros: Map<string, EventMacroTime> = new Map();
+    valueMacros: Map<string, EventMacroValue> = new Map();
+    macroEvaluators: Map<string, MacroEvaluator<EventValueESType>> = new Map();
+    dumpTimeMacros(): MacroTimeBodyData[] {
+        const arr: MacroTimeBodyData[] = [];
+        for (const [_, macro] of this.timeMacros) {
+            arr.push(macro.dumpContent());
+        }
+        return arr;
+    }
+    readTimeMacros(data: MacroTimeBodyData[]) {
+        const len = data.length;
+        for (let i = 0; i < len; i++) {
+            const datum = data[i];
+            const macro = new EventMacroTime(datum.macro, datum.id, datum.parametric);
+            this.timeMacros.set(datum.id, macro);
+        }
+    }
+
+    dumpValueMacros(): MacroValueBodyData[] {
+        const arr: MacroValueBodyData[] = [];
+        for (const [_, macro] of this.valueMacros) {
+            arr.push(macro.dumpContent());
+        }
+        return arr;
+    }
+    readValueMacros(data: MacroValueBodyData[]) {
+        const len = data.length;
+        for (let i = 0; i < len; i++) {
+            const datum = data[i];
+            const macro = new EventMacroValue(datum.macro, datum.id, datum.parametric);
+            this.valueMacros.set(datum.id, macro);
+        }
+    }
+
+    dumpMacroEvaluators(): MacroEvaluatorBodyData[] {
+        const arr: MacroEvaluatorBodyData[] = [];
+        for (const [_, ev] of this.macroEvaluators) {
+            arr.push({
+                id: ev.id,
+                macro: ev.expression
+            })
+        }
+        return arr;
+    }
+    readMacroEvaluators(data: MacroEvaluatorBodyData[]): void {
+        const len = data.length;
+        for (let i = 0; i < len; i++) {
+            const datum = data[i];
+            this.macroEvaluators.set(datum.id, new MacroEvaluator(datum.macro, datum.id));
+        }
+    }
+}

package/note.ts

@@ -185,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就应该是个绝对的值，不受速度影响 */
             /** 但是有历史包袱，所以加字段 */