webgal-parser 4.3.2

package/index.js

@@ -0,0 +1,17 @@
+"use strict";
+exports.__esModule = true;
+exports.SceneParser = void 0;
+var sceneParser_1 = require("./sceneParser");
+var SceneParser = /** @class */ (function () {
+    function SceneParser(assetsPrefetcher, assetSetter, ADD_NEXT_ARG_LIST, SCRIPT_CONFIG) {
+        this.assetsPrefetcher = assetsPrefetcher;
+        this.assetSetter = assetSetter;
+        this.ADD_NEXT_ARG_LIST = ADD_NEXT_ARG_LIST;
+        this.SCRIPT_CONFIG = SCRIPT_CONFIG;
+    }
+    SceneParser.prototype.parse = function (rawScene, sceneName, sceneUrl) {
+        return (0, sceneParser_1.sceneParser)(rawScene, sceneName, sceneUrl, this.assetsPrefetcher, this.assetSetter, this.ADD_NEXT_ARG_LIST, this.SCRIPT_CONFIG);
+    };
+    return SceneParser;
+}());
+exports.SceneParser = SceneParser;

package/index.ts

@@ -0,0 +1,25 @@
+import { IAsset } from "./interface/sceneInterface";
+import { fileType } from "./interface/assets";
+import { sceneParser } from "./sceneParser";
+
+export class SceneParser {
+
+  private assetsPrefetcher;
+  private assetSetter;
+  private ADD_NEXT_ARG_LIST;
+  private SCRIPT_CONFIG;
+
+  constructor(assetsPrefetcher: ((assetList: Array<IAsset>) => void),
+              assetSetter: (fileName: string, assetType: fileType) => string,
+              ADD_NEXT_ARG_LIST, SCRIPT_CONFIG) {
+    this.assetsPrefetcher = assetsPrefetcher;
+    this.assetSetter = assetSetter;
+    this.ADD_NEXT_ARG_LIST = ADD_NEXT_ARG_LIST;
+    this.SCRIPT_CONFIG = SCRIPT_CONFIG;
+  }
+
+  parse(rawScene: string, sceneName: string, sceneUrl: string
+  ) {
+    return sceneParser(rawScene, sceneName, sceneUrl, this.assetsPrefetcher, this.assetSetter, this.ADD_NEXT_ARG_LIST, this.SCRIPT_CONFIG);
+  }
+}

package/interface/assets.js

@@ -0,0 +1,16 @@
+"use strict";
+exports.__esModule = true;
+exports.fileType = void 0;
+/**
+ * 内置资源类型的枚举
+ */
+var fileType;
+(function (fileType) {
+    fileType[fileType["background"] = 0] = "background";
+    fileType[fileType["bgm"] = 1] = "bgm";
+    fileType[fileType["figure"] = 2] = "figure";
+    fileType[fileType["scene"] = 3] = "scene";
+    fileType[fileType["tex"] = 4] = "tex";
+    fileType[fileType["vocal"] = 5] = "vocal";
+    fileType[fileType["video"] = 6] = "video";
+})(fileType = exports.fileType || (exports.fileType = {}));

package/interface/assets.ts

@@ -0,0 +1,12 @@
+/**
+ * 内置资源类型的枚举
+ */
+export enum fileType {
+  background,
+  bgm,
+  figure,
+  scene,
+  tex,
+  vocal,
+  video,
+}

package/interface/runtimeInterface.js

@@ -0,0 +1,2 @@
+"use strict";
+exports.__esModule = true;

package/interface/runtimeInterface.ts

@@ -0,0 +1,9 @@
+/**
+ * 子场景结束后回到父场景的入口
+ * @interface sceneEntry
+ */
+export interface sceneEntry {
+  sceneName: string; // 场景名称
+  sceneUrl: string; // 场景url
+  continueLine: number; // 继续原场景的行号
+}

package/interface/sceneInterface.js

