poi-plugin-kai-planner 1.0.0

package/src/services/player/getPlayerItemCountByUseitemId.js

@@ -0,0 +1,45 @@
+// src/services/player/getPlayerItemCountByUseitemId.js
+// 读取玩家道具（useitem）数量。POI 的 state.info.items 在不同版本/场景下可能有不同形态，
+// 这里做一个兼容层，避免算出来全是 0。
+
+function getPlayerItemCountByUseitemId(poiState, useitemId) {
+  if (!poiState || !poiState.info) return 0;
+  const items = poiState.info.items || poiState.info.useitems;
+  if (!items) return 0;
+
+  const idStr = String(useitemId);
+
+  // 形态1：object map: { "77": { api_id: 77, api_count: 64 }, ... }
+  if (typeof items === "object" && !Array.isArray(items)) {
+    // shape A: keyed by api_id, e.g. { "77": { api_id:77, api_count:64 } }
+    const direct = items[idStr] || items[useitemId];
+    if (direct) {
+      const c = direct.api_count ?? direct.count;
+      const n = Number(c);
+      return Number.isFinite(n) ? n : 0;
+    }
+
+    // shape B: object map but keyed by something else; find by row.api_id
+    for (const k of Object.keys(items)) {
+      const row = items[k];
+      if (!row) continue;
+      if (String(row.api_id) !== idStr) continue;
+      const c = row.api_count ?? row.count;
+      const n = Number(c);
+      return Number.isFinite(n) ? n : 0;
+    }
+    return 0;
+  }
+
+  // 形态2：array: [{ api_id, api_count }, ...]
+  if (Array.isArray(items)) {
+    const row = items.find((x) => x && String(x.api_id) === idStr);
+    if (!row) return 0;
+    const n = Number(row.api_count ?? row.count);
+    return Number.isFinite(n) ? n : 0;
+  }
+
+  return 0;
+}
+
+module.exports = { getPlayerItemCountByUseitemId };

package/src/services/player/getReduxStateFromEnvWindow.js

@@ -0,0 +1,12 @@
+/* src/services/player/getReduxStateFromEnvWindow.js */
+
+function getReduxStateFromEnvWindow(envWindow) {
+  try {
+    if (envWindow && typeof envWindow.getStore === "function") return envWindow.getStore();
+    if (envWindow && envWindow.store && typeof envWindow.store.getState === "function") return envWindow.store.getState();
+    if (envWindow && envWindow.app && envWindow.app.store && typeof envWindow.app.store.getState === "function") return envWindow.app.store.getState();
+  } catch {}
+  return null;
+}
+
+module.exports = { getReduxStateFromEnvWindow };

package/src/services/player/resolveMaterialKeyToUseitemId.js

@@ -0,0 +1,54 @@
+/* src/services/player/resolveMaterialKeyToUseitemId.js */
+
+/**
+ * Resolve item_material_key -> master useitem api_id
+ *
+ * ✅ Supports TWO call styles:
+ * 1) resolveMaterialKeyToUseitemId({ materialByKey, masterUseitemsById }, materialKey)
+ * 2) resolveMaterialKeyToUseitemId(materialKey, staticData, masterUseitemsById)
+ */
+function resolveMaterialKeyToUseitemId(arg1, arg2, arg3) {
+  // Style (1)
+  if (arg1 && typeof arg1 === "object" && arg1.materialByKey) {
+    const { materialByKey, masterUseitemsById } = arg1;
+    const materialKey = arg2;
+    return _resolve(materialKey, materialByKey, masterUseitemsById);
+  }
+
+  // Style (2)
+  const materialKey = arg1;
+  const staticData = arg2 || {};
+  const masterUseitemsById = arg3 || {};
+  const materialByKey = staticData.materialByKey || buildMaterialByKey(staticData.material || []);
+  return _resolve(materialKey, materialByKey, masterUseitemsById);
+}
+
+function buildMaterialByKey(materialArr) {
+  const m = {};
+  for (const r of materialArr || []) {
+    if (!r || r.key == null) continue;
+    m[String(r.key)] = r;
+  }
+  return m;
+}
+
+function _resolve(materialKey, materialByKey, masterUseitemsById) {
+  if (!materialKey) return null;
+  const row = materialByKey && materialByKey[String(materialKey)];
+  if (!row) return null;
+
+  const materialName = row.name;
+  if (!materialName) return null;
+
+  // match by api_name
+  for (const idStr of Object.keys(masterUseitemsById || {})) {
+    const u = masterUseitemsById[idStr];
+    if (!u || !u.api_name) continue;
+    if (String(u.api_name) === String(materialName)) {
+      return Number(idStr);
+    }
+  }
+  return null;
+}
+
+module.exports = { resolveMaterialKeyToUseitemId };

