koishipro-core.js 1.0.2 → 1.0.6

package/dist/index.d.ts

@@ -5,7 +5,6 @@ export * from './src/types';
 export * from './src/structs';
 export * from './src/adapters';
 export * from './src/constants';
-export * from './src/utility';
 export * from './src/vendor';
 export * from './src/sqljs-card-reader';
 export * from './src/play-yrp';

package/dist/index.mjs

@@ -1,5 +1,12 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // index.ts
-import { Buffer } from "buffer";
+import { Buffer as Buffer2 } from "buffer";
 
 // src/vendor/ocgcore-constants.ts
 var OcgcoreCommonConstants = {
@@ -394,11 +401,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;
@@ -680,13 +693,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) {
@@ -941,6 +947,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();
@@ -948,6 +957,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;
@@ -966,7 +1070,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);
@@ -1009,7 +1116,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) {
@@ -1018,99 +1125,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);
-    }
-    if (!this.scriptBufferPtr) {
-      this.scriptBufferPtr = this.ocgcoreModule._malloc(this.scriptBufferSize);
+  setScriptReader(reader, reset = false) {
+    if (reset) {
+      this.scriptReaders = [];
     }
-    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);
@@ -1193,6 +1230,54 @@ async function createOcgcoreWrapper(options = {}) {
 
 // src/adapters/script-readers.ts
 import JSZip from "jszip";
+
+// 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/adapters/script-readers.ts
 var SCRIPT_PREFIX = "./script/";
 function normalizePath(input) {
   let path = input.replace(/\\/g, "/");
@@ -1218,13 +1303,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;
@@ -1239,25 +1358,30 @@ function normalizeZipEntryName(name) {
   }
   return Array.from(names);
 }
-async function ZipReader(data) {
-  const zip = await JSZip.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 JSZip.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
@@ -2115,7 +2239,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) {
@@ -2307,18 +2431,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");
@@ -2347,10 +2459,11 @@ var playYrp = (ocgcoreWrapper, yrpInput) => {
 
 // index.ts
 if (typeof globalThis !== "undefined" && !globalThis.Buffer) {
-  globalThis.Buffer = Buffer;
+  globalThis.Buffer = Buffer2;
 }
 export {
   CardDataStruct,
+  DirReader,
   LEN_EMPTY,
   LEN_FAIL,
   LEN_HEADER,
@@ -2368,17 +2481,12 @@ export {
   ZipReader,
   createOcgcoreWrapper,
   createSqljsCardReader,
-  encodeUtf8,
   normalizeStartDuelOptions,
   parseCardQuery,
   parseFieldCardQuery,
   parseFieldInfo,
   parseRegistryDump,
   parseRegistryKeys,
-  playYrp,
-  readI32,
-  readU16,
-  readU32,
-  readU8
+  playYrp
 };
 //# sourceMappingURL=index.mjs.map