@@ -0,0 +1,32 @@
+"use strict";
+exports.__esModule = true;
+exports.commandType = void 0;
+var commandType;
+(function (commandType) {
+    commandType[commandType["say"] = 0] = "say";
+    commandType[commandType["changeBg"] = 1] = "changeBg";
+    commandType[commandType["changeFigure"] = 2] = "changeFigure";
+    commandType[commandType["bgm"] = 3] = "bgm";
+    commandType[commandType["video"] = 4] = "video";
+    commandType[commandType["pixi"] = 5] = "pixi";
+    commandType[commandType["pixiInit"] = 6] = "pixiInit";
+    commandType[commandType["intro"] = 7] = "intro";
+    commandType[commandType["miniAvatar"] = 8] = "miniAvatar";
+    commandType[commandType["changeScene"] = 9] = "changeScene";
+    commandType[commandType["choose"] = 10] = "choose";
+    commandType[commandType["end"] = 11] = "end";
+    commandType[commandType["setComplexAnimation"] = 12] = "setComplexAnimation";
+    commandType[commandType["setFilter"] = 13] = "setFilter";
+    commandType[commandType["label"] = 14] = "label";
+    commandType[commandType["jumpLabel"] = 15] = "jumpLabel";
+    commandType[commandType["chooseLabel"] = 16] = "chooseLabel";
+    commandType[commandType["setVar"] = 17] = "setVar";
+    commandType[commandType["if"] = 18] = "if";
+    commandType[commandType["callScene"] = 19] = "callScene";
+    commandType[commandType["showVars"] = 20] = "showVars";
+    commandType[commandType["unlockCg"] = 21] = "unlockCg";
+    commandType[commandType["unlockBgm"] = 22] = "unlockBgm";
+    commandType[commandType["filmMode"] = 23] = "filmMode";
+    commandType[commandType["setTextbox"] = 24] = "setTextbox";
+    commandType[commandType["setAnimation"] = 25] = "setAnimation";
+})(commandType = exports.commandType || (exports.commandType = {}));

package/interface/sceneInterface.ts

@@ -0,0 +1,98 @@
+/**
+ * 语句类型
+ */
+import { sceneEntry } from "./runtimeInterface";
+import { fileType } from "./assets";
+
+export enum commandType {
+  say, // 对话
+  changeBg, // 更改背景
+  changeFigure, // 更改立绘
+  bgm, // 更改背景音乐
+  video, // 播放视频
+  pixi, // pixi演出
+  pixiInit, // pixi初始化
+  intro, // 黑屏文字演示
+  miniAvatar, // 小头像
+  changeScene, // 切换场景
+  choose, // 分支选择
+  end, // 结束游戏
+  setComplexAnimation, // 动画演出
+  setFilter, // 设置效果
+  label, // 标签
+  jumpLabel, // 跳转标签
+  chooseLabel, // 选择标签
+  setVar, // 设置变量
+  if, // 条件跳转
+  callScene, // 调用场景
+  showVars,
+  unlockCg,
+  unlockBgm,
+  filmMode,
+  setTextbox,
+  setAnimation,
+}
+
+/**
+ * 单个参数接口
+ * @interface arg
+ */
+export interface arg {
+  key: string; // 参数键
+  value: string | boolean | number; // 参数值
+}
+
+/**
+ * 资源接口
+ * @interface IAsset
+ */
+export interface IAsset {
+  name: string; // 资源名称
+  type: fileType; // 资源类型
+  url: string; // 资源url
+  lineNumber: number; // 触发资源语句的行号
+}
+
+/**
+ * 单条语句接口
+ * @interface ISentence
+ */
+export interface ISentence {
+  command: commandType; // 语句类型
+  commandRaw: string; // 命令的原始内容，方便调试
+  content: string; // 语句内容
+  args: Array<arg>; // 参数列表
+  sentenceAssets: Array<IAsset>; // 语句携带的资源列表
+  subScene: Array<string>; // 语句包含子场景列表
+}
+
+/**
+ * 场景接口
+ * @interface IScene
+ */
+export interface IScene {
+  sceneName: string; // 场景名称
+  sceneUrl: string; // 场景url
+  sentenceList: Array<ISentence>; // 语句列表
+  assetsList: Array<IAsset>; // 资源列表
+  subSceneList: Array<string>; // 子场景的url列表
+}
+
+/**
+ * 当前的场景数据
+ * @interface ISceneData
+ */
+export interface ISceneData {
+  currentSentenceId: number; // 当前语句ID
+  sceneStack: Array<sceneEntry>; // 场景栈
+  currentScene: IScene; // 当前场景数据
+}
+
+/**
+ * 处理后的命令接口
+ * @interface parsedCommand
+ */
+export interface parsedCommand {
+  type: commandType;
+  additionalArgs: Array<arg>;
+}

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "webgal-parser",
+  "version": "4.3.2",
+  "description": "WebGAL script parser",
+  "scripts": {
+    "test": "node test/test.js"
+  },
+  "main": "index.js",
+  "author": "Mahiru <Mahiru_@outlook.com>",
+  "license": "MPL-2.0",
+  "dependencies": {
+    "cloudlogjs": "^1.0.11",
+    "lodash": "^4.17.21"
+  },
+  "devDependencies": {
+    "@types/lodash": "^4.14.189",
+    "ts-node": "^10.9.1"
+  }
+}

