kipphi 2.0.0 → 2.1.0

package/jumparray.ts

@@ -1,9 +1,7 @@
 import { NodeType } from "./util";
+import Env from "./env";
 
 // type EndBeats = number;
-const MIN_LENGTH = 128
-const MAX_LENGTH = 1024
-const MINOR_PARTS = 16;
 /// #declaration:global
 
 type EndNextFn<T extends TwoDirectionNodeLike> = (node: T) => [endBeats: number, next: T];
@@ -23,6 +21,7 @@ export class JumpArray<T extends TwoDirectionNodeLike> {
     averageBeats: number;
     effectiveBeats: number;
     goPrev: (node: T) => T;
+    readonly MINOR_SCALE_COUNT: number = Env.JUMPARRAY_MINOR_SCALE_COUNT;
 
     /**
      * 
@@ -46,7 +45,7 @@ export class JumpArray<T extends TwoDirectionNodeLike> {
         this.header = head;
         this.tailer = tail;
         // const originalListLength = this.listLength
-        const listLength: number = Math.max(MIN_LENGTH, Math.min(originalListLength * 4, MAX_LENGTH));
+        const listLength: number = Math.max(Env.JUMPARRAY_MIN_LENGTH, Math.min(originalListLength * 4, Env.JUMPARRAY_MAX_LENGTH));
         const averageBeats: number = Math.pow(2, Math.ceil(Math.log2(effectiveBeats / listLength)));
         const exactLength: number = Math.ceil(effectiveBeats / averageBeats);
         // console.log(exactLength, listLength, averageBeats, exactLength)
@@ -91,6 +90,7 @@ export class JumpArray<T extends TwoDirectionNodeLike> {
     updateRange(firstNode: T, lastNode: T) {
         const {endNextFn, effectiveBeats, resolveLastNode} = this;
         lastNode = resolveLastNode(lastNode);
+        const MINOR_PARTS = this.MINOR_SCALE_COUNT;
         // console.log(firstNode, lastNode)
         /**
          * 
@@ -125,16 +125,13 @@ export class JumpArray<T extends TwoDirectionNodeLike> {
                     if (Array.isArray(jumpArray[jumpIndex])) {
                         fillMinor(previousEndTime, endTime)
                     } else {
-                        try {
-                            // console.log(jumpIndex, currentNode)
                         jumpArray[jumpIndex] = currentNode;
-                        } catch (E) {console.log(jumpIndex, jumpArray);debugger}
                     }
                     jumpIndex++;
                 }
                 const currentJumpBeats: number = jumpIndex * averageBeats // 放错了
                 if (endTime > currentJumpBeats) {
-                    let minor = jumpArray[jumpIndex];
+                    const minor = jumpArray[jumpIndex];
                     if (!Array.isArray(minor)) {
                         jumpArray[jumpIndex] = new Array(MINOR_PARTS);
                     }
@@ -175,8 +172,9 @@ export class JumpArray<T extends TwoDirectionNodeLike> {
         const jumpAverageBeats = this.averageBeats;
         const jumpPos = Math.floor(beats / jumpAverageBeats);
         const rest = beats - jumpPos * jumpAverageBeats;
+        const MINOR_PARTS = this.MINOR_SCALE_COUNT;
         for (let i = jumpPos; i >= 0; i--) {
-            let canBeNodeOrArray: T | T[] = this.array[i];
+            const canBeNodeOrArray: T | T[] = this.array[i];
             if (Array.isArray(canBeNodeOrArray)) {
                 const minorIndex = Math.floor(rest / (jumpAverageBeats / MINOR_PARTS)) - 1;
                 for (let j = minorIndex; j >= 0; j--) {
@@ -202,11 +200,12 @@ export class JumpArray<T extends TwoDirectionNodeLike> {
         if (beats >= this.effectiveBeats) {
             return this.tailer;
         }
+        const MINOR_PARTS = this.MINOR_SCALE_COUNT;
         const jumpAverageBeats = this.averageBeats;
         const jumpPos = Math.floor(beats / jumpAverageBeats);
         const rest = beats - jumpPos * jumpAverageBeats;
         const nextFn = this.nextFn;
-        let canBeNodeOrArray: T | T[] = this.array[jumpPos]
+        const canBeNodeOrArray: T | T[] = this.array[jumpPos]
         let node: T = Array.isArray(canBeNodeOrArray)
             ? canBeNodeOrArray[Math.floor(rest / (jumpAverageBeats / MINOR_PARTS))]
             : canBeNodeOrArray;
@@ -216,7 +215,7 @@ export class JumpArray<T extends TwoDirectionNodeLike> {
         // console.log(this, node, jumpPos, beats)
         if (!node) {
             console.warn("No node:", node, beats)
-            debugger
+            throw new Error();
         }
         let next: T | false;
         // console.log(this)

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));
+        }
+    }
+}