poi-plugin-kai-planner 1.0.0

package/src/services/planner/calcImproveSteps.js

@@ -0,0 +1,104 @@
+/* src/services/planner/calcImproveSteps.js */
+
+const { toInt } = require("../utils/toInt");
+
+function getEquipName(masterEquipsById, equipId) {
+  const row = masterEquipsById && masterEquipsById[String(equipId)];
+  if (row && row.api_name) return String(row.api_name);
+  return `UnknownEquip(${equipId})`;
+}
+
+function inStarRange(star, starFrom, starTo) {
+  if (starFrom == null && starTo == null) return true;
+  if (starFrom == null) return star <= toInt(starTo, 999);
+  if (starTo == null) return star >= toInt(starFrom, 0);
+  return star >= toInt(starFrom, 0) && star <= toInt(starTo, 999);
+}
+
+function normalizeItemRow(row, staticData, masterEquipsById) {
+  if (!row) return null;
+
+  if (row.item_equipment_id != null) {
+    const id = toInt(row.item_equipment_id, 0);
+    if (!id) return null;
+    return {
+      kind: "equipment",
+      id,
+      name: getEquipName(masterEquipsById, id),
+      count: toInt(row.count, 0),
+    };
+  }
+
+  if (row.item_material_key != null) {
+    const key = String(row.item_material_key);
+    const m = staticData.materialByKey ? staticData.materialByKey[key] : null;
+    return {
+      kind: "material",
+      key,
+      name: m && m.name ? String(m.name) : key,
+      count: toInt(row.count, 0),
+    };
+  }
+
+  return null;
+}
+
+function calcImproveSteps({
+  equipId,
+  fromStar,
+  toStar,
+  consumeIndexes,
+  staticData,
+  masterEquipsById,
+}) {
+  const eqId = toInt(equipId, 0);
+  const from = Math.max(0, toInt(fromStar, 0));
+  const to = Math.max(0, toInt(toStar, 0));
+  if (!eqId || to <= from) return [];
+
+  const stepById = consumeIndexes && consumeIndexes.stepById ? consumeIndexes.stepById : {};
+  const itemsByStepId = consumeIndexes && consumeIndexes.itemsByStepId ? consumeIndexes.itemsByStepId : {};
+  const eqName = getEquipName(masterEquipsById, eqId);
+
+  const steps = [];
+  for (let star = from; star < to; star += 1) {
+    const phase = star < 6 ? 0 : 1;
+    const stepId = `${eqId}_${phase}`;
+    const meta = stepById[stepId] || null;
+    const itemRows = itemsByStepId[stepId] || [];
+
+    const devEach = phase === 0 ? toInt(meta && meta.dev_min, 0) : toInt(meta && meta.dev_max, 0);
+    const screwEach = phase === 0 ? toInt(meta && meta.screw_min, 0) : toInt(meta && meta.screw_max, 0);
+
+    const costItems = [];
+    for (const r of itemRows) {
+      if (!r || r.is_deleted === true) continue;
+      if (!inStarRange(star, r.star_from, r.star_to)) continue;
+      const item = normalizeItemRow(r, staticData, masterEquipsById);
+      if (!item || !item.count) continue;
+      costItems.push(item);
+    }
+
+    steps.push({
+      kind: "improve",
+      equipId: eqId,
+      equipName: eqName,
+      fromStar: star,
+      toStar: star + 1,
+      phase,
+      step_id: stepId,
+      calcCost: {
+        dev: devEach,
+        screw: screwEach,
+        items: costItems,
+        policy: phase === 0 ? "improve_phase0_min" : "improve_phase1_max",
+      },
+    });
+  }
+
+  return steps;
+}
+
+module.exports = {
+  calcImproveSteps,
+};

package/src/services/planner/calcRemainingPlan.js