package/sceneParser.js

@@ -0,0 +1,53 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+exports.__esModule = true;
+exports.sceneParser = void 0;
+var scriptParser_1 = require("./scriptParser/scriptParser");
+var __ = require("lodash");
+/**
+ * 场景解析器
+ * @param rawScene 原始场景
+ * @param sceneName 场景名称
+ * @param sceneUrl 场景url
+ * @param assetsPrefetcher
+ * @param assetSetter
+ * @param ADD_NEXT_ARG_LIST
+ * @param SCRIPT_CONFIG
+ * @return {IScene} 解析后的场景
+ */
+var sceneParser = function (rawScene, sceneName, sceneUrl, assetsPrefetcher, assetSetter, ADD_NEXT_ARG_LIST, SCRIPT_CONFIG) {
+    var rawSentenceList = rawScene.split("\n"); // 原始句子列表
+    // 去除冒号后的内容
+    // 去除分号后的内容
+    var rawSentenceListWithoutEmpty = rawSentenceList
+        .map(function (sentence) { return sentence.split(";")[0]; })
+        .filter(function (sentence) { return sentence.trim() !== ""; });
+    var assetsList = []; // 场景资源列表
+    var subSceneList = []; // 子场景列表
+    var sentenceList = rawSentenceListWithoutEmpty.map(function (sentence) {
+        var returnSentence = (0, scriptParser_1.scriptParser)(sentence, assetSetter, ADD_NEXT_ARG_LIST, SCRIPT_CONFIG);
+        // 在这里解析出语句可能携带的资源和场景，合并到 assetsList 和 subSceneList
+        assetsList = __spreadArray(__spreadArray([], assetsList, true), returnSentence.sentenceAssets, true);
+        subSceneList = __spreadArray(__spreadArray([], subSceneList, true), returnSentence.subScene, true);
+        return returnSentence;
+    });
+    // 开始资源的预加载
+    assetsList = __.uniqWith(assetsList); // 去重
+    assetsPrefetcher(assetsList);
+    return {
+        sceneName: sceneName,
+        sceneUrl: sceneUrl,
+        sentenceList: sentenceList,
+        assetsList: assetsList,
+        subSceneList: subSceneList // 子场景列表
+    };
+};
+exports.sceneParser = sceneParser;

package/sceneParser.ts