package/src/services/static/indexes/buildConsumeIndexes.js

@@ -0,0 +1,28 @@
+/* src/services/static/indexes/buildConsumeIndexes.js */
+
+function buildConsumeIndexes(staticData) {
+  const stepById = {};
+  for (const r of staticData.improvementConsumeStep || []) {
+    if (!r || !r.id || r.is_deleted === true) continue;
+    // 统一字段命名：planner 层用 dev_*/screw_*（避免记忆歧义）
+    stepById[String(r.id)] = {
+      ...r,
+      dev_min: Number(r.consume_development_min || 0),
+      dev_max: Number(r.consume_development_max || 0),
+      screw_min: Number(r.consume_improvement_min || 0),
+      screw_max: Number(r.consume_improvement_max || 0),
+    };
+  }
+
+  const itemsByStepId = {};
+  for (const r of staticData.improvementConsumeItem || []) {
+    if (!r || !r.step_id || r.is_deleted === true) continue;
+    const k = String(r.step_id);
+    if (!itemsByStepId[k]) itemsByStepId[k] = [];
+    itemsByStepId[k].push(r);
+  }
+
+  return { stepById, itemsByStepId };
+}
+
+module.exports = { buildConsumeIndexes };

package/src/services/static/indexes/buildPathIndexes.js

@@ -0,0 +1,29 @@
+/* src/services/static/indexes/buildPathIndexes.js */
+
+function toInt(x) {
+  const n = Number(x);
+  return Number.isFinite(n) ? n : null;
+}
+
+function buildPathIndexes(staticData) {
+  // key: "from|to" -> path array (int[])
+  const pathByPair = {};
+
+  for (const r of staticData.equipmentUpgradePath || []) {
+    if (!r || !r.equipment_path || r.is_deleted === true) continue;
+
+    const arr = Array.isArray(r.equipment_path) ? r.equipment_path : [];
+    const path = arr.map((x) => toInt(x)).filter((x) => x != null);
+    if (path.length < 1) continue;
+
+    const from = toInt(r.from_equipment_id);
+    const to = toInt(r.to_equipment_id);
+    if (from == null || to == null) continue;
+
+    pathByPair[`${from}|${to}`] = path;
+  }
+
+  return { pathByPair };
+}
+
+module.exports = { buildPathIndexes };

package/src/services/static/indexes/buildUpgradeIndexes.js

@@ -0,0 +1,57 @@
+/* src/services/static/indexes/buildUpgradeIndexes.js */
+
+function buildUpgradeIndexes(staticData) {
+  const normalizeRouteKind = (rk) => {
+    if (rk === null || rk === undefined) return "__NULL__";
+    const s = String(rk).trim();
+    return s.length ? s : "__NULL__";
+  };
+
+  const pairKey = (equipmentId, upgradeId) => `${Number(equipmentId)}|${Number(upgradeId)}`;
+  const targetKey = (equipmentId, upgradeId) => pairKey(equipmentId, upgradeId);
+
+  const targetByKey = {};
+  const targetsByFromEquipId = {};
+  for (const r of staticData.improvementUpgradeTarget || []) {
+    if (!r || r.is_deleted === true) continue;
+    if (r.equipment_id == null || r.upgrade_id == null) continue;
+
+    const normalized = {
+      ...r,
+      __routeKindKey: normalizeRouteKind(r.route_kind),
+      // compatibility alias for older planner code
+      upgrade_to_equipment_id: r.upgrade_id,
+    };
+
+    const k = pairKey(r.equipment_id, r.upgrade_id);
+    if (!targetByKey[k]) targetByKey[k] = [];
+    targetByKey[k].push(normalized);
+
+    const fromKey = String(r.equipment_id);
+    if (!targetsByFromEquipId[fromKey]) targetsByFromEquipId[fromKey] = [];
+    targetsByFromEquipId[fromKey].push(normalized);
+  }
+
+  const costByKey = {};
+  for (const r of staticData.improvementUpgradeCost || []) {
+    if (!r || r.is_deleted === true) continue;
+    if (r.equipment_id == null || r.upgrade_id == null) continue;
+
+    const k = pairKey(r.equipment_id, r.upgrade_id);
+    if (!costByKey[k]) costByKey[k] = [];
+    costByKey[k].push(r);
+  }
+
+  return {
+    normalizeRouteKind,
+    pairKey,
+    targetsByPair: targetByKey,
+    costsByPair: costByKey,
+    targetsByFromEquipId,
+    targetKey,
+    targetByKey,
+    costByKey,
+  };
+}
+
+module.exports = { buildUpgradeIndexes };

