koishipro-core.js 1.0.2 → 1.0.6

package/dist/index.cjs

@@ -30,6 +30,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   CardDataStruct: () => CardDataStruct,
+  DirReader: () => DirReader,
   LEN_EMPTY: () => LEN_EMPTY,
   LEN_FAIL: () => LEN_FAIL,
   LEN_HEADER: () => LEN_HEADER,
@@ -47,18 +48,13 @@ __export(index_exports, {
   ZipReader: () => ZipReader,
   createOcgcoreWrapper: () => createOcgcoreWrapper,
   createSqljsCardReader: () => createSqljsCardReader,
-  encodeUtf8: () => encodeUtf8,
   normalizeStartDuelOptions: () => normalizeStartDuelOptions,
   parseCardQuery: () => parseCardQuery,
   parseFieldCardQuery: () => parseFieldCardQuery,
   parseFieldInfo: () => parseFieldInfo,
   parseRegistryDump: () => parseRegistryDump,
   parseRegistryKeys: () => parseRegistryKeys,
-  playYrp: () => playYrp,
-  readI32: () => readI32,
-  readU16: () => readU16,
-  readU32: () => readU32,
-  readU8: () => readU8
+  playYrp: () => playYrp
 });
 module.exports = __toCommonJS(index_exports);
 var import_buffer = require("buffer");
@@ -456,11 +452,17 @@ function readU32(buf, offset) {
   );
 }
 
-// src/adapters/ocgcore-parsers.ts
+// src/utility/utf8.ts
+var encoder = new TextEncoder();
 var decoder = new TextDecoder("utf-8");
+function encodeUtf8(value) {
+  return encoder.encode(value);
+}
 function decodeUtf8(value) {
   return decoder.decode(value);
 }