@@ -0,0 +1,47 @@
+import { IAsset, IScene, ISentence } from "./interface/sceneInterface";
+import { scriptParser } from "./scriptParser/scriptParser";
+import * as __ from "lodash";
+import { fileType } from "./interface/assets";
+
+/**
+ * 场景解析器
+ * @param rawScene 原始场景
+ * @param sceneName 场景名称
+ * @param sceneUrl 场景url
+ * @param assetsPrefetcher
+ * @param assetSetter
+ * @param ADD_NEXT_ARG_LIST
+ * @param SCRIPT_CONFIG
+ * @return {IScene} 解析后的场景
+ */
+export const sceneParser = (rawScene: string, sceneName: string, sceneUrl: string
+  , assetsPrefetcher: ((assetList: Array<IAsset>) => void), assetSetter: (fileName: string, assetType: fileType) => string
+  , ADD_NEXT_ARG_LIST, SCRIPT_CONFIG): IScene => {
+  const rawSentenceList = rawScene.split("\n"); // 原始句子列表
+  // 去除冒号后的内容
+  // 去除分号后的内容
+  const rawSentenceListWithoutEmpty = rawSentenceList
+    .map((sentence) => sentence.split(";")[0])
+    .filter((sentence) => sentence.trim() !== "");
+  let assetsList: Array<IAsset> = []; // 场景资源列表
+  let subSceneList: Array<string> = []; // 子场景列表
+  const sentenceList: Array<ISentence> = rawSentenceListWithoutEmpty.map((sentence) => {
+    const returnSentence: ISentence = scriptParser(sentence, assetSetter, ADD_NEXT_ARG_LIST, SCRIPT_CONFIG);
+    // 在这里解析出语句可能携带的资源和场景，合并到 assetsList 和 subSceneList
+    assetsList = [...assetsList, ...returnSentence.sentenceAssets];
+    subSceneList = [...subSceneList, ...returnSentence.subScene];
+    return returnSentence;
+  });
+
+  // 开始资源的预加载
+  assetsList = __.uniqWith(assetsList); // 去重
+  assetsPrefetcher(assetsList);
+
+  return {
+    sceneName: sceneName, // 场景名称
+    sceneUrl: sceneUrl,
+    sentenceList: sentenceList, // 语句列表
+    assetsList: assetsList, // 资源列表
+    subSceneList: subSceneList // 子场景列表
+  };
+};

package/scriptParser/argsParser.js

@@ -0,0 +1,70 @@
+"use strict";
+exports.__esModule = true;
+exports.argsParser = void 0;
+var assets_1 = require("../interface/assets");
+/**
+ * 参数解析器
+ * @param argsRaw 原始参数字符串
+ * @param assetSetter
+ * @return {Array<arg>} 解析后的参数列表
+ */
+function argsParser(argsRaw, assetSetter) {
+    var returnArrayList = [];
+    // 处理参数
+    // 不要去空格
+    var newArgsRaw = argsRaw.replace(/ /g, " ");
+    // 分割参数列表
+    var rawArgsList = newArgsRaw.split(" -");
+    // 去除空字符串
+    rawArgsList = rawArgsList.filter(function (e) {
+        return e !== "";
+    });
+    rawArgsList.forEach(function (e) {
+        var argName = e.split("=")[0];
+        var argValue = e.split("=")[1];
+        // 判断是不是语音参数
+        if (e.match(/.ogg|.mp3|.wav/)) {
+            returnArrayList.push({
+                key: "vocal",
+                value: assetSetter(e, assets_1.fileType.vocal)
+            });
+        }
+        else {
+            // 判断是不是省略参数
+            if (argValue === undefined) {
+                returnArrayList.push({
+                    key: argName,
+                    value: true
+                });
+            }
+            else {
+                // 是字符串描述的布尔值
+                if (argValue === "true" || argValue === "false") {
+                    returnArrayList.push({
+                        key: argName,
+                        value: argValue === "true"
+                    });
+                }
+                else {
+                    // 是数字
+                    if (!isNaN(Number(argValue))) {
+                        returnArrayList.push({
+                            key: argName,
+                            value: Number(argValue)
+                        });
+                    }
+                    else {
+                        // 是普通参数
+                        returnArrayList.push({
+                            key: argName,
+                            value: argValue
+                        });
+                    }
+                }
+            }
+        }
+    });
+    return returnArrayList;
+}
+exports.argsParser = argsParser;
+;

package/scriptParser/argsParser.ts