@@ -0,0 +1,169 @@
+/* src/services/planner/calcRemainingPlan.js */
+
+const { toInt } = require("../utils/toInt");
+const { calcRoutePlan } = require("./calcRoutePlan");
+const { calcImproveSteps } = require("./calcImproveSteps");
+const { calcUpgradeStep } = require("./calcUpgradeStep");
+const { summarizeShortage } = require("./summarizeShortage");
+
+function buildDisplaySteps(steps) {
+  return (steps || []).map((s, idx) => {
+    if (s.kind === "improve") {
+      return {
+        index: idx,
+        kind: "improve",
+        key: `improve:${s.equipId}:${s.fromStar}->${s.toStar}`,
+        label: `${s.equipName} +${s.fromStar} -> +${s.toStar}`,
+        equipId: s.equipId,
+        fromStar: s.fromStar,
+        toStar: s.toStar,
+      };
+    }
+    return {
+      index: idx,
+      kind: "upgrade",
+      key: `upgrade:${s.equipId}->${s.nextEquipId}`,
+      label: `${s.equipName} MAX -> ${s.nextEquipName} +0`,
+      equipId: s.equipId,
+      nextEquipId: s.nextEquipId,
+      routeKind: s.route_kind_required || null,
+    };
+  });
+}
+
+function calcTotals(steps) {
+  const totals = {
+    dev: 0,
+    screw: 0,
+    equipments: {},
+    materials: {},
+  };
+
+  for (const s of steps || []) {
+    const calcCost = s && s.calcCost ? s.calcCost : null;
+    if (!calcCost) continue;
+    totals.dev += toInt(calcCost.dev, 0);
+    totals.screw += toInt(calcCost.screw, 0);
+
+    for (const it of calcCost.items || []) {
+      if (!it || !it.kind) continue;
+      const amount = toInt(it.count != null ? it.count : it.need, 0);
+      if (amount <= 0) continue;
+
+      if (it.kind === "equipment") {
+        const k = String(it.id);
+        totals.equipments[k] = (totals.equipments[k] || 0) + amount;
+      } else if (it.kind === "material") {
+        const k = String(it.key);
+        totals.materials[k] = (totals.materials[k] || 0) + amount;
+      }
+    }
+  }
+
+  return totals;
+}
+
+function calcRemainingPlan({
+  staticData,
+  state,
+  apiId,
+  targetEquipId,
+  targetLevel,
+  consumeIndexes,
+  upgradeIndexes,
+  pathByPair,
+  masterEquipsById,
+  masterUseitemsById,
+  playerEquip,
+  playerHelpers,
+}) {
+  const current = playerEquip || null;
+  if (!current) return { ok: false, error: "playerEquip is required" };
+
+  const fromEquipId = toInt(current.api_slotitem_id, 0);
+  const fromStar = Math.max(0, toInt(current.api_level, 0));
+  const toEquipId = toInt(targetEquipId, 0);
+  const toStar = Math.max(0, Math.min(10, toInt(targetLevel, 10)));
+  if (!fromEquipId || !toEquipId) {
+    return { ok: false, error: "invalid input equip ids" };
+  }
+
+  const routePlan = calcRoutePlan({
+    fromEquipId,
+    toEquipId,
+    pathByPair,
+    upgradeIndexes,
+  });
+  if (!routePlan.ok) return { ok: false, error: routePlan.error || "route not found" };
+
+  const routeEquipIds = routePlan.routeEquipIds || [];
+  const transitions = routePlan.transitions || [];
+
+  const steps = [];
+  for (let i = 0; i < routeEquipIds.length; i += 1) {
+    const equipId = toInt(routeEquipIds[i], 0);
+    if (!equipId) continue;
+
+    const isLastEquip = i === routeEquipIds.length - 1;
+    const improveFromStar = i === 0 ? fromStar : 0;
+    const improveToStar = isLastEquip ? toStar : 10;
+
+    if (improveToStar > improveFromStar) {
+      steps.push(
+        ...calcImproveSteps({
+          equipId,
+          fromStar: improveFromStar,
+          toStar: improveToStar,
+          consumeIndexes,
+          staticData,
+          masterEquipsById,
+        })
+      );
+    }
+
+    if (!isLastEquip) {
+      const tr = transitions[i] || null;
+      if (!tr) continue;
+      const up = calcUpgradeStep({
+        fromEquipId: tr.fromEquipId,
+        toEquipId: tr.toEquipId,
+        routeKind: tr.routeKind,
+        upgradeIndexes,
+        staticData,
+        masterEquipsById,
+      });
+      if (up) steps.push(up);
+    }
+  }
+
+  const totals = calcTotals(steps);
+  const shortage = summarizeShortage({
+    totals,
+    state,
+    staticData,
+    masterEquipsById: masterEquipsById || {},
+    masterUseitemsById: masterUseitemsById || {},
+    playerHelpers: playerHelpers || {},
+  });
+
+  return {
+    ok: true,
+    inputs: {
+      apiId: toInt(apiId, 0),
+      fromEquipId,
+      fromStar,
+      toEquipId,
+      toStar,
+    },
+    route: routeEquipIds,
+    transitions,
+    steps,
+    displaySteps: buildDisplaySteps(steps),
+    totals,
+    shortage,
+  };
+}
+
+module.exports = {
+  calcRemainingPlan,
+};

