webgal-parser 4.6.2 → 4.6.3-beta.2

package/build/umd/index.global.js

@@ -38,6 +38,7 @@ var webgalParser = (function (exports) {
       commandType[commandType["applyStyle"] = 32] = "applyStyle";
       commandType[commandType["wait"] = 33] = "wait";
       commandType[commandType["callSteam"] = 34] = "callSteam";
+      commandType[commandType["return"] = 35] = "return";
   })(commandType || (commandType = {}));
 
   const SCRIPT_CONFIG = [
@@ -79,6 +80,7 @@ var webgalParser = (function (exports) {
       { scriptString: 'applyStyle', scriptType: commandType.applyStyle },
       { scriptString: 'wait', scriptType: commandType.wait },
       { scriptString: 'callSteam', scriptType: commandType.callSteam },
+      { scriptString: 'return', scriptType: commandType.return },
   ];
   const ADD_NEXT_ARG_LIST = [
       commandType.bgm,
@@ -137,7 +139,7 @@ var webgalParser = (function (exports) {
               argValue = undefined;
           }
           // 判断是不是语音参数
-          if (argName.toLowerCase().match(/.ogg|.mp3|.wav/)) {
+          if (argName.toLowerCase().match(/.ogg|.mp3|.wav|.opus/)) {
               returnArrayList.push({
                   key: 'vocal',
                   value: assetSetter(e, fileType.vocal),
@@ -462,7 +464,10 @@ var webgalParser = (function (exports) {
               args: [{ key: 'next', value: true }],
               sentenceAssets: [],
               subScene: [],
-              inlineComment: '', // 行内注释
+              inlineComment: '',
+              startLine: lineNumber,
+              endLine: lineNumber,
+              isLineBreakHolder: false,
           };
       }
       // 截取命令
@@ -513,92 +518,14 @@ var webgalParser = (function (exports) {
           args: args,
           sentenceAssets: sentenceAssets,
           subScene: subScene,
-          inlineComment: sentenceComment.trim(), // 行内注释
+          inlineComment: sentenceComment.trim(),
+          // 单行语句的行范围就是自己，多行语句的 endLine 由 sceneParser 回填
+          startLine: lineNumber,
+          endLine: lineNumber,
+          isLineBreakHolder: false,
       };
   };
 
-  /**
-   * 场景解析器
-   * @param rawScene 原始场景
-   * @param sceneName 场景名称
-   * @param sceneUrl 场景url
-   * @param assetsPrefetcher
-   * @param assetSetter
-   * @param ADD_NEXT_ARG_LIST
-   * @param SCRIPT_CONFIG_MAP
-   * @return {IScene} 解析后的场景
-   */
-  const sceneParser = (rawScene, sceneName, sceneUrl, assetsPrefetcher, assetSetter, ADD_NEXT_ARG_LIST, SCRIPT_CONFIG_MAP) => {
-      const rawSentenceList = rawScene.replaceAll('\r', '').split('\n'); // 原始句子列表
-      // 去分号留到后面去做了，现在注释要单独处理
-      const rawSentenceListWithoutEmpty = rawSentenceList;
-      // .map((sentence) => sentence.split(";")[0])
-      // .filter((sentence) => sentence.trim() !== "");
-      let assetsList = []; // 场景资源列表
-      let subSceneList = []; // 子场景列表
-      const sentenceList = rawSentenceListWithoutEmpty.map((sentence, index) => {
-          const returnSentence = scriptParser(sentence, assetSetter, ADD_NEXT_ARG_LIST, SCRIPT_CONFIG_MAP, index);
-          // 在这里解析出语句可能携带的资源和场景，合并到 assetsList 和 subSceneList
-          assetsList = [...assetsList, ...returnSentence.sentenceAssets];
-          subSceneList = [...subSceneList, ...returnSentence.subScene];
-          return returnSentence;
-      });
-      // 开始资源的预加载
-      assetsList = deduplicateAssets(assetsList);
-      assetsPrefetcher(assetsList);
-      return {
-          sceneName: sceneName,
-          sceneUrl: sceneUrl,
-          sentenceList: sentenceList,
-          assetsList: assetsList,
-          subSceneList: subSceneList, // 子场景列表
-      };
-  };
-  const deduplicateAssets = (assetsList) => {
-      const seenAssets = new Set();
-      return assetsList.filter((asset) => {
-          if (!asset || typeof asset.url !== 'string' || asset.url === '') {
-              return false;
-          }
-          const assetKey = `${asset.type}:${asset.url}`;
-          if (seenAssets.has(assetKey)) {
-              return false;
-          }
-          seenAssets.add(assetKey);
-          return true;
-      });
-  };
-
-  function scss2cssinjsParser(scssString) {
-      const [classNameStyles, others] = parseCSS(scssString);
-      return {
-          classNameStyles,
-          others,
-      };
-  }
-  /**
-   * GPT 4 写的，临时用，以后要重构！！！
-   * TODO：用人类智能重构，要是用着一直没问题，也不是不可以 trust AI
-   * @param css
-   */
-  function parseCSS(css) {
-      const result = {};
-      let specialRules = '';
-      let matches;
-      // 使用非贪婪匹配，尝试正确处理任意层次的嵌套
-      const classRegex = /\.([^{\s]+)\s*{((?:[^{}]*|{[^}]*})*)}/g;
-      const specialRegex = /(@[^{]+{\s*(?:[^{}]*{[^}]*}[^{}]*)+\s*})/g;
-      while ((matches = classRegex.exec(css)) !== null) {
-          const key = matches[1];
-          const value = matches[2].trim().replace(/\s*;\s*/g, ';\n');
-          result[key] = value;
-      }
-      while ((matches = specialRegex.exec(css)) !== null) {
-          specialRules += matches[1].trim() + '\n';
-      }
-      return [result, specialRules.trim()];
-  }
-
   /**
    * Preprocessor for scene text.
    *
@@ -628,13 +555,11 @@ var webgalParser = (function (exports) {
       let lastLineIsMultiline = false;
       let thisLineIsMultiline = false;
       for (const line of lines) {
-          thisLineIsMultiline = false;
-          if (canBeMultiline(line)) {
-              thisLineIsMultiline = true;
-          }
-          if (shouldNotBeMultiline(line, lastLineIsMultiline)) {
-              thisLineIsMultiline = false;
-          }
+          // 续行需要接到上一行，所以场景的第一行永远不会是续行。
+          thisLineIsMultiline =
+              processedLines.length > 0 &&
+                  canBeMultiline(line) &&
+                  !shouldNotBeMultiline(line, lastLineIsMultiline);
           if (thisLineIsMultiline) {
               processedLines[processedLines.length - 1] += '\\';
           }
@@ -681,7 +606,10 @@ var webgalParser = (function (exports) {
    */
   function sceneTextPreProcessPassTwo(lines) {
       const processedLines = [];
-      let currentMultilineContent = "";
+      // null 表示当前不在多行序列里。这里不能用空串来判断：
+      // 序列的首行本身可能就是空行（比如空行后面紧跟着一条续行），
+      // 那样整条序列会被静默丢弃，破坏「预处理前后行数一致」这个前提。
+      let currentMultilineContent = null;
       let placeHolderLines = [];
       function concat(line) {
           let trimmed = line.trim();
@@ -691,11 +619,16 @@ var webgalParser = (function (exports) {
           currentMultilineContent = currentMultilineContent + trimmed;
           placeHolderLines.push(placeholderLine(line));
       }
+      /** 把折叠好的整条语句连同补齐行数的占位行一起输出 */
+      function flushMultiline() {
+          processedLines.push(currentMultilineContent, ...placeHolderLines);
+          placeHolderLines = [];
+          currentMultilineContent = null;
+      }
       for (const line of lines) {
-          console.log(line);
           if (line.endsWith('\\')) {
               const trueLine = line.slice(0, -1);
-              if (currentMultilineContent === "") {
+              if (currentMultilineContent === null) {
                   // first line
                   currentMultilineContent = trueLine;
               }
@@ -705,19 +638,32 @@ var webgalParser = (function (exports) {
               }
               continue;
           }
-          if (currentMultilineContent !== "") {
+          if (currentMultilineContent !== null) {
               // end line
               concat(line);
-              processedLines.push(currentMultilineContent);
-              processedLines.push(...placeHolderLines);
-              placeHolderLines = [];
-              currentMultilineContent = "";
+              flushMultiline();
               continue;
           }
           processedLines.push(line);
       }
+      // 场景末行仍以 \ 结尾时循环里没有机会收尾，在这里把累积的内容补出去。
+      if (currentMultilineContent !== null) {
+          flushMultiline();
+      }
       return processedLines;
   }
+  /**
+   * 占位行的前缀。占位行本身是一条注释，引擎会空跑掉；
+   * 它的作用是让预处理后的行数与原始场景一致，从而保持
+   * 「解析后语句 index == 文件行号」这一不变量。
+   */
+  const WEBGAL_LINE_BREAK_MARK = ';_WEBGAL_LINE_BREAK_';
+  /**
+   * 判断预处理后的某一行是否是占位行，即它是上一条多行语句折叠掉的续行。
+   */
+  function isLineBreakPlaceholder(processedLine) {
+      return processedLine.startsWith(WEBGAL_LINE_BREAK_MARK);
+  }
   /**
    * Placeholder Line. Adding this line preserves the original number of lines
    * in the scene text, so that it can be compatible with the graphical editor.
@@ -726,70 +672,116 @@ var webgalParser = (function (exports) {
    * @returns The placeholder line
    */
   function placeholderLine(content = "") {
-      return ";_WEBGAL_LINE_BREAK_" + content;
+      return WEBGAL_LINE_BREAK_MARK + content;
+  }
+
+  /**
+   * 场景解析器
+   * @param rawScene 原始场景
+   * @param sceneName 场景名称
+   * @param sceneUrl 场景url
+   * @param assetsPrefetcher
+   * @param assetSetter
+   * @param ADD_NEXT_ARG_LIST
+   * @param SCRIPT_CONFIG_MAP
+   * @return {IScene} 解析后的场景
+   */
+  const sceneParser = (rawScene, sceneName, sceneUrl, assetsPrefetcher, assetSetter, ADD_NEXT_ARG_LIST, SCRIPT_CONFIG_MAP) => {
+      // 预处理把多行语句折叠进它的首行，并用占位行补齐被折叠掉的行，
+      // 因此这里的行数与原始场景严格一致，「语句 index == 文件行号」始终成立。
+      const rawSentenceList = sceneTextPreProcess(rawScene).split('\n'); // 原始句子列表
+      // 去分号留到后面去做了，现在注释要单独处理
+      const rawSentenceListWithoutEmpty = rawSentenceList;
+      // .map((sentence) => sentence.split(";")[0])
+      // .filter((sentence) => sentence.trim() !== "");
+      let assetsList = []; // 场景资源列表
+      let subSceneList = []; // 子场景列表
+      const sentenceList = rawSentenceListWithoutEmpty.map((sentence, index) => {
+          const returnSentence = scriptParser(sentence, assetSetter, ADD_NEXT_ARG_LIST, SCRIPT_CONFIG_MAP, index);
+          // 在这里解析出语句可能携带的资源和场景，合并到 assetsList 和 subSceneList
+          assetsList = [...assetsList, ...returnSentence.sentenceAssets];
+          subSceneList = [...subSceneList, ...returnSentence.subScene];
+          return returnSentence;
+      });
+      markMultilineRanges(sentenceList, rawSentenceList);
+      // 开始资源的预加载
+      assetsList = deduplicateAssets(assetsList);
+      assetsPrefetcher(assetsList);
+      return {
+          sceneName: sceneName,
+          sceneUrl: sceneUrl,
+          sentenceList: sentenceList,
+          assetsList: assetsList,
+          subSceneList: subSceneList, // 子场景列表
+      };
+  };
+  /**
+   * 回填多行语句的行范围。
+   *
+   * 预处理后，一条多行语句的完整内容都落在它的首行，紧跟其后的若干占位行
+   * 就是被折叠掉的续行。这里把占位行标记出来，并把首行语句的 endLine
+   * 推到最后一条续行，图形编辑器据此按整个行范围替换语句。
+   *
+   * @param sentenceList 解析后的语句列表
+   * @param processedLines 预处理后的行，与 sentenceList 一一对应
+   */
+  const markMultilineRanges = (sentenceList, processedLines) => {
+      let headIndex = -1; // 最近一条非占位语句的下标，即当前多行语句的首行
+      for (let index = 0; index < sentenceList.length; index++) {
+          if (!isLineBreakPlaceholder(processedLines[index])) {
+              headIndex = index;
+              continue;
+          }
+          sentenceList[index].isLineBreakHolder = true;
+          if (headIndex >= 0) {
+              sentenceList[headIndex].endLine = index;
+          }
+      }
+  };
+  const deduplicateAssets = (assetsList) => {
+      const seenAssets = new Set();
+      return assetsList.filter((asset) => {
+          if (!asset || typeof asset.url !== 'string' || asset.url === '') {
+              return false;
+          }
+          const assetKey = `${asset.type}:${asset.url}`;
+          if (seenAssets.has(assetKey)) {
+              return false;
+          }
+          seenAssets.add(assetKey);
+          return true;
+      });
+  };
+
+  function scss2cssinjsParser(scssString) {
+      const [classNameStyles, others] = parseCSS(scssString);
+      return {
+          classNameStyles,
+          others,
+      };
   }
-  // export function sceneTextPreProcess(sceneText: string): string {
-  //   const lines = sceneText.replaceAll('\r', '').split('\n');
-  //   const processedLines: string[] = [];
-  //   let lastNonMultilineIndex = -1;
-  //   let isInMultilineSequence = false;
-  //   function isMultiline(line: string): boolean {
-  //     if (!line.startsWith(' ')) return false;
-  //     const trimmedLine = line.trimStart();
-  //     return trimmedLine.startsWith('|') || trimmedLine.startsWith('-');
-  //   }
-  //   for (let i = 0; i < lines.length; i++) {
-  //     const line = lines[i];
-  //     if (line.trim() === '') {
-  //       // Empty line handling
-  //       if (isInMultilineSequence) {
-  //         // Check if the next line is a multiline line
-  //         let isStillInMulti = false;
-  //         for (let j = i + 1; j < lines.length; j++) {
-  //           const lookForwardLine = lines[j] || '';
-  //           // 遇到正常语句了，直接中断
-  //           if (lookForwardLine.trim() !== '' && !isMultiline(lookForwardLine)) {
-  //             isStillInMulti = false;
-  //             break;
-  //           }
-  //           // 必须找到后面接的是参数，并且中间没有遇到任何正常语句才行
-  //           if (lookForwardLine.trim() !== '' && isMultiline(lookForwardLine)) {
-  //             isStillInMulti = true;
-  //             break;
-  //           }
-  //         }
-  //         if (isStillInMulti) {
-  //           // Still within a multiline sequence
-  //           processedLines.push(';_WEBGAL_LINE_BREAK_');
-  //         } else {
-  //           // End of multiline sequence
-  //           isInMultilineSequence = false;
-  //           processedLines.push(line);
-  //         }
-  //       } else {
-  //         // Preserve empty lines outside of multiline sequences
-  //         processedLines.push(line);
-  //       }
-  //     } else if (isMultiline(line)) {
-  //       // Multiline statement handling
-  //       if (lastNonMultilineIndex >= 0) {
-  //         // Concatenate to the previous non-multiline statement
-  //         const trimedLine = line.trimStart();
-  //         const addBlank = trimedLine.startsWith('-') ? ' ' : '';
-  //         processedLines[lastNonMultilineIndex] += addBlank + trimedLine;
-  //       }
-  //       // Add the special comment line
-  //       processedLines.push(';_WEBGAL_LINE_BREAK_' + line);
-  //       isInMultilineSequence = true;
-  //     } else {
-  //       // Non-multiline statement handling
-  //       processedLines.push(line);
-  //       lastNonMultilineIndex = processedLines.length - 1;
-  //       isInMultilineSequence = false;
-  //     }
-  //   }
-  //   return processedLines.join('\n');
-  // }
+  /**
+   * GPT 4 写的，临时用，以后要重构！！！
+   * TODO：用人类智能重构，要是用着一直没问题，也不是不可以 trust AI
+   * @param css
+   */
+  function parseCSS(css) {
+      const result = {};
+      let specialRules = '';
+      let matches;
+      // 使用非贪婪匹配，尝试正确处理任意层次的嵌套
+      const classRegex = /\.([^{\s]+)\s*{((?:[^{}]*|{[^}]*})*)}/g;
+      const specialRegex = /(@[^{]+{\s*(?:[^{}]*{[^}]*}[^{}]*)+\s*})/g;
+      while ((matches = classRegex.exec(css)) !== null) {
+          const key = matches[1];
+          const value = matches[2].trim().replace(/\s*;\s*/g, ';\n');
+          result[key] = value;
+      }
+      while ((matches = specialRegex.exec(css)) !== null) {
+          specialRules += matches[1].trim() + '\n';
+      }
+      return [result, specialRules.trim()];
+  }
 
   class SceneParser {
       assetsPrefetcher;
@@ -836,7 +828,9 @@ var webgalParser = (function (exports) {
 
   exports.ADD_NEXT_ARG_LIST = ADD_NEXT_ARG_LIST;
   exports.SCRIPT_CONFIG = SCRIPT_CONFIG;
+  exports.WEBGAL_LINE_BREAK_MARK = WEBGAL_LINE_BREAK_MARK;
   exports.default = SceneParser;
+  exports.isLineBreakPlaceholder = isLineBreakPlaceholder;
   exports.sceneTextPreProcess = sceneTextPreProcess;
 
   Object.defineProperty(exports, '__esModule', { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webgal-parser",
-  "version": "4.6.2",
+  "version": "4.6.3-beta.2",
   "description": "WebGAL script parser",
   "scripts": {
     "test": "vitest",

package/src/config/scriptConfig.ts

@@ -39,6 +39,7 @@ export const SCRIPT_CONFIG = [
   { scriptString: 'applyStyle', scriptType: commandType.applyStyle },
   { scriptString: 'wait', scriptType: commandType.wait },
   { scriptString: 'callSteam', scriptType: commandType.callSteam },
+  { scriptString: 'return', scriptType: commandType.return },
 ];
 export const ADD_NEXT_ARG_LIST = [
   commandType.bgm,

package/src/index.ts

@@ -9,7 +9,11 @@ import { fileType } from './interface/assets';
 import { IAsset } from './interface/sceneInterface';
 import { sceneParser } from './sceneParser';
 import { IWebGALStyleObj, scss2cssinjsParser } from "./styleParser";
-import { sceneTextPreProcess } from "./sceneTextPreProcessor";
+import {
+  isLineBreakPlaceholder,
+  sceneTextPreProcess,
+  WEBGAL_LINE_BREAK_MARK,
+} from "./sceneTextPreProcessor";
 
 export default class SceneParser {
   private readonly SCRIPT_CONFIG_MAP: ConfigMap;
@@ -77,4 +81,4 @@ export default class SceneParser {
 }
 
 export { ADD_NEXT_ARG_LIST, SCRIPT_CONFIG };
-export { sceneTextPreProcess };
+export { sceneTextPreProcess, isLineBreakPlaceholder, WEBGAL_LINE_BREAK_MARK };

package/src/interface/runtimeInterface.ts

@@ -6,6 +6,8 @@ export interface sceneEntry {
   sceneName: string; // 场景名称
   sceneUrl: string; // 场景url
   continueLine: number; // 继续原场景的行号
+  locals?: Record<string, any>; // 该帧的局部变量
+  writeReturnTo?: string; // 返回值写回该帧的哪个变量
 }
 
 /**

package/src/interface/sceneInterface.ts

@@ -40,6 +40,7 @@ export enum commandType {
   applyStyle,
   wait,
   callSteam, // 调用Steam功能
+  return, // 从被调用的场景返回
 }
 
 /**
@@ -74,6 +75,15 @@ export interface ISentence {
   sentenceAssets: Array<IAsset>; // 语句携带的资源列表
   subScene: Array<string>; // 语句包含子场景列表
   inlineComment: string; // 行内注释
+  /**
+   * 本语句在原始场景文件中占据的行范围（0-based，含首尾）。
+   * 单行语句 startLine === endLine；多行语句 endLine 指向最后一条续行。
+   * 图形编辑器据此做「只替换被编辑语句所占的行」。
+   */
+  startLine: number;
+  endLine: number;
+  /** 本条是多行语句被折叠掉的续行占位，仅用于补齐行数，不应展示给用户 */
+  isLineBreakHolder: boolean;
 }
 
 /**

package/src/sceneParser.ts

@@ -7,6 +7,10 @@ import {
 import { scriptParser } from './scriptParser/scriptParser';
 import { fileType } from './interface/assets';
 import { ConfigMap } from './config/scriptConfig';
+import {
+  isLineBreakPlaceholder,
+  sceneTextPreProcess,
+} from './sceneTextPreProcessor';
 
 /**
  * 场景解析器
@@ -28,7 +32,9 @@ export const sceneParser = (
   ADD_NEXT_ARG_LIST: commandType[],
   SCRIPT_CONFIG_MAP: ConfigMap,
 ): IScene => {
-  const rawSentenceList = rawScene.replaceAll('\r', '').split('\n'); // 原始句子列表
+  // 预处理把多行语句折叠进它的首行，并用占位行补齐被折叠掉的行，
+  // 因此这里的行数与原始场景严格一致，「语句 index == 文件行号」始终成立。
+  const rawSentenceList = sceneTextPreProcess(rawScene).split('\n'); // 原始句子列表
 
   // 去分号留到后面去做了，现在注释要单独处理
   const rawSentenceListWithoutEmpty = rawSentenceList;
@@ -52,6 +58,8 @@ export const sceneParser = (
     },
   );
 
+  markMultilineRanges(sentenceList, rawSentenceList);
+
   // 开始资源的预加载
   assetsList = deduplicateAssets(assetsList);
   assetsPrefetcher(assetsList);
@@ -65,6 +73,33 @@ export const sceneParser = (
   };
 };
 
+/**
+ * 回填多行语句的行范围。
+ *
+ * 预处理后，一条多行语句的完整内容都落在它的首行，紧跟其后的若干占位行
+ * 就是被折叠掉的续行。这里把占位行标记出来，并把首行语句的 endLine
+ * 推到最后一条续行，图形编辑器据此按整个行范围替换语句。
+ *
+ * @param sentenceList 解析后的语句列表
+ * @param processedLines 预处理后的行，与 sentenceList 一一对应
+ */
+const markMultilineRanges = (
+  sentenceList: ISentence[],
+  processedLines: string[],
+) => {
+  let headIndex = -1; // 最近一条非占位语句的下标，即当前多行语句的首行
+  for (let index = 0; index < sentenceList.length; index++) {
+    if (!isLineBreakPlaceholder(processedLines[index])) {
+      headIndex = index;
+      continue;
+    }
+    sentenceList[index].isLineBreakHolder = true;
+    if (headIndex >= 0) {
+      sentenceList[headIndex].endLine = index;
+    }
+  }
+};
+
 const deduplicateAssets = (assetsList: IAsset[]): IAsset[] => {
   const seenAssets = new Set<string>();
   return assetsList.filter((asset) => {