@@ -0,0 +1,62 @@
+import { arg } from "../interface/sceneInterface";
+import { fileType } from "../interface/assets";
+/**
+ * 参数解析器
+ * @param argsRaw 原始参数字符串
+ * @param assetSetter
+ * @return {Array<arg>} 解析后的参数列表
+ */
+export function argsParser(argsRaw: string, assetSetter: (fileName: string, assetType: fileType) => string): Array<arg> {
+  const returnArrayList: Array<arg> = [];
+  // 处理参数
+  // 不要去空格
+  let newArgsRaw = argsRaw.replace(/ /g, " ");
+  // 分割参数列表
+  let rawArgsList: Array<string> = newArgsRaw.split(" -");
+  // 去除空字符串
+  rawArgsList = rawArgsList.filter((e) => {
+    return e !== "";
+  });
+  rawArgsList.forEach((e) => {
+    const argName = e.split("=")[0];
+    const argValue = e.split("=")[1];
+    // 判断是不是语音参数
+    if (e.match(/.ogg|.mp3|.wav/)) {
+      returnArrayList.push({
+        key: "vocal",
+        value: assetSetter(e, fileType.vocal)
+      });
+    } else {
+      // 判断是不是省略参数
+      if (argValue === undefined) {
+        returnArrayList.push({
+          key: argName,
+          value: true
+        });
+      } else {
+        // 是字符串描述的布尔值
+        if (argValue === "true" || argValue === "false") {
+          returnArrayList.push({
+            key: argName,
+            value: argValue === "true"
+          });
+        } else {
+          // 是数字
+          if (!isNaN(Number(argValue))) {
+            returnArrayList.push({
+              key: argName,
+              value: Number(argValue)
+            });
+          } else {
+            // 是普通参数
+            returnArrayList.push({
+              key: argName,
+              value: argValue
+            });
+          }
+        }
+      }
+    }
+  });
+  return returnArrayList;
+};

package/scriptParser/assetsScanner.js

@@ -0,0 +1,75 @@
+"use strict";
+exports.__esModule = true;
+exports.assetsScanner = void 0;
+var sceneInterface_1 = require("../interface/sceneInterface");
+var assets_1 = require("../interface/assets");
+/**
+ * 根据语句类型、语句内容、参数列表，扫描该语句可能携带的资源
+ * @param command 语句类型
+ * @param content 语句内容
+ * @param args 参数列表
+ * @return {Array<IAsset>} 语句携带的参数列表
+ */
+var assetsScanner = function (command, content, args) {
+    var hasVocalArg = false;
+    var returnAssetsList = [];
+    if (command === sceneInterface_1.commandType.say) {
+        args.forEach(function (e) {
+            if (e.key === 'vocal') {
+                hasVocalArg = true;
+                returnAssetsList.push({
+                    name: e.value,
+                    url: e.value,
+                    lineNumber: 0,
+                    type: assets_1.fileType.vocal
+                });
+            }
+        });
+    }
+    if (content === 'none' || content === '') {
+        return returnAssetsList;
+    }
+    // 处理语句携带的资源
+    if (command === sceneInterface_1.commandType.changeBg) {
+        returnAssetsList.push({
+            name: content,
+            url: content,
+            lineNumber: 0,
+            type: assets_1.fileType.background
+        });
+    }
+    if (command === sceneInterface_1.commandType.changeFigure) {
+        returnAssetsList.push({
+            name: content,
+            url: content,
+            lineNumber: 0,
+            type: assets_1.fileType.figure
+        });
+    }
+    if (command === sceneInterface_1.commandType.miniAvatar) {
+        returnAssetsList.push({
+            name: content,
+            url: content,
+            lineNumber: 0,
+            type: assets_1.fileType.figure
+        });
+    }
+    if (command === sceneInterface_1.commandType.video) {
+        returnAssetsList.push({
+            name: content,
+            url: content,
+            lineNumber: 0,
+            type: assets_1.fileType.video
+        });
+    }
+    if (command === sceneInterface_1.commandType.bgm) {
+        returnAssetsList.push({
+            name: content,
+            url: content,
+            lineNumber: 0,
+            type: assets_1.fileType.bgm
+        });
+    }
+    return returnAssetsList;
+};
+exports.assetsScanner = assetsScanner;

package/scriptParser/assetsScanner.ts

