poi-plugin-compass 0.1.5 → 0.1.6

package/data/normal-maps.json

@@ -1138,9 +1138,10 @@
       "name": "拉包尔方面海域",
       "start": "1",
       "boss": "G",
-      "manualNodes": ["I"],
+      "manualNodes": ["I", "O"],
       "manualOutcomes": {
-        "I": [{ "to": "J", "probability": null }, { "to": "O", "probability": null }]
+        "I": [{ "to": "J", "probability": null }, { "to": "O", "probability": null }],
+        "O": [{ "to": "P", "probability": null }, { "to": "Q", "probability": null }]
       },
       "sourceRefs": [
         { "kind": "kcwiki", "url": "https://zh.kcwiki.cn/wiki/南方海域/5-6", "checkedAt": "2026-09-11" },
@@ -1186,7 +1187,7 @@
         { "id": "5-6-L-fallback", "node": "L", "priority": 999, "predicate": { "kind": "always", "label": "索敌不足" }, "outcomes": [{ "to": "M", "probability": 1 }], "confidence": "approximate" },
         { "id": "5-6-I-p2", "node": "I", "priority": 10, "predicate": { "kind": "phase", "phase": "P2", "label": "P2：向下前往 J" }, "outcomes": [{ "to": "J", "probability": 1 }], "confidence": "verified" },
         { "id": "5-6-I-p3", "node": "I", "priority": 20, "predicate": { "kind": "phase", "phase": "P3", "label": "P3：向上前往 O" }, "outcomes": [{ "to": "O", "probability": 1 }], "confidence": "verified" },
-        { "id": "5-6-O-fixed", "node": "O", "priority": 1, "predicate": { "kind": "always", "label": "固定前往 Q" }, "outcomes": [{ "to": "Q", "probability": 1 }], "confidence": "parsed" },
+        { "id": "5-6-O-manual", "node": "O", "priority": 1, "predicate": { "kind": "always", "label": "能动分歧：选择 P / Q" }, "outcomes": [{ "to": "P", "probability": null }, { "to": "Q", "probability": null }], "confidence": "verified" },
         { "id": "5-6-Q-locked", "node": "Q", "priority": 10, "predicate": { "kind": "flag", "flag": "qRoutes", "value": false, "label": "Q-U/Q-W 路线未解锁" }, "outcomes": [{ "to": "Q2", "probability": 1 }], "confidence": "verified" },
         { "id": "5-6-Q-fast-plus", "node": "Q", "priority": 20, "predicate": { "kind": "speed", "mode": "highPlus" }, "outcomes": [{ "to": "W", "probability": 1 }], "confidence": "verified" },
         { "id": "5-6-Q-high-light", "node": "Q", "priority": 30, "predicate": { "kind": "all", "predicates": [{ "kind": "count", "category": "CL", "op": ">=", "value": 1 }, { "kind": "count", "category": "DD", "op": ">=", "value": 3 }, { "kind": "speed", "mode": "allHigh" }] }, "outcomes": [{ "to": "W", "probability": 1 }], "confidence": "verified" },

package/index.js

@@ -50,6 +50,13 @@ const MAP_PHASES = {
   ],
 }
 
+const MAP_ROUTE_OPTIONS = {
+  '5-6': [
+    { id: 'locked', label: '未解锁', flags: { qRoutes: false } },
+    { id: 'unlocked', label: '已解锁', flags: { qRoutes: true } },
+  ],
+}
+
 function phaseOptionsForMap(mapId) {
   return MAP_PHASES[mapId] || []
 }
@@ -58,10 +65,25 @@ function phaseOptionForMap(mapId, phaseId) {
   return phaseOptionsForMap(mapId).find((phase) => phase.id === phaseId) || phaseOptionsForMap(mapId)[0] || null
 }
 