package/src/services/static/version/dataSourceConfig.js

@@ -0,0 +1,25 @@
+/* src/services/static/version/dataSourceConfig.js */
+
+function readPackageJson() {
+  try {
+    // eslint-disable-next-line global-require
+    return require("../../../../package.json");
+  } catch {
+    return {};
+  }
+}
+
+function getDataSourceConfig() {
+  const pkg = readPackageJson();
+  const poiPlugin = pkg && pkg.poiPlugin ? pkg.poiPlugin : {};
+  const dataSource = poiPlugin && poiPlugin.dataSource ? poiPlugin.dataSource : {};
+
+  return {
+    manifestRawUrl: dataSource.manifestRawUrl || "",
+    rawBaseUrl: dataSource.rawBaseUrl || "",
+  };
+}
+
+module.exports = {
+  getDataSourceConfig,
+};

package/src/services/static/version/dataUpdateManager.js

@@ -0,0 +1,176 @@
+/* src/services/static/version/dataUpdateManager.js */
+
+const { getDataSourceConfig } = require("./dataSourceConfig");
+const { readMeta, writeMeta, writeCachedFile, readCachedJson } = require("./versionStore");
+
+const CHECK_INTERVAL_DAYS = 7;
+
+function nowMs() {
+  return Date.now();
+}
+
+function toMs(iso) {
+  if (!iso) return 0;
+  const t = new Date(iso).getTime();
+  return Number.isFinite(t) ? t : 0;
+}
+
+function parseVersion(v) {
+  return String(v || "")
+    .split(/[^0-9]+/)
+    .filter((x) => x !== "")
+    .map((x) => Number(x));
+}
+
+function compareVersion(a, b) {
+  const av = parseVersion(a);
+  const bv = parseVersion(b);
+  const len = Math.max(av.length, bv.length);
+  for (let i = 0; i < len; i += 1) {
+    const x = av[i] || 0;
+    const y = bv[i] || 0;
+    if (x !== y) return x - y;
+  }
+  return 0;
+}
+
+async function fetchJson(url) {
+  const res = await fetch(url, { method: "GET", cache: "no-store" });
+  if (!res.ok) throw new Error(`http ${res.status} for ${url}`);
+  return res.json();
+}
+
+async function fetchText(url) {
+  const res = await fetch(url, { method: "GET", cache: "no-store" });
+  if (!res.ok) throw new Error(`http ${res.status} for ${url}`);
+  return res.text();
+}
+
+function getDaySerial(d) {
+  if (!(d instanceof Date) || !Number.isFinite(d.getTime())) return 0;
+  // "Natural day" comparison: convert to UTC date number and compare day diff.
+  return Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate()) / (24 * 60 * 60 * 1000);
+}
+
+function shouldAutoCheck(meta) {
+  const lastIso = meta && meta.lastCheckAt ? String(meta.lastCheckAt) : "";
+  if (!lastIso) return true;
+  const last = new Date(lastIso);
+  if (!Number.isFinite(last.getTime())) return true;
+  const now = new Date();
+  const diffDays = getDaySerial(now) - getDaySerial(last);
+  return diffDays >= CHECK_INTERVAL_DAYS;
+}
+
+async function applyRemoteData(remoteManifest, rawBaseUrl) {
+  const files = Array.isArray(remoteManifest && remoteManifest.files) ? remoteManifest.files : [];
+  if (!files.length) {
+    throw new Error("remote manifest has no files");
+  }
+
+  // Always cache manifest itself.
+  writeCachedFile("data_manifest.json", JSON.stringify(remoteManifest, null, 2));
+
+  for (const f of files) {
+    const fileName = String(f);
+    const url = `${rawBaseUrl.replace(/\/+$/, "")}/${fileName}`;
+    const text = await fetchText(url);
+    writeCachedFile(fileName, text);
+  }
+}
+
+function getLocalDataVersion() {
+  const cachedManifest = readCachedJson("data_manifest.json");
+  if (cachedManifest && cachedManifest.data_version) return String(cachedManifest.data_version);
+
+  try {
+    // eslint-disable-next-line global-require
+    const bundled = require("../../../data/static/data_manifest.json");
+    return bundled && bundled.data_version ? String(bundled.data_version) : "0";
+  } catch {
+    return "0";
+  }
+}
+
+function getLocalManifestUpdatedAt() {
+  const cachedManifest = readCachedJson("data_manifest.json");
+  if (cachedManifest && cachedManifest.updated_at) return String(cachedManifest.updated_at);
+
+  try {
+    // eslint-disable-next-line global-require
+    const bundled = require("../../../data/static/data_manifest.json");
+    if (bundled && bundled.updated_at) return String(bundled.updated_at);
+  } catch {}
+  return null;
+}
+
+async function checkAndUpdateData({ force = false } = {}) {
+  const cfg = getDataSourceConfig();
+  const meta = readMeta();
+  const startCheckAt = new Date().toISOString();
+
+  if (!cfg.manifestRawUrl || !cfg.rawBaseUrl) {
+    const nextMeta = writeMeta({
+      lastCheckAt: startCheckAt,
+    });
+    return {
+      ok: false,
+      skipped: true,
+      reason: "data_source_not_configured",
+      meta: nextMeta,
+    };
+  }
+
+  if (!force && !shouldAutoCheck(meta)) {
+    return {
+      ok: true,
+      skipped: true,
+      reason: "within_weekly_window",
+      meta,
+    };
+  }
+
+  try {
+    const remoteManifest = await fetchJson(cfg.manifestRawUrl);
+    const remoteVersion = String(remoteManifest && remoteManifest.data_version ? remoteManifest.data_version : "0");
+    const localVersion = String(meta.lastVersion || getLocalDataVersion());
+    const hasNewer = compareVersion(remoteVersion, localVersion) > 0;
+
+    if (hasNewer) {
+      await applyRemoteData(remoteManifest, cfg.rawBaseUrl);
+    }
+
+    const nextMeta = writeMeta({
+      lastCheckAt: startCheckAt,
+      lastVersion: hasNewer ? remoteVersion : localVersion,
+      lastUpdateAt: hasNewer
+        ? (remoteManifest.updated_at || startCheckAt)
+        : (meta.lastUpdateAt || getLocalManifestUpdatedAt()),
+    });
+
+    return {
+      ok: true,
+      skipped: false,
+      updated: hasNewer,
+      remoteVersion,
+      localVersion,
+      meta: nextMeta,
+    };
+  } catch (e) {
+    const nextMeta = writeMeta({
+      lastCheckAt: startCheckAt,
+    });
+    return {
+      ok: false,
+      skipped: false,
+      error: String(e && (e.stack || e)),
+      meta: nextMeta,
+    };
+  }
+}
+
+module.exports = {
+  CHECK_INTERVAL_DAYS,
+  shouldAutoCheck,
+  checkAndUpdateData,
+};