@@ -0,0 +1,72 @@
+import { arg, commandType, IAsset } from '../interface/sceneInterface';
+import { fileType } from '../interface/assets';
+
+/**
+ * 根据语句类型、语句内容、参数列表，扫描该语句可能携带的资源
+ * @param command 语句类型
+ * @param content 语句内容
+ * @param args 参数列表
+ * @return {Array<IAsset>} 语句携带的参数列表
+ */
+export const assetsScanner = (command: commandType, content: string, args: Array<arg>): Array<IAsset> => {
+  let hasVocalArg = false;
+  const returnAssetsList: Array<IAsset> = [];
+  if (command === commandType.say) {
+    args.forEach((e) => {
+      if (e.key === 'vocal') {
+        hasVocalArg = true;
+        returnAssetsList.push({
+          name: e.value as string,
+          url: e.value as string,
+          lineNumber: 0,
+          type: fileType.vocal,
+        });
+      }
+    });
+  }
+  if (content === 'none' || content === '') {
+    return returnAssetsList;
+  }
+  // 处理语句携带的资源
+  if (command === commandType.changeBg) {
+    returnAssetsList.push({
+      name: content,
+      url: content,
+      lineNumber: 0,
+      type: fileType.background,
+    });
+  }
+  if (command === commandType.changeFigure) {
+    returnAssetsList.push({
+      name: content,
+      url: content,
+      lineNumber: 0,
+      type: fileType.figure,
+    });
+  }
+  if (command === commandType.miniAvatar) {
+    returnAssetsList.push({
+      name: content,
+      url: content,
+      lineNumber: 0,
+      type: fileType.figure,
+    });
+  }
+  if (command === commandType.video) {
+    returnAssetsList.push({
+      name: content,
+      url: content,
+      lineNumber: 0,
+      type: fileType.video,
+    });
+  }
+  if (command === commandType.bgm) {
+    returnAssetsList.push({
+      name: content,
+      url: content,
+      lineNumber: 0,
+      type: fileType.bgm,
+    });
+  }
+  return returnAssetsList;
+};

package/scriptParser/commandParser.js

@@ -0,0 +1,60 @@
+"use strict";
+exports.__esModule = true;
+exports.commandParser = void 0;
+var sceneInterface_1 = require("../interface/sceneInterface");
+/**
+ * 处理命令
+ * @param commandRaw
+ * @param ADD_NEXT_ARG_LIST
+ * @param SCRIPT_CONFIG
+ * @return {parsedCommand} 处理后的命令
+ */
+var commandParser = function (commandRaw, ADD_NEXT_ARG_LIST, SCRIPT_CONFIG) {
+    var returnCommand = {
+        type: sceneInterface_1.commandType.say,
+        additionalArgs: []
+    };
+    // 开始处理命令内容
+    var type = getCommandType(commandRaw, ADD_NEXT_ARG_LIST, SCRIPT_CONFIG);
+    returnCommand.type = type;
+    // 如果是对话，加上额外的参数
+    if (type === sceneInterface_1.commandType.say) {
+        returnCommand.additionalArgs.push({
+            key: "speaker",
+            value: commandRaw
+        });
+    }
+    returnCommand = addNextArg(returnCommand, type, ADD_NEXT_ARG_LIST);
+    return returnCommand;
+};
+exports.commandParser = commandParser;
+/**
+ * 根据command原始值判断是什么命令
+ * @param command command原始值
+ * @param ADD_NEXT_ARG_LIST
+ * @param SCRIPT_CONFIG
+ * @return {commandType} 得到的command类型
+ */
+function getCommandType(command, ADD_NEXT_ARG_LIST, SCRIPT_CONFIG) {
+    // if (command.match(/if/)) {
+    //   return commandType.if;
+    // }
+    var commandMap = new Map();
+    SCRIPT_CONFIG.forEach(function (e) {
+        commandMap.set(e.scriptString, e.scriptType);
+    });
+    if (commandMap.has(command)) {
+        return commandMap.get(command);
+    }
+    else
+        return sceneInterface_1.commandType.say;
+}
+function addNextArg(commandToParse, thisCommandType, ADD_NEXT_ARG_LIST) {
+    if (ADD_NEXT_ARG_LIST.includes(thisCommandType)) {
+        commandToParse.additionalArgs.push({
+            key: "next",
+            value: true
+        });
+    }
+    return commandToParse;
+}