+
+// src/adapters/ocgcore-parsers.ts
 function parseCardInfo(payload) {
   let offset = 0;
   const flags = readI32(payload, offset) >>> 0;
@@ -742,13 +744,6 @@ function normalizeStartDuelOptions(options) {
   return ((duelRule & 65535) << 16 | duelOptions & 65535) >>> 0;
 }
 
-// src/utility/utf8.ts
-var encoder = new TextEncoder();
-var decoder2 = new TextDecoder("utf-8");
-function encodeUtf8(value) {
-  return encoder.encode(value);
-}
-
 // src/ocgcore-duel.ts
 var OcgcoreDuel = class {
   constructor(ocgcoreWrapper, duelPtr) {
@@ -1003,6 +998,9 @@ var OcgcoreWrapper = class {
     this.scriptReaderFunc = 0;
     this.cardReaderFunc = 0;
     this.messageHandlerFunc = 0;
+    this.scriptReaders = [];
+    this.cardReaders = [];
+    this.messageHandlers = [];
     this.encoder = new TextEncoder();
     this.decoder = new TextDecoder("utf-8");
     this.duels = /* @__PURE__ */ new Map();
@@ -1010,6 +1008,101 @@ var OcgcoreWrapper = class {
     this.heapView = new DataView(this.heapU8.buffer);
     this.scriptBufferSize = options?.scriptBufferSize ?? 1048576;
     this.logBufferSize = options?.logBufferSize ?? 1024;
+    this.scriptReaderFunc = this.createFunction((scriptPtr, lenPtr) => {
+      const scriptPath = this.getUTF8String(scriptPtr);
+      let content;
+      for (const reader of this.scriptReaders) {
+        try {
+          content = reader(scriptPath);
+        } catch {
+          content = null;
+        }
+        if (content != null) {
+          break;
+        }
+      }
+      if (content == null) {
+        return 0;
+      }
+      if (!this.scriptBufferPtr) {
+        this.scriptBufferPtr = this.ocgcoreModule._malloc(
+          this.scriptBufferSize
+        );
+      }
+      const bytes = typeof content === "string" ? this.encoder.encode(content) : content;
+      if (bytes.length > this.scriptBufferSize) {
+        this.ocgcoreModule._free(this.scriptBufferPtr);
+        this.scriptBufferPtr = this.ocgcoreModule._malloc(bytes.length);
+        this.scriptBufferSize = bytes.length;
+      }
+      this.heapU8.set(bytes, this.scriptBufferPtr);
+      this.heapView.setInt32(lenPtr, bytes.length, true);
+      return this.scriptBufferPtr;
+    }, "iii");
+    this.ocgcoreModule._set_script_reader(this.scriptReaderFunc);
+    this.cardReaderFunc = this.createFunction((cardId, cardDataPtr) => {
+      let data;
+      for (const reader of this.cardReaders) {
+        try {
+          data = reader(cardId);
+        } catch {
+          data = null;
+        }
+        if (data) {
+          break;
+        }
+      }
+      if (!data) {
+        return 0;
+      }
+      const CardDataCtor = CardDataStruct;
+      let buf;
+      if (data instanceof CardDataCtor) {
+        buf = CardDataStruct.raw(data);
+      } else {
+        const cardData = new CardDataCtor();
+        cardData.code = data.code;
+        cardData.alias = data.alias;
+        const targetSetcode = cardData.setcode;
+        targetSetcode.fill(0);
+        if (data.setcode instanceof Uint16Array && data.setcode.length === 16) {
+          targetSetcode.set(data.setcode);
+        } else {
+          for (let i = 0; i < 16 && i < data.setcode.length; i++) {
+            targetSetcode[i] = data.setcode[i];
+          }
+        }
+        cardData.type = data.type;
+        cardData.level = data.level;
+        cardData.attribute = data.attribute;
+        cardData.race = data.race;
+        cardData.attack = data.attack;
+        cardData.defense = data.defense;
+        cardData.lscale = data.lscale;
+        cardData.rscale = data.rscale;
+        cardData.linkMarker = data.linkMarker;
+        buf = CardDataStruct.raw(cardData);
+      }
+      this.heapU8.set(buf, cardDataPtr);
+      return 0;
+    }, "iii");
+    this.ocgcoreModule._set_card_reader(this.cardReaderFunc);
+    this.messageHandlerFunc = this.createFunction((duelPtr, messageType) => {
+      if (!this.logBufferPtr) {
+        this.logBufferPtr = this.ocgcoreModule._malloc(this.logBufferSize);
+      }
+      this.ocgcoreModule._get_log_message(duelPtr, this.logBufferPtr);
+      const message = this.getUTF8String(this.logBufferPtr);
+      const type = messageType === 1 ? "ScriptError" /* ScriptError */ : messageType === 2 ? "DebugMessage" /* DebugMessage */ : messageType;
+      const duel = this.getOrCreateDuel(duelPtr);
+      for (const handler of this.messageHandlers) {
+        try {
+          handler(duel, message, type);
+        } catch {
+        }
+      }
+    }, "iii");
+    this.ocgcoreModule._set_message_handler(this.messageHandlerFunc);
   }
   getUTF8String(ptr) {
     let length = 0;
@@ -1028,7 +1121,10 @@ var OcgcoreWrapper = class {
     const encoded = args.map(
       (item) => typeof item === "string" ? this.encoder.encode(item) : item
     );
-    const totalLength = encoded.reduce((acc, bytes) => acc + bytes.length + 1, 0);
+    const totalLength = encoded.reduce(
+      (acc, bytes) => acc + bytes.length + 1,
+      0
+    );
     if (totalLength > this.tmpStringBufferSize) {
       if (this.tmpStringBufferPtr) {
         this.ocgcoreModule._free(this.tmpStringBufferPtr);
@@ -1071,7 +1167,7 @@ var OcgcoreWrapper = class {
     this.ocgcoreModule._free(ptr);
     return this.getOrCreateDuel(duelPtr);
   }
-  defaultScriptReader(namePtr, dataPtr) {
+  _defaultScriptReader(namePtr, dataPtr) {
     return this.ocgcoreModule._default_script_reader(namePtr, dataPtr);
   }
   malloc(size) {
@@ -1080,99 +1176,29 @@ var OcgcoreWrapper = class {
   free(ptr) {
     this.ocgcoreModule._free(ptr);
   }
-  _setScriptReader(funcPtr) {
-    this.ocgcoreModule._set_script_reader(funcPtr);
-  }
-  _setCardReader(funcPtr) {
-    this.ocgcoreModule._set_card_reader(funcPtr);
-  }
-  _setMessageHandler(funcPtr) {
-    this.ocgcoreModule._set_message_handler(funcPtr);
-  }
-  stdioExit() {
+  _stdioExit() {
     this.ocgcoreModule.___stdio_exit();
   }
-  setScriptReader(reader) {
-    if (this.scriptReaderFunc) {
-      this.ocgcoreModule.removeFunction(this.scriptReaderFunc);
+  setScriptReader(reader, reset = false) {
+    if (reset) {
+      this.scriptReaders = [];
     }
-    if (!this.scriptBufferPtr) {
-      this.scriptBufferPtr = this.ocgcoreModule._malloc(this.scriptBufferSize);
-    }
-    this.scriptReaderFunc = this.createFunction((scriptPtr, lenPtr) => {
-      const scriptPath = this.getUTF8String(scriptPtr);
-      const content = reader(scriptPath);
-      if (content == null) {
-        return 0;
-      }
-      const bytes = typeof content === "string" ? this.encoder.encode(content) : content;
-      if (bytes.length > this.scriptBufferSize) {
-        this.ocgcoreModule._free(this.scriptBufferPtr);
-        this.scriptBufferPtr = this.ocgcoreModule._malloc(bytes.length);
-        this.scriptBufferSize = bytes.length;
-      }
-      this.heapU8.set(bytes, this.scriptBufferPtr);
-      this.heapView.setInt32(lenPtr, bytes.length, true);
-      return this.scriptBufferPtr;
-    }, "iii");
-    this._setScriptReader(this.scriptReaderFunc);
+    this.scriptReaders.push(reader);
+    return this;
   }
-  setCardReader(reader) {
-    if (this.cardReaderFunc) {
-      this.ocgcoreModule.removeFunction(this.cardReaderFunc);
+  setCardReader(reader, reset = false) {
+    if (reset) {
+      this.cardReaders = [];
     }
-    this.cardReaderFunc = this.createFunction((cardId, cardDataPtr) => {
-      const data = reader(cardId);
-      if (!data) {
-        return 0;
-      }
-      const CardDataCtor = CardDataStruct;
-      let buf;
-      if (data instanceof CardDataCtor) {
-        buf = CardDataStruct.raw(data);
-      } else {
-        const cardData = new CardDataCtor();
-        cardData.code = data.code;
-        cardData.alias = data.alias;
-        const targetSetcode = cardData.setcode;
-        targetSetcode.fill(0);
-        if (data.setcode instanceof Uint16Array && data.setcode.length === 16) {
-          targetSetcode.set(data.setcode);
-        } else {
-          for (let i = 0; i < 16 && i < data.setcode.length; i++) {
-            targetSetcode[i] = data.setcode[i];
-          }
-        }
-        cardData.type = data.type;
-        cardData.level = data.level;
-        cardData.attribute = data.attribute;
-        cardData.race = data.race;
-        cardData.attack = data.attack;
-        cardData.defense = data.defense;
-        cardData.lscale = data.lscale;
-        cardData.rscale = data.rscale;
-        cardData.linkMarker = data.linkMarker;
-        buf = CardDataStruct.raw(cardData);
-      }
-      this.heapU8.set(buf, cardDataPtr);
-      return 0;
-    }, "iii");
-    this._setCardReader(this.cardReaderFunc);
+    this.cardReaders.push(reader);
+    return this;
   }
-  setMessageHandler(handler) {
-    if (!this.logBufferPtr) {
-      this.logBufferPtr = this.ocgcoreModule._malloc(this.logBufferSize);
-    }
-    if (this.messageHandlerFunc) {
-      this.ocgcoreModule.removeFunction(this.messageHandlerFunc);
+  setMessageHandler(handler, reset = false) {
+    if (reset) {
+      this.messageHandlers = [];
     }
-    this.messageHandlerFunc = this.createFunction((duelPtr, messageType) => {
-      this.ocgcoreModule._get_log_message(duelPtr, this.logBufferPtr);
-      const message = this.getUTF8String(this.logBufferPtr);
-      const type = messageType === 1 ? "ScriptError" /* ScriptError */ : messageType === 2 ? "DebugMessage" /* DebugMessage */ : messageType;
-      handler(this.getOrCreateDuel(duelPtr), message, type);
-    }, "iii");
-    this._setMessageHandler(this.messageHandlerFunc);
+    this.messageHandlers.push(handler);
+    return this;
   }
   getOrCreateDuel(duelPtr) {
     const existing = this.duels.get(duelPtr);
@@ -1229,10 +1255,86 @@ function normalizeOcgcoreFactory(mod) {
   throw new Error("Invalid ocgcore factory module");
 }
 
+// src/utility/node-fs.ts
+function getNodeFs(noThrow = false) {
+  const req = typeof require !== "undefined" && require || Function('return typeof require !== "undefined" && require')();
+  if (!req) {
+    if (noThrow) {
+      return null;
+    }
+    throw new Error("Node.js fs module is not available.");
+  }
+  try {
+    return req("node:fs");
+  } catch {
+    try {
+      return req("fs");
+    } catch {
+      if (noThrow) {
+        return null;
+      }
+      throw new Error("Node.js fs module is not available.");
+    }
+  }
+}
+
+// src/utility/node-path.ts
+function getNodePath(noThrow = false) {
+  const req = typeof require !== "undefined" && require || Function('return typeof require !== "undefined" && require')();
+  if (!req) {
+    if (noThrow) {
+      return null;
+    }
+    throw new Error("Node.js path module is not available.");
+  }
+  try {
+    return req("node:path");
+  } catch {
+    try {
+      return req("path");
+    } catch {
+      if (noThrow) {
+        return null;
+      }
+      throw new Error("Node.js path module is not available.");
+    }
+  }
+}
+
 // src/load-ocgcore-factory.cjs.ts
 async function loadOcgcoreFactory() {
   const mod = require("./vendor/wasm_cjs/libocgcore.cjs");
-  return normalizeOcgcoreFactory(mod);
+  const baseFactory = normalizeOcgcoreFactory(mod);
+  const fs = getNodeFs(true);
+  if (!fs) {
+    return baseFactory;
+  }
+  const pathMod = getNodePath(true);
+  if (!pathMod) {
+    return baseFactory;
+  }
+  let defaultWasmBinary = null;
+  const wasmPath = pathMod.join(
+    __dirname,
+    "vendor",
+    "wasm_cjs",
+    "libocgcore.wasm"
+  );
+  if (fs.existsSync(wasmPath)) {
+    defaultWasmBinary = fs.readFileSync(wasmPath);
+  }
+  if (!defaultWasmBinary) {
+    return baseFactory;
+  }
+  return async (overrides) => {
+    if (!overrides?.wasmBinary && !overrides?.locateFile) {
+      return baseFactory({
+        ...overrides,
+        wasmBinary: defaultWasmBinary.buffer
+      });
+    }
+    return baseFactory(overrides);
+  };
 }
 
 // src/create-ocgcore-wrapper.ts
@@ -1278,13 +1380,47 @@ function buildCandidates(filename) {
   }
   return candidates;
 }
-function MapReader(map) {
+function joinPath(baseDir, relativePath) {
+  const pathMod = getNodePath();
+  if (pathMod) {
+    return pathMod.join(baseDir, relativePath);
+  }
+  const trimmedBase = baseDir.replace(/[/\\]+$/, "");
+  const trimmedRel = relativePath.replace(/^[/\\]+/, "");
+  return `${trimmedBase}/${trimmedRel}`;
+}
+function MapReader(...maps) {
   return (path) => {
     const filename = normalizePath(path);
+    if (!filename.toLowerCase().endsWith(".lua")) {
+      return null;
+    }
     const candidates = buildCandidates(filename);
     for (const candidate of candidates) {
-      if (map.has(candidate)) {
-        return map.get(candidate) ?? null;
+      for (const map of maps) {
+        if (map.has(candidate)) {
+          return map.get(candidate) ?? null;
+        }
+      }
+    }
+    return null;
+  };
+}
+function DirReader(...baseDirs) {
+  const fs = getNodeFs();
+  return (path) => {
+    const filename = normalizePath(path);
+    if (!filename.toLowerCase().endsWith(".lua")) {
+      return null;
+    }
+    const candidates = buildCandidates(filename);
+    for (const baseDir of baseDirs) {
+      for (const candidate of candidates) {
+        const normalized = candidate.startsWith("/") ? candidate.slice(1) : candidate;
+        const fullPath = joinPath(baseDir, normalized);
+        if (fs.existsSync(fullPath)) {
+          return fs.readFileSync(fullPath);
+        }
       }
     }
     return null;
@@ -1299,25 +1435,30 @@ function normalizeZipEntryName(name) {
   }
   return Array.from(names);
 }
-async function ZipReader(data) {
-  const zip = await import_jszip.default.loadAsync(data);
-  const map = /* @__PURE__ */ new Map();
-  const entries = Object.values(zip.files);
-  await Promise.all(
-    entries.map(async (entry) => {
-      if (entry.dir) {
-        return;
-      }
-      if (!entry.name.toLowerCase().endsWith(".lua")) {
-        return;
-      }
-      const content = await entry.async("uint8array");
-      for (const name of normalizeZipEntryName(entry.name)) {
-        map.set(name, content);
-      }
+async function ZipReader(...inputs) {
+  const maps = await Promise.all(
+    inputs.map(async (data) => {
+      const zip = await import_jszip.default.loadAsync(data);
+      const map = /* @__PURE__ */ new Map();
+      const entries = Object.values(zip.files);
+      await Promise.all(
+        entries.map(async (entry) => {
+          if (entry.dir) {
+            return;
+          }
+          if (!entry.name.toLowerCase().endsWith(".lua")) {
+            return;
+          }
+          const content = await entry.async("uint8array");
+          for (const name of normalizeZipEntryName(entry.name)) {
+            map.set(name, content);
+          }
+        })
+      );
+      return map;
     })
   );
-  return MapReader(map);
+  return MapReader(...maps);
 }
 
 // src/vendor/script-constants.ts
@@ -2175,7 +2316,7 @@ function toUint16ArrayFromSetcode(value) {
 }
 function mapRowToCardData(row) {
   const type = (row.type ?? 0) >>> 0;
-  let attack = row.atk ?? 0;
+  const attack = row.atk ?? 0;
   let defense = row.def ?? 0;
   let linkMarker = 0;
   if ((type & OcgcoreCommonConstants.TYPE_LINK) >>> 0 !== 0) {
@@ -2367,18 +2508,6 @@ var playYrp = (ocgcoreWrapper, yrpInput) => {
     duel.startDuel(yrp.opt >>> 0);
     while (true) {
       const { raw, status } = duel.process();
-      console.log(
-        "Duel process status:",
-        status,
-        "Message length:",
-        raw.length,
-        "Message:",
-        raw[0],
-        "Message string:",
-        Object.entries(OcgcoreCommonConstants).find(
-          ([k, v]) => v === raw[0] && k.startsWith("MSG_")
-        )?.[0] ?? "Unknown"
-      );
       messages.push(raw);
       if (raw.length > 0 && raw[0] === OcgcoreCommonConstants.MSG_RETRY) {
         throw new Error("Got MSG_RETRY");
@@ -2412,6 +2541,7 @@ if (typeof globalThis !== "undefined" && !globalThis.Buffer) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CardDataStruct,
+  DirReader,
   LEN_EMPTY,
   LEN_FAIL,
   LEN_HEADER,
@@ -2429,17 +2559,12 @@ if (typeof globalThis !== "undefined" && !globalThis.Buffer) {
   ZipReader,
   createOcgcoreWrapper,
   createSqljsCardReader,
-  encodeUtf8,
   normalizeStartDuelOptions,
   parseCardQuery,
   parseFieldCardQuery,
   parseFieldInfo,
   parseRegistryDump,
   parseRegistryKeys,
-  playYrp,
-  readI32,
-  readU16,
-  readU32,
-  readU8
+  playYrp
 });
 //# sourceMappingURL=index.cjs.map