package/src/services/planner/calcRoutePlan.js

@@ -0,0 +1,85 @@
+/* src/services/planner/calcRoutePlan.js */
+
+const { toInt } = require("../utils/toInt");
+const { buildUpgradePath } = require("./buildUpgradePath");
+
+function findUpgradeRow(upgradeIndexes, fromEquipId, toEquipId) {
+  if (!upgradeIndexes) return null;
+  const key = `${Number(fromEquipId)}|${Number(toEquipId)}`;
+  const rows = upgradeIndexes.targetByKey ? (upgradeIndexes.targetByKey[key] || []) : [];
+  if (!rows.length) return null;
+  return rows[0] || null; // confirmed by product rule: A->B only one route_kind
+}
+
+function buildTransitions(routeEquipIds, upgradeIndexes) {
+  const transitions = [];
+  for (let i = 0; i < routeEquipIds.length - 1; i += 1) {
+    const fromEquipId = toInt(routeEquipIds[i], 0);
+    const toEquipId = toInt(routeEquipIds[i + 1], 0);
+    if (!fromEquipId || !toEquipId) continue;
+
+    const row = findUpgradeRow(upgradeIndexes, fromEquipId, toEquipId);
+    transitions.push({
+      fromEquipId,
+      toEquipId,
+      routeKind: row && row.route_kind != null ? String(row.route_kind) : null,
+      upgradeId: row && row.upgrade_id != null ? Number(row.upgrade_id) : toEquipId,
+    });
+  }
+  return transitions;
+}
+
+function calcRoutePlan({ fromEquipId, toEquipId, pathByPair, upgradeIndexes }) {
+  const fromId = toInt(fromEquipId, 0);
+  const toId = toInt(toEquipId, 0);
+  if (!fromId || !toId) return { ok: false, error: "invalid route input", routeEquipIds: [], transitions: [] };
+
+  if (fromId === toId) {
+    return {
+      ok: true,
+      routeEquipIds: [fromId],
+      transitions: [],
+    };
+  }
+
+  const pairKey = `${fromId}|${toId}`;
+  const path = pathByPair && Array.isArray(pathByPair[pairKey]) ? pathByPair[pairKey] : null;
+  if (path && path.length >= 2) {
+    return {
+      ok: true,
+      routeEquipIds: path.map((x) => Number(x)),
+      transitions: buildTransitions(path, upgradeIndexes),
+    };
+  }
+
+  const fallback = buildUpgradePath({
+    equipId: fromId,
+    targetEquipId: toId,
+    upgradeIndexes,
+  });
+  const steps = (fallback && fallback.steps) || [];
+  if (!steps.length) {
+    return {
+      ok: false,
+      error: `no upgrade route from ${fromId} to ${toId}`,
+      routeEquipIds: [],
+      transitions: [],
+    };
+  }
+
+  const routeEquipIds = [fromId];
+  for (const s of steps) {
+    const nextId = toInt(s.toEquipId, 0);
+    if (nextId) routeEquipIds.push(nextId);
+  }
+
+  return {
+    ok: true,
+    routeEquipIds,
+    transitions: buildTransitions(routeEquipIds, upgradeIndexes),
+  };
+}
+
+module.exports = {
+  calcRoutePlan,
+};

