kipphi 2.0.1 → 2.1.0

package/chartTypes.ts

@@ -212,7 +212,8 @@ export type EasingDataKPA2 = NormalEasingData | TemplateEasingData | BezierEasin
 
 export enum EvaluatorType {
     eased,
-    expressionbased
+    expressionbased,
+    macro
 }
 
 // Eased
@@ -237,14 +238,53 @@ export interface ExpressionEvaluatorDataKPA2 {
     jsExpr: string;
 }
 
+export interface MacroEvaluatorDataKPA2 {
+    type: EvaluatorType.macro;
+    name: string;
+    compiled: string;
+}
+
+
+export type EvaluatorDataKPA2<T> = EasedEvaluatorDataOfType<T> | ExpressionEvaluatorDataKPA2 | MacroEvaluatorDataKPA2;
+
+export type MacroData = [id: string, proto: number] | string;
+export type MacroLink = [macroTypeAndId: `${'value' | 'time'}:${string}`, nodeId: number]
 
-export type EvaluatorDataKPA2<T> = EasedEvaluatorDataOfType<T> | ExpressionEvaluatorDataKPA2;
 export interface EventDataKPA2<T = number> {
+    /** 开始时间 */
     startTime: TimeT;
+    /** 结束时间 */
     endTime: TimeT;
+    /** 起始值 */
     start: T;
+    /** 终值 */
     end: T;
+    /** 求值器 */
     evaluator: EvaluatorDataKPA2<T>;
+    /** 终值绑定的宏的ID */
+    macroEnd?: MacroData;
+    /** 起始值绑定的宏的ID */
+    macroStart?: MacroData;
+    /** 起始时间绑定的宏的ID */
+    macroStartTime?: MacroData;
+    /** 将该事件的起始节点关联到一个宏的某个参数 */
+    startLinkedMacro?: MacroLink[];
+    endLinkedMacro?: MacroLink[];
+}
+
+export interface FinalEventStartNodeDataKPA2<T = number> {
+    /** 开始时间 */
+    startTime: TimeT;
+    /** 起始值 */
+    start: T;
+    /** 求值器 */
+    evaluator: EvaluatorDataKPA2<T>;
+    /** 起始值绑定的宏的ID */
+    macro?: MacroData;
+    /** 起始时间绑定的宏的ID */
+    macroTime?: MacroData;
+    /** 将该事件的起始节点关联到一个宏的某个参数 */
+    linkedMacro?: MacroLink[];
 }
 
 export enum EventValueType {
@@ -458,7 +498,7 @@ export interface EventNodeSequenceDataKPA2<VT> {
     events: EventDataKPA2<VT>[];
     id: string;
     type: EventType;
-    endValue: VT;
+    final: FinalEventStartNodeDataKPA2<VT>;
 }
 
 export interface WrapperEasingBodyData {
@@ -468,6 +508,21 @@ export interface WrapperEasingBodyData {
     id: string;
 }
 
+export interface MacroEvaluatorBodyData {
+    macro: string;
+    id: string;
+}
+
+export interface MacroTimeBodyData {
+    id: string;
+    macro: string;
+    parametric?: boolean;
+}
+export interface MacroValueBodyData {
+    id: string;
+    macro: string;
+    parametric?: boolean;
+}
 export interface ChartDataKPA {
     version: number;
     offset: number;
@@ -499,6 +554,7 @@ export interface ChartDataKPA {
 
 export interface ChartDataKPA2 {
     version: number;
+    $schema: string;
     offset: number;
     duration: number;
     info: {
@@ -509,16 +565,19 @@ export interface ChartDataKPA2 {
         composer: string;
     };
     ui: {
-        pause: number;
-        combonumber: number;
-        combo: number;
-        score: number;
-        bar: number;
-        name: number;
-        level: number;
+        pause?: number;
+        combonumber?: number;
+        combo?: number;
+        score?: number;
+        bar?: number;
+        name?: number;
+        level?: number;
     }
     templateEasings: TemplateEasingBodyData[];
-    wrapperEasings: WrapperEasingBodyData[]
+    wrapperEasings: WrapperEasingBodyData[];
+    macroEvaluators: MacroEvaluatorBodyData[];
+    timeMacros: MacroTimeBodyData[];
+    valueMacros: MacroValueBodyData[];
     eventNodeSequences: EventNodeSequenceDataKPA2<unknown>[];
     orphanLines: JudgeLineDataKPA2[];
     bpmList: BPMSegmentData[];

package/easing.ts

@@ -1,7 +1,7 @@
 import { type TemplateEasingBodyData, type EasingDataKPA2, EasingType, EventType, type SegmentedEasingData, type NormalEasingData, type BezierEasingData, type TemplateEasingData, WrapperEasingData, WrapperEasingBodyData } from "./chartTypes";
 import { type EventNodeSequence } from "./event";
 import { type TupleCoord } from "./util";
-import Environment from "./env";
+import Environment, { err } from "./env";
 import { type ExpressionEvaluator } from "./evaluator";
 
 
@@ -93,6 +93,40 @@ const easeInOutElastic = toEaseInOut(easeInElastic, easeOutElastic);
 const easeInOutBounce = toEaseInOut(easeInBounce, easeOutBounce);
 
 
+export const easingFns = {
+    linear,
+    easeInSine,
+    easeOutSine,
+    easeInOutSine,
+    easeInQuad,
+    easeOutQuad,
+    easeInOutQuad,
+    easeInCubic,
+    easeOutCubic,
+    easeInOutCubic,
+    easeInQuart,
+    easeOutQuart,
+    easeInOutQuart,
+    easeInQuint,
+    easeOutQuint,
+    easeInOutQuint,
+    easeInExpo,
+    easeOutExpo,
+    easeInOutExpo,
+    easeInCirc,
+    easeOutCirc,
+    easeInOutCirc,
+    easeInBack,
+    easeOutBack,
+    easeInOutBack,
+    easeInElastic,
+    easeOutElastic,
+    easeInOutElastic,
+    easeInBounce,
+    easeOutBounce,
+    easeInOutBounce
+}
+
 type FuncType = "linear" | "sine" | "quad" | "cubic" | "quart" | "quint" | "expo" | "circ" | "back" | "elastic" | "bounce"
 
 export const easingFnMap: {
@@ -185,11 +219,6 @@ export class NormalEasing extends Easing {
         this._getValue = fn;
     }
     getValue(t: number): number {
-        if (t > 1 || t < 0) {
-            console.warn("缓动超出定义域！")
-            // debugger;
-        }
-        // console.log("t:", t, "rat", this._getValue(t))
         return this._getValue(t)
     }
     private dumpCache: NormalEasingData;
@@ -394,7 +423,7 @@ export class TemplateEasingLib {
     check() {
         for (const [name, easing] of this.easings) {
             if (!easing.eventNodeSequence) {
-                console.warn(`未实现的缓动：${name}`);
+                err.UNIMPLEMENTED_TEMPLATE_EASING(name).warn();
             }
         }
     }
@@ -502,7 +531,7 @@ easingArray.forEach((easing, index) => {
 })
 
 export const rpeEasingArray = [
-    null,
+    fixedEasing,
     linearEasing, // 1
     easingMap.sine.out, // 2
     easingMap.sine.in, // 3

package/env.ts

@@ -14,6 +14,7 @@
 
 // 就挺神奇的！明明typeof后面跟值，这里却可以写成类型导入
 import { type TimeT, type EventValueType } from "./chartTypes";
+import { EventNode } from "./event";
 import { toTimeString } from "./util";
 
 // occupied 1
@@ -33,6 +34,7 @@ const
     EASING = 0xA00,
     NOTE = 0xB00,
     TC = 0xC00,
+    MACRO = 0xD00,
     INTERNAL = 0xF00,
 
     OCCPIED = 0x10,
@@ -65,19 +67,30 @@ export enum ERROR_IDS {
     INVALID_EASING_ID =                             EASING     | INVALID_DATA  | 0,
     CANNOT_IMPLEMENT_TEMEAS_WITH_NON_EASING_ENS =   EASING     | INVALID_DATA  | 1,
     CANNOT_IMPLEMENT_TEMEAS_WITH_NON_NUMERIC_ENS =  EASING     | INVALID_DATA  | 2,
+    UNIMPLEMENTED_TEMPLATE_EASING =                 EASING     | INVALID_DATA  | 3,
     MUST_INTERPOLATE_TEMPLATE_EASING =              EASING     | INVALID_USAGE | 0,
     NODES_NOT_CONTINUOUS =                          EASING     | INVALID_USAGE | 1,
     NODES_NOT_BELONG_TO_SAME_SEQUENCE =             EASING     | INVALID_USAGE | 2,
     NODES_HAS_ZERO_DELTA =                          EASING     | INVALID_USAGE | 3,
 
     CANNOT_DIVIDE_EXPRESSION_EVALUATOR =            EVALUATOR  | INVALID_USAGE | 0,
+    MISSING_MACRO_EVALUATOR_KEY =                   EVALUATOR  | INVALID_DATA  | 0,
+    MACRO_EVALUATOR_NOT_FOUND =                     EVALUATOR  | INVALID_DATA  | 1,
     
     
 
     INVALID_NOTE_PROP_TYPE =                        NOTE       | INVALID_TYPE  | 0,
 
 
-    INVALID_TIME_TUPLE =                            TC         | INVALID_DATA  | 0
+    INVALID_TIME_TUPLE =                            TC         | INVALID_DATA  | 0,
+
+    TIME_MACRO_NOT_FOUND =                          MACRO      | INVALID_DATA  | 0,
+    VALUE_MACRO_NOT_FOUND =                         MACRO      | INVALID_DATA  | 1,
+    UNKNOWN_MACRO_EXPRESSION =                      MACRO      | INVALID_DATA  | 2,
+    JAVASCRIPT_SYNTAX_ERROR =                       MACRO      | INVALID_DATA  | 3,
+    PROTO_PRESENT_IN_NONPARAMETRIC =                MACRO      | INVALID_USAGE | 0,
+    PARAMETRIC_MACRO_REQUIRES_PROTO_KEY =           MACRO      | INVALID_DATA  | 4,
+    MACRO_NOT_PARAMETRIC =                          MACRO      | INVALID_DATA  | 5,
 }
 
 export const ERRORS = {
@@ -140,6 +153,28 @@ export const ERRORS = {
     CANNOT_DIVIDE_EXPRESSION_EVALUATOR: (id: string) =>
         `Cannot divide ExpressionEvaluator (Compiling ${id})`,
 
+
+    UNIMPLEMENTED_TEMPLATE_EASING: (temEasName: string) =>
+        `Unimplemented template easing: '${temEasName}'`,
+
+    MISSING_MACRO_EVALUATOR_KEY: (pos: string) =>
+        `Missing Macro Evaluator key. At ${pos}`,
+    MACRO_EVALUATOR_NOT_FOUND: (evaluatorId: string, pos: string) =>
+        `Macro Evaluator '${evaluatorId}' not found. At ${pos}`,
+    TIME_MACRO_NOT_FOUND: (macroId: string, pos: string) =>
+        `Time Macro '${macroId}' not found. At ${pos}`,
+    VALUE_MACRO_NOT_FOUND: (macroId: string, pos: string) =>
+        `Value Macro '${macroId}' not found. At ${pos}`,
+    UNKNOWN_MACRO_EXPRESSION: (expression: string, macroId: string) =>
+        `Unknown Macro Expression '${expression}'. At ${macroId}`,
+    PROTO_PRESENT_IN_NONPARAMETRIC: (macroId: string) =>
+        `'@proto can only be used in parametric Macros. At ${macroId}'`,
+    JAVASCRIPT_SYNTAX_ERROR: (error: Error, macroId: string) =>
+        `JavaScript Syntax Error: ${error.message}. At ${macroId}`,
+    PARAMETRIC_MACRO_REQUIRES_PROTO_KEY: (pos) =>
+        `Parametric Macro requires key. At ${pos}`,
+    MACRO_NOT_PARAMETRIC: (macroId: string, pos) =>
+        `Macro '${macroId}' is not parametric. At ${pos}`,
 } satisfies Record<keyof typeof ERROR_IDS, (...args: any[]) => string>
 
 export class KPAError<ET extends ERROR_IDS> extends Error {

package/evaluator.ts

@@ -9,7 +9,10 @@ import {
 import TC from "./time";
 
 import type { EventEndNode, EventStartNode, NonLastStartNode } from "./event";
-import { EvaluatorType, InterpreteAs, type ColorEasedEvaluatorKPA2, type EvaluatorDataKPA2, type EventValueESType, type ExpressionEvaluatorDataKPA2, type NumericEasedEvaluatorKPA2, type RGB, type TextEasedEvaluatorKPA2 } from "./chartTypes";
+import { EasingType, EvaluatorType, EventValueType, EventValueTypeOfType, InterpreteAs, MacroEvaluatorBodyData, MacroEvaluatorDataKPA2, type ColorEasedEvaluatorKPA2, type EvaluatorDataKPA2, type EventValueESType, type ExpressionEvaluatorDataKPA2, type NumericEasedEvaluatorKPA2, type RGB, type TextEasedEvaluatorKPA2 } from "./chartTypes";
+import type { JudgeLine } from "./judgeline";
+import { Chart } from "./chart";
+import { EVENT_MACROS } from "./macro";
 
 
 /// #declaration:global
@@ -23,9 +26,9 @@ import { EvaluatorType, InterpreteAs, type ColorEasedEvaluatorKPA2, type Evaluat
  * @immutable
  * @since 2.0.0
  */
-export abstract class Evaluator<T> {
-    abstract eval(event: EventStartNode<T>, beats: number): T;
-    abstract dump(): EvaluatorDataKPA2<T>;
+export abstract class Evaluator<T extends EventValueESType> {
+    abstract eval(event: NonLastStartNode<T>, beats: number): T;
+    abstract dumpFor(node: EventStartNode<T>): EvaluatorDataKPA2<T>;
 }
 
 
@@ -54,6 +57,24 @@ export abstract class EasedEvaluator<T extends EventValueESType> extends Evaluat
      * @returns 
      */
     abstract deriveWithEasing(easing: Easing): EasedEvaluator<T>;
+
+    static getEvaluatorFromEasing<T extends EventValueESType>(type: EventValueTypeOfType<T>, easing: Easing, interpretedAs?: InterpreteAs): EasedEvaluatorOfType<T> {
+        const easingIsNormal = easing instanceof NormalEasing;
+        switch (type) {
+            case EventValueType.numeric:
+                return easingIsNormal
+                    ? NumericEasedEvaluator.evaluatorsOfNormalEasing[easing.rpeId] as EasedEvaluatorOfType<T>
+                    : new NumericEasedEvaluator(easing) as EasedEvaluatorOfType<T>;
+            case EventValueType.color:
+                return easingIsNormal
+                    ? ColorEasedEvaluator.evaluatorsOfNormalEasing[easing.rpeId] as EasedEvaluatorOfType<T>
+                    : new ColorEasedEvaluator(easing) as EasedEvaluatorOfType<T>;
+            case EventValueType.text:
+                return easingIsNormal
+                    ? TextEasedEvaluator.evaluatorsOfNoEzAndItpAs[easing.rpeId][interpretedAs ?? InterpreteAs.str] as EasedEvaluatorOfType<T>
+                    : new TextEasedEvaluator(easing, interpretedAs) as EasedEvaluatorOfType<T>
+        }
+    }
 }
 
 export type EasedEvaluatorOfType<T extends EventValueESType> = T extends number ? NumericEasedEvaluator : T extends RGB ? ColorEasedEvaluator : TextEasedEvaluator;
@@ -64,7 +85,7 @@ export class NumericEasedEvaluator extends EasedEvaluator<number> {
         super(easing);
     }
     private cache?: NumericEasedEvaluatorKPA2
-    override dump(): NumericEasedEvaluatorKPA2 {
+    override dumpFor(): NumericEasedEvaluatorKPA2 {
         return this.cache ??= {
             type: EvaluatorType.eased,
             easing: this.easing.dump()
@@ -88,7 +109,7 @@ export class ColorEasedEvaluator extends EasedEvaluator<RGB> {
     constructor(easing: Easing) {
         super(easing);
     }
-    override dump(): ColorEasedEvaluatorKPA2 {
+    override dumpFor(): ColorEasedEvaluatorKPA2 {
         return {
             type: EvaluatorType.eased,
             easing: this.easing.dump()
@@ -126,7 +147,7 @@ export class TextEasedEvaluator extends EasedEvaluator<string> {
     {
         super(easing);
     }
-    override dump(): TextEasedEvaluatorKPA2 {
+    override dumpFor(): TextEasedEvaluatorKPA2 {
         return {
             type: EvaluatorType.eased,
             easing: this.easing.dump(),
@@ -174,19 +195,60 @@ export class TextEasedEvaluator extends EasedEvaluator<string> {
     }
 }
 
-export class ExpressionEvaluator<T> extends Evaluator<T> {
+
+
+export class MacroEvaluator<T extends EventValueESType> extends Evaluator<T> {
+    readonly consumers: Map<EventStartNode<T>, ExpressionEvaluator<T>> = new Map();
+    constructor(public expression: string, public id: string) {
+        super();
+    }
+    compile(node: EventStartNode<T>, chart: Chart): ExpressionEvaluator<T> {
+        const jsExpr = this.expression
+        .replace(/@([a-z\.]+)/, (k) => {
+            return JSON.stringify(EVENT_MACROS[k](node, chart)) + " "
+        }).replace(/@\{\{(.+?)\}\}/g, (k) => {
+            const replaced = k.replace(new RegExp(Object.keys(EVENT_MACROS).join("|"), "g"), (k) => {
+                return JSON.stringify(EVENT_MACROS[k](node, chart)) + " "
+            });
+            return JSON.stringify(new Function("return " + replaced)()) + " ";
+        });
+        return new ExpressionEvaluator(jsExpr);
+    }
+    assignTo(node: EventStartNode<T>, chart: Chart): void {
+        node.evaluator = this;
+        this.consumers.set(node, this.compile(node, chart));
+    }
+    eval(event: NonLastStartNode<T>, beats: number): T {
+        return this.consumers.get(event)!.eval(event, beats);
+    }
+    dumpFor(node: EventStartNode<T>): MacroEvaluatorDataKPA2 {
+        return {
+            type: EvaluatorType.macro,
+            name: this.id,
+            compiled: this.consumers.get(node)!.jsExpr
+        }
+    }
+    dumpContent(): MacroEvaluatorBodyData {
+        return {
+            id: this.id,
+            macro: this.expression
+        }
+    }
+}
+
+export class ExpressionEvaluator<T extends EventValueESType> extends Evaluator<T> {
     readonly func: (t: number) => T;
     constructor(public readonly jsExpr: string) {
         super();
         this.func = new Function("t", "return " + jsExpr) as (t: number) => T;
     }
-    override eval(startNode: EventStartNode<T> & { next: EventEndNode }, beats: number): T {
+    override eval(startNode: NonLastStartNode<T>, beats: number): T {
         const next = startNode.next;
         const timeDelta = TC.getDelta(next.time, startNode.time)
         const current = beats - TC.toBeats(startNode.time)
         return this.func(current / timeDelta);
     }
-    override dump(): ExpressionEvaluatorDataKPA2 {
+    override dumpFor(): ExpressionEvaluatorDataKPA2 {
         return {
             type: EvaluatorType.expressionbased,
             jsExpr: this.jsExpr