package/src/services/static/version/versionStore.js

@@ -0,0 +1,205 @@
+/* src/services/static/version/versionStore.js */
+
+function getNodeModule(name) {
+  try {
+    if (typeof window !== "undefined" && typeof window.require === "function") {
+      return window.require(name);
+    }
+  } catch {}
+
+  try {
+    // eslint-disable-next-line global-require
+    return require(name);
+  } catch {
+    return null;
+  }
+}
+
+const fs = getNodeModule("fs");
+const path = getNodeModule("path");
+
+const LAST_CHECK_KEY = "kai_planner_data_last_check_at";
+const LAST_UPDATE_KEY = "kai_planner_data_last_update_at";
+const LAST_VERSION_KEY = "kai_planner_data_last_version";
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function canUseLocalStorage() {
+  try {
+    return typeof window !== "undefined" && window.localStorage != null;
+  } catch {
+    return false;
+  }
+}
+
+function getPluginRoot() {
+  if (!fs || !path) return null;
+  return path.resolve(__dirname, "../../../../");
+}
+
+function getDataDir() {
+  const root = getPluginRoot();
+  if (!root || !path) return null;
+  return path.join(root, "runtime_data", "static_data");
+}
+
+function getMetaPath() {
+  const dir = getDataDir();
+  if (!dir || !path) return null;
+  return path.join(dir, "meta.json");
+}
+
+function getCachePath() {
+  const dir = getDataDir();
+  if (!dir || !path) return null;
+  return path.join(dir, "cache");
+}
+
+function ensureDirs() {
+  if (!fs || !path) return false;
+  try {
+    const dataDir = getDataDir();
+    const cacheDir = getCachePath();
+    if (!dataDir || !cacheDir) return false;
+    fs.mkdirSync(dataDir, { recursive: true });
+    fs.mkdirSync(cacheDir, { recursive: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function readMetaFromFile() {
+  if (!fs) return null;
+  const fp = getMetaPath();
+  if (!fp) return null;
+  try {
+    if (!fs.existsSync(fp)) return null;
+    const s = fs.readFileSync(fp, "utf8");
+    if (!s) return null;
+    return JSON.parse(s);
+  } catch {
+    return null;
+  }
+}
+
+function writeMetaToFile(meta) {
+  if (!fs) return false;
+  if (!ensureDirs()) return false;
+  const fp = getMetaPath();
+  if (!fp) return false;
+  const tmp = `${fp}.tmp`;
+  try {
+    fs.writeFileSync(tmp, JSON.stringify(meta, null, 2), "utf8");
+    fs.renameSync(tmp, fp);
+    return true;
+  } catch {
+    try {
+      if (fs.existsSync(tmp)) fs.unlinkSync(tmp);
+    } catch {}
+    return false;
+  }
+}
+
+function readMetaFromLocalStorage() {
+  if (!canUseLocalStorage()) return null;
+  try {
+    return {
+      lastCheckAt: window.localStorage.getItem(LAST_CHECK_KEY) || null,
+      lastUpdateAt: window.localStorage.getItem(LAST_UPDATE_KEY) || null,
+      lastVersion: window.localStorage.getItem(LAST_VERSION_KEY) || null,
+    };
+  } catch {
+    return null;
+  }
+}
+
+function writeMetaToLocalStorage(meta) {
+  if (!canUseLocalStorage()) return false;
+  try {
+    window.localStorage.setItem(LAST_CHECK_KEY, meta.lastCheckAt || "");
+    window.localStorage.setItem(LAST_UPDATE_KEY, meta.lastUpdateAt || "");
+    window.localStorage.setItem(LAST_VERSION_KEY, meta.lastVersion || "");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function getDefaultMeta() {
+  return {
+    lastCheckAt: null,
+    lastUpdateAt: null,
+    lastVersion: null,
+    updatedAt: nowIso(),
+  };
+}
+
+function readMeta() {
+  return readMetaFromFile() || readMetaFromLocalStorage() || getDefaultMeta();
+}
+
+function writeMeta(patch) {
+  const prev = readMeta();
+  const next = {
+    ...prev,
+    ...(patch || {}),
+    updatedAt: nowIso(),
+  };
+  if (!writeMetaToFile(next)) {
+    writeMetaToLocalStorage(next);
+  }
+  return next;
+}
+
+function getCachedFilePath(fileName) {
+  if (!path) return null;
+  const base = getCachePath();
+  if (!base) return null;
+  return path.join(base, String(fileName));
+}
+
+function writeCachedFile(fileName, content) {
+  if (!fs) return false;
+  if (!ensureDirs()) return false;
+  const fp = getCachedFilePath(fileName);
+  if (!fp) return false;
+  const tmp = `${fp}.tmp`;
+  try {
+    fs.writeFileSync(tmp, content, "utf8");
+    fs.renameSync(tmp, fp);
+    return true;
+  } catch {
+    try {
+      if (fs.existsSync(tmp)) fs.unlinkSync(tmp);
+    } catch {}
+    return false;
+  }
+}
+
+function readCachedJson(fileName) {
+  if (!fs) return null;
+  const fp = getCachedFilePath(fileName);
+  if (!fp) return null;
+  try {
+    if (!fs.existsSync(fp)) return null;
+    const s = fs.readFileSync(fp, "utf8");
+    if (!s) return null;
+    return JSON.parse(s);
+  } catch {
+    return null;
+  }
+}
+
+module.exports = {
+  getDefaultMeta,
+  readMeta,
+  writeMeta,
+  getCachedFilePath,
+  writeCachedFile,
+  readCachedJson,
+  getDataDir,
+  getCachePath,
+};

package/src/services/utils/toInt.js

@@ -0,0 +1,11 @@
+// src/services/utils/toInt.js
+// 小工具：把输入安全转换成整数（NaN -> fallback）
+
+function toInt(v, fallback = 0) {
+  if (v === null || v === undefined) return fallback;
+  const n = Number(v);
+  if (!Number.isFinite(n)) return fallback;
+  return Math.trunc(n);
+}
+
+module.exports = { toInt };