package/src/services/planner/calcUpgradeStep.js

@@ -0,0 +1,85 @@
+/* src/services/planner/calcUpgradeStep.js */
+
+const { toInt } = require("../utils/toInt");
+
+function getEquipName(masterEquipsById, equipId) {
+  const row = masterEquipsById && masterEquipsById[String(equipId)];
+  if (row && row.api_name) return String(row.api_name);
+  return `UnknownEquip(${equipId})`;
+}
+
+function pickUpgradeRow(rows, routeKind) {
+  if (!rows || !rows.length) return null;
+  if (!routeKind) return rows[0];
+  return rows.find((r) => String(r.route_kind || "") === String(routeKind)) || rows[0];
+}
+
+function calcUpgradeStep({
+  fromEquipId,
+  toEquipId,
+  routeKind,
+  upgradeIndexes,
+  staticData,
+  masterEquipsById,
+}) {
+  const fromId = toInt(fromEquipId, 0);
+  const toId = toInt(toEquipId, 0);
+  if (!fromId || !toId) return null;
+
+  const key = `${fromId}|${toId}`;
+  const targetRows = upgradeIndexes && upgradeIndexes.targetByKey ? (upgradeIndexes.targetByKey[key] || []) : [];
+  const costRows = upgradeIndexes && upgradeIndexes.costByKey ? (upgradeIndexes.costByKey[key] || []) : [];
+  if (!targetRows.length) return null;
+
+  const targetRow = pickUpgradeRow(targetRows, routeKind);
+  if (!targetRow) return null;
+
+  const items = [];
+  for (const r of costRows) {
+    if (!r) continue;
+    const count = toInt(r.count, 0);
+    if (count <= 0) continue;
+
+    if (r.item_equipment_id != null) {
+      const id = toInt(r.item_equipment_id, 0);
+      if (!id) continue;
+      items.push({
+        kind: "equipment",
+        id,
+        name: getEquipName(masterEquipsById, id),
+        count,
+      });
+      continue;
+    }
+
+    if (r.item_material_key != null) {
+      const key2 = String(r.item_material_key);
+      const m = staticData.materialByKey ? staticData.materialByKey[key2] : null;
+      items.push({
+        kind: "material",
+        key: key2,
+        name: m && m.name ? String(m.name) : key2,
+        count,
+      });
+    }
+  }
+
+  return {
+    kind: "upgrade",
+    equipId: fromId,
+    equipName: getEquipName(masterEquipsById, fromId),
+    nextEquipId: toId,
+    nextEquipName: getEquipName(masterEquipsById, toId),
+    route_kind_required: targetRow.route_kind == null ? null : String(targetRow.route_kind),
+    calcCost: {
+      dev: toInt(targetRow.consume_development_max, 0),
+      screw: toInt(targetRow.consume_improvement_max, 0),
+      items,
+      policy: "upgrade_max",
+    },
+  };
+}
+
+module.exports = {
+  calcUpgradeStep,
+};

package/src/services/planner/detectCurrentPosition.js