-function phaseFlags(mapId, phaseId) {
+function routeOptionsForMap(mapId) {
+  return MAP_ROUTE_OPTIONS[mapId] || []
+}
+
+function defaultRouteOptionId(mapId) {
+  return routeOptionsForMap(mapId)[0]?.id || null
+}
+
+function routeOptionForMap(mapId, routeOptionId) {
+  return routeOptionsForMap(mapId).find((option) => option.id === routeOptionId)
+    || routeOptionsForMap(mapId)[0]
+    || null
+}
+
+function phaseFlags(mapId, phaseId, routeOptionId) {
   const flags = {}
   if (mapId === '7-3') flags.phase1 = phaseId === 'P1'
-  if (mapId === '5-6') flags.qRoutes = phaseId === 'P3'
+  const routeOption = routeOptionForMap(mapId, routeOptionId)
+  if (routeOption?.flags) Object.assign(flags, routeOption.flags)
   return flags
 }
 
@@ -662,11 +684,14 @@ class Compass extends React.Component {
     const initialDeckId = [1, 2, 3, 4].includes(Number(preferences.deckId)) ? Number(preferences.deckId) : 1
     const preferredPhaseId = preferences.phaseByMap?.[initialMapId] ?? preferences.phaseId
     const initialPhaseId = phaseOptionForMap(initialMapId, preferredPhaseId)?.id || null
+    const initialRouteOptionId = routeOptionForMap(initialMapId, preferences.routeOptionByMap?.[initialMapId])?.id
+      || defaultRouteOptionId(initialMapId)
     const initialExportPreferences = storedExportPreferencesForView(preferences, initialMapId, initialPhaseId, initialDeckId)
     this.state = {
       deckId: initialDeckId,
       mapId: initialMapId,
       phaseId: initialPhaseId,
+      routeOptionId: initialRouteOptionId,
       selectedNode: pluginState.currentNode || null,
       selectedEdge: null,
       overrides: storedOverridesForView(preferences, initialMapId, initialPhaseId, initialDeckId),
@@ -717,11 +742,14 @@ class Compass extends React.Component {
       }
       const phaseByMap = isRecord(previous.phaseByMap) ? { ...previous.phaseByMap } : {}
       phaseByMap[this.state.mapId] = this.state.phaseId
+      const routeOptionByMap = isRecord(previous.routeOptionByMap) ? { ...previous.routeOptionByMap } : {}
+      if (this.state.routeOptionId) routeOptionByMap[this.state.mapId] = this.state.routeOptionId
       storage.setItem(PREFERENCES_STORAGE_KEY, JSON.stringify({
         ...previous,
         mapId: this.state.mapId,
         phaseId: this.state.phaseId,
         phaseByMap,
+        routeOptionByMap,
         deckId: this.state.deckId,
         probabilityFormat: this.state.probabilityFormat,
         showEstimatedAir: this.state.showEstimatedAir,
@@ -743,10 +771,13 @@ class Compass extends React.Component {
   selectMap(mapId) {
     const preferences = readCompassPreferences()
     const phaseId = phaseOptionForMap(mapId, preferences.phaseByMap?.[mapId])?.id || null
+    const routeOptionId = routeOptionForMap(mapId, preferences.routeOptionByMap?.[mapId])?.id
+      || defaultRouteOptionId(mapId)
     const exportPreferences = storedExportPreferencesForView(preferences, mapId, phaseId, this.state.deckId)
     this.setState({
       mapId,
       phaseId,
+      routeOptionId,
       selectedNode: null,
       selectedEdge: null,
       overrides: storedOverridesForView(preferences, mapId, phaseId, this.state.deckId),
@@ -800,6 +831,11 @@ class Compass extends React.Component {
     this.setState({ phaseId, selectedNode: null, selectedEdge: null, overrides, ...exportPreferences, exportError: null })
   }
 
+  selectRouteOption(routeOptionId) {
+    if (!routeOptionForMap(this.state.mapId, routeOptionId)) return
+    this.setState({ routeOptionId, selectedNode: null, selectedEdge: null, exportRoute: null, exportError: null })
+  }
+
   selectNode(node) {
     this.setState({ selectedNode: node, selectedEdge: null })
   }
@@ -1299,7 +1335,7 @@ class Compass extends React.Component {
       admiralCoefficient: mapLosConfig.admiralCoefficient,
       passedNodes: pluginState.currentMapId === this.state.mapId ? pluginState.passedNodes : [],
       phase: phase?.id || null,
-      flags: phaseFlags(this.state.mapId, phase?.id),
+      flags: phaseFlags(this.state.mapId, phase?.id, this.state.routeOptionId),
     })
     const geometry = mapGeometry(this.state.mapId)
     const displayMapDefinition = phase?.boss
@@ -1342,6 +1378,18 @@ class Compass extends React.Component {
             }, option.label)),
           )
           : null,
+        routeOptionsForMap(this.state.mapId).length > 1
+          ? h('div', { className: 'compass-phase-group', role: 'group', 'aria-label': '路线解锁状态' },
+            h('span', { className: 'compass-option-label' }, 'Q路线'),
+            routeOptionsForMap(this.state.mapId).map((option) => h('button', {
+              key: option.id,
+              type: 'button',
+              className: routeOptionForMap(this.state.mapId, this.state.routeOptionId)?.id === option.id ? 'is-active' : '',
+              'aria-pressed': routeOptionForMap(this.state.mapId, this.state.routeOptionId)?.id === option.id,
+              onClick: () => this.selectRouteOption(option.id),
+            }, option.label)),
+          )
+          : null,
         h('div', { className: 'compass-option-group', role: 'group', 'aria-label': '概率标签格式' },
           h('span', { className: 'compass-option-label' }, '概率'),
           ...[
@@ -1423,6 +1471,8 @@ exports.__test = {
   nodeIconUrl,
   losConfig: losCatalog.maps,
   phaseOptionsForMap,
+  routeOptionsForMap,
+  routeOptionForMap,
   pluginState,
   routeEdges,
   ruleRows,

package/logic.js

@@ -290,6 +290,17 @@ function hasPhaseRules(mapDefinition, node) {
   return rulesForNode(mapDefinition, node).some((rule) => containsPhasePredicate(rule.predicate))
 }
 
+function containsVisitedPredicate(predicate) {
+  if (!predicate || typeof predicate !== 'object') return false
+  if (predicate.kind === 'visited') return true
+  if (Array.isArray(predicate.predicates) && predicate.predicates.some(containsVisitedPredicate)) return true
+  return containsVisitedPredicate(predicate.predicate)
+}
+
+function hasVisitedRules(mapDefinition) {
+  return (mapDefinition?.rules || []).some((rule) => containsVisitedPredicate(rule.predicate))
+}
+
 function selectRouteRule(mapDefinition, node, context) {
   const rules = rulesForNode(mapDefinition, node)
   for (const rule of rules) {
@@ -562,6 +573,74 @@ function propagateProbability(start, decisions) {
   }
 }
 
+function propagatePathProbability(start, mapDefinition, context = {}, overrides = {}) {
+  const reach = {}
+  const edgeMass = {}
+  const unknownNodes = new Set()
+  const unknownEdges = new Set()
+  const estimatedNodes = new Set()
+  const estimatedEdges = new Set()
+  const decisionVariants = new Map()
+  let visits = 0
+
+  function rememberDecision(node, passedNodes, decision) {
+    const variants = decisionVariants.get(node) || []
+    const key = passedNodes.join('\u0000')
+    if (!variants.some((variant) => variant.key === key)) {
+      variants.push({ key, passedNodes, decision })
+      decisionVariants.set(node, variants)
+    }
+  }
+
+  function walk(node, passedNodes, mass, path, estimatedPath) {
+    if (!Number.isFinite(mass) || mass <= 0) return
+    if (++visits > 10000) {
+      unknownNodes.add(node)
+      return
+    }
+    reach[node] = number(reach[node]) + mass
+    if (estimatedPath) estimatedNodes.add(node)
+    if (path.has(node)) {
+      unknownNodes.add(node)
+      return
+    }
+
+    const decision = routeDecision(mapDefinition, node, { ...context, passedNodes }, overrides)
+    rememberDecision(node, passedNodes, decision)
+    if (!decision || decision.status === 'terminal' && !decision.outcomes.length
+      || decision.status === 'unknown' && !decision.outcomes.length) {
+      if (decision?.status === 'unknown') unknownNodes.add(node)
+      return
+    }
+    if (decision.status === 'unknown' || Number(decision.unknownProbability) > 1e-9) unknownNodes.add(node)
+
+    const nextPath = new Set(path)
+    nextPath.add(node)
+    decision.outcomes.forEach((outcome) => {
+      const key = edgeKey(node, outcome.to)
+      if (outcome.probability == null) {
+        unknownEdges.add(key)
+        return
+      }
+      const edgeEstimated = estimatedPath || outcome.estimated === true
+      if (edgeEstimated) estimatedEdges.add(key)
+      edgeMass[key] = number(edgeMass[key]) + mass * outcome.probability
+      walk(outcome.to, [...passedNodes, node], mass * outcome.probability, nextPath, edgeEstimated)
+    })
+  }
+
+  walk(start, [], 1, new Set(), false)
+  return {
+    reach,
+    edgeMass,
+    unknownNodes: Array.from(unknownNodes),
+    unknownEdges: Array.from(unknownEdges),
+    estimatedNodes: Array.from(estimatedNodes),
+    estimatedEdges: Array.from(estimatedEdges),
+    decisionVariants,
+  }
+}
+
 function evaluateMap(mapDefinition, context = {}, overrides = {}) {
   const nodes = new Set([mapDefinition?.start || '1'])
   ;(mapDefinition?.rules || []).forEach((rule) => nodes.add(rule.node))
@@ -574,7 +653,21 @@ function evaluateMap(mapDefinition, context = {}, overrides = {}) {
   Array.from(nodes).forEach((node) => {
     if (!decisions[node]) decisions[node] = routeDecision(mapDefinition, node, context, overrides)
   })
-  const probability = propagateProbability(mapDefinition?.start || '1', decisions)
+  const probability = hasVisitedRules(mapDefinition)
+    ? propagatePathProbability(mapDefinition?.start || '1', mapDefinition, context, overrides)
+    : propagateProbability(mapDefinition?.start || '1', decisions)
+  if (probability.decisionVariants) {
+    const preferredPath = Array.isArray(context.passedNodes) ? context.passedNodes : []
+    probability.decisionVariants.forEach((variants, node) => {
+      const preferred = preferredPath.length
+        ? variants
+          .filter((variant) => variant.passedNodes.every((passedNode, index) => preferredPath[index] === passedNode))
+          .sort((left, right) => right.passedNodes.length - left.passedNodes.length)[0]
+        : null
+      decisions[node] = (preferred || variants[0]).decision
+    })
+    delete probability.decisionVariants
+  }
   return { decisions, probability }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poi-plugin-compass",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "通常海域舰队罗盘",
   "main": "index.js",
   "repository": {
@@ -52,7 +52,7 @@
     "icon": "fa/compass",
     "priority": 20,
     "apiVer": {
-      "11.99.99": "0.1.5"
+      "11.99.99": "0.1.6"
     }
   },
   "peerDependencies": {