@@ -0,0 +1,57 @@
+/* src/services/planner/detectCurrentPosition.js */
+
+function toInt(x) {
+  const n = Number(x);
+  return Number.isFinite(n) ? n : null;
+}
+
+function detectCurrentPosition({ state, plan }) {
+  const apiId = plan && plan.startApiId != null ? String(plan.startApiId) : "";
+  if (!apiId) {
+    return {
+      isValid: false,
+      reason: "missing_start_api_id",
+      apiId: "",
+      currentEquipId: null,
+      currentLevel: null,
+      reachedTargetEquip: false,
+      reachedTargetLevel: false,
+    };
+  }
+
+  const equips = state && state.info && state.info.equips;
+  const current = equips ? equips[apiId] : null;
+  if (!current) {
+    return {
+      isValid: false,
+      reason: "start_equip_not_found",
+      apiId,
+      currentEquipId: null,
+      currentLevel: null,
+      reachedTargetEquip: false,
+      reachedTargetLevel: false,
+    };
+  }
+
+  const currentEquipId = toInt(current.api_slotitem_id);
+  const currentLevel = toInt(current.api_level) || 0;
+  const targetEquipId = toInt(plan && plan.targetEquipId);
+  const targetLevel = toInt(plan && plan.targetLevel) || 0;
+
+  const reachedTargetEquip = currentEquipId != null && targetEquipId != null && currentEquipId === targetEquipId;
+  const reachedTargetLevel = reachedTargetEquip && currentLevel >= targetLevel;
+
+  return {
+    isValid: true,
+    reason: null,
+    apiId,
+    currentEquipId,
+    currentLevel,
+    reachedTargetEquip,
+    reachedTargetLevel,
+  };
+}
+
+module.exports = {
+  detectCurrentPosition,
+};

package/src/services/planner/summarizeShortage.js

@@ -0,0 +1,76 @@
+/* src/services/planner/summarizeShortage.js */
+
+const { toInt } = require("../utils/toInt");
+
+function getEquipName(masterEquipsById, equipId) {
+  const row = masterEquipsById && masterEquipsById[String(equipId)];
+  if (row && row.api_name) return String(row.api_name);
+  return `UnknownEquip(${equipId})`;
+}
+
+function summarizeShortage({
+  totals,
+  state,
+  staticData,
+  masterEquipsById,
+  masterUseitemsById,
+  playerHelpers,
+}) {
+  const countPlayerEquipByMasterId =
+    playerHelpers && typeof playerHelpers.countPlayerEquipByMasterId === "function"
+      ? playerHelpers.countPlayerEquipByMasterId
+      : () => 0;
+  const resolveMaterialKeyToUseitemId =
+    playerHelpers && typeof playerHelpers.resolveMaterialKeyToUseitemId === "function"
+      ? playerHelpers.resolveMaterialKeyToUseitemId
+      : () => null;
+  const getPlayerItemCountByUseitemId =
+    playerHelpers && typeof playerHelpers.getPlayerItemCountByUseitemId === "function"
+      ? playerHelpers.getPlayerItemCountByUseitemId
+      : () => 0;
+
+  const equipments = [];
+  for (const [equipId, need] of Object.entries(totals.equipments || {})) {
+    const needN = toInt(need, 0);
+    const ownedN = toInt(countPlayerEquipByMasterId(state, equipId), 0);
+    equipments.push({
+      kind: "equipment",
+      id: toInt(equipId, 0),
+      name: getEquipName(masterEquipsById, equipId),
+      need: needN,
+      owned: ownedN,
+      missing: Math.max(0, needN - ownedN),
+    });
+  }
+
+  const materials = [];
+  for (const [materialKey, need] of Object.entries(totals.materials || {})) {
+    const useitemId = resolveMaterialKeyToUseitemId(
+      { materialByKey: staticData.materialByKey, masterUseitemsById },
+      materialKey
+    );
+    const ownedN = useitemId ? toInt(getPlayerItemCountByUseitemId(state, useitemId), 0) : 0;
+    const needN = toInt(need, 0);
+    const m = staticData.materialByKey ? staticData.materialByKey[String(materialKey)] : null;
+    materials.push({
+      kind: "material",
+      key: String(materialKey),
+      name: m && m.name ? String(m.name) : String(materialKey),
+      need: needN,
+      useitemId: useitemId == null ? null : Number(useitemId),
+      owned: ownedN,
+      missing: Math.max(0, needN - ownedN),
+    });
+  }
+
+  return {
+    dev: { need: toInt(totals.dev, 0) },
+    screw: { need: toInt(totals.screw, 0) },
+    equipments,
+    materials,
+  };
+}
+
+module.exports = {
+  summarizeShortage,
+};

package/src/services/player/countPlayerEquipByMasterId.js

@@ -0,0 +1,27 @@
+/* src/services/player/countPlayerEquipByMasterId.js */
+
+function toInt(x) {
+  const n = Number(x);
+  return Number.isFinite(n) ? n : null;
+}
+
+/**
+ * 统计玩家持有“同图鉴装备(master equip id = api_slotitem_id)”数量
+ */
+function countPlayerEquipByMasterId(state, masterEquipId) {
+  const equips = state && state.info && state.info.equips;
+  if (!equips) return 0;
+
+  let c = 0;
+  const target = toInt(masterEquipId);
+  if (target == null) return 0;
+
+  for (const k of Object.keys(equips)) {
+    const e = equips[k];
+    if (!e) continue;
+    if ((toInt(e.api_slotitem_id) || 0) === target) c += 1;
+  }
+  return c;
+}
+
+module.exports = { countPlayerEquipByMasterId };

package/src/services/player/getEquipOwnerShip.js

@@ -0,0 +1,66 @@
+/* src/services/player/getEquipOwnerShip.js */
+
+function toInt(x) {
+  const n = Number(x);
+  return Number.isFinite(n) ? Math.trunc(n) : 0;
+}
+
+function getShipName(masterShipsById, masterShipId) {
+  if (!masterShipId) return null;
+  const row = masterShipsById && masterShipsById[String(masterShipId)];
+  return row && row.api_name ? String(row.api_name) : null;
+}
+
+function buildEquipOwnerShipIndex(state) {
+  const ships = (state && state.info && state.info.ships) || {};
+  const masterShipsById = (state && state.const && state.const.$ships) || {};
+  const index = {};
+
+  for (const k of Object.keys(ships)) {
+    const ship = ships[k];
+    if (!ship) continue;
+
+    const shipApiId = toInt(ship.api_id) || toInt(k);
+    const masterShipId = toInt(ship.api_ship_id);
+    const shipName = getShipName(masterShipsById, masterShipId) || `UnknownShip(${masterShipId || shipApiId})`;
+    const slots = Array.isArray(ship.api_slot) ? ship.api_slot : [];
+
+    for (const slotItem of slots) {
+      const equipApiId = toInt(slotItem);
+      if (equipApiId <= 0) continue;
+      const key = String(equipApiId);
+      if (!index[key]) {
+        index[key] = {
+          shipApiId,
+          masterShipId,
+          shipName,
+        };
+      }
+    }
+  }
+
+  return index;
+}
+
+function getEquipOwnerShipByApiId(equipOwnerShipIndex, equipApiId) {
+  if (!equipOwnerShipIndex || equipApiId == null) return null;
+  return equipOwnerShipIndex[String(equipApiId)] || null;
+}
+
+function buildPlanOwnerShipNameMap(plans, equipOwnerShipIndex) {
+  const map = {};
+  for (const p of plans || []) {
+    if (!p || p.startApiId == null) continue;
+    const planId = String(p.id || "");
+    if (!planId) continue;
+    const owner = getEquipOwnerShipByApiId(equipOwnerShipIndex, p.startApiId);
+    map[planId] = owner && owner.shipName ? owner.shipName : "";
+  }
+  return map;
+}
+
+module.exports = {
+  buildEquipOwnerShipIndex,
+  getEquipOwnerShipByApiId,
+  buildPlanOwnerShipNameMap,
+};

package/src/services/player/getPlayerData.js

@@ -0,0 +1,14 @@
+/* src/services/player/getPlayerData.js */
+
+/**
+ * poi: store.info.equips is object map, key=player equip api_id
+ */
+function getPlayerEquipByApiId(state, apiId) {
+  const equips = state && state.info && state.info.equips;
+  if (!equips) return null;
+  return equips[String(apiId)] || null;
+}
+
+module.exports = {
+  getPlayerEquipByApiId,
+};