poi-plugin-compass 0.1.2 → 0.1.3

package/docs/research.md

@@ -131,7 +131,7 @@ const label = maps?.[mapKey]?.route?.[Number(cell)]?.[1]
 
 无法确定“约 80%”是否为长期规则、样本估计还是攻略近似时，应使用 `approximate` 或 `unknown`，并把原文保留到审阅队列。
 
-本轮已将通常海域 36 张 `/{带路条件}` 子页以及 5-6 主页面的原始 wikitext 缓存到 `data/sources/kcwiki/routes/`，并在 `manifest.json` 中记录 revision ID、修订时间和 SHA-256。规则校正以这批缓存为审阅入口：`CV系`/`CV*` 归入 `CV_ALL`，明确的 `CV+CVB` 归入 `CV_MAIN`；`CL系`、`CL+CT`、`BB系` 和单独 `BB` 也分别使用不同令牌，避免把 CVL、CT 或 BBV 静默漏掉或误计入。
+本轮已将通常海域 36 张 `/{带路条件}` 子页以及 5-6 主页面的原始 wikitext 缓存到 `data/sources/kcwiki/routes/`，并在 `manifest.json` 中记录 revision ID、修订时间和 SHA-256。规则校正以这批缓存为审阅入口：`CA系`/`CA+CAV` 归入 `CA_ALL`，`CV系`/`CV*` 归入 `CV_ALL`，明确的 `CV+CVB` 归入 `CV_MAIN`；`CL系`、`CL+CT`、`BB系` 和单独 `BB` 也分别使用不同令牌。`CV_ALL` 是 CV+CVB+CVL，`CV_MAIN` 只含 CV+CVB；`CL_ALL` 是 CL+CLT+CT；`BB_ALL` 是 BB+FBB+BBV，而单独 `BB` 只含 BB+FBB，避免把 CVL、CT、BBV 或 CAV 静默漏掉或误计入。
 
 ### 4.2 日文 Wiki
 
@@ -247,6 +247,8 @@ interface RouteRule {
     to: NodeLabel
     probability: number | 'unknown'
   }>
+  // 原文明确表示本次概率判定失败后继续检查后续规则
+  continueOnFailure?: boolean
   appliesWhen?: { difficulty?: string; gauge?: number; phase?: number }
   sourceRefs: SourceRef[]
   confidence: 'exact' | 'verified' | 'parsed' | 'approximate' | 'unknown'
@@ -287,11 +289,11 @@ interface EnemyComposition {
 
 1. 按 `priority` 排序；
 2. 依次求值规则的 predicate；
-3. 取第一个确定匹配的规则；
-4. 若匹配规则产生多个出口，使用其明确权重；
-5. 若没有规则或规则含未知状态，返回 `unknown` 并附上原因。
+3. 对命中的规则按其出口概率消费当前剩余概率质量；
+4. 若规则标记 `continueOnFailure`，或已知出口概率之和小于 1，则只消费已知命中概率，把失败的剩余质量交给同节点后续规则；
+5. 没有后续规则时，才将明确的未知随机出口均分并标记估算；predicate 本身无法判断时返回 `unknown`，不越过该条件猜测后续规则。
 
-这里的“第一个”不是实现者猜测的优先级，而必须来自页面表格顺序或人工标注的 `priority`。
+因此页面中的“第一条规则”只是在没有续判语义时消耗全部质量；`4-3 H`、`2-3 J`、`4-5 Q` 等节点会把多个命中规则组合成复合概率，而不是把前一条的失败质量强行并入另一个出口。
 
 ### 6.2 概率质量传播
 

package/docs/sources.md

@@ -82,4 +82,4 @@ data/sources/kcwiki/routes/manifest.json
 
 `1-1`～`1-6`、`2-1`～`2-5`、`3-1`～`3-5`、`4-1`～`4-5`、`5-1`～`5-6`、`6-1`～`6-5`、`7-1`～`7-5`。5-6 的路线分支直接记录在海域主页面 `南方海域/5-6`，因此缓存脚本对该图使用主页面标题，而其他通常图继续使用 `/{带路条件}` 子页。
 
-其中带有“约”“随机但未给比例”“原文带问号”或依赖分歧点系数/司令部系数的条件，使用 `approximate` 或 `unknown`；这类记录仍提供可能出口，但不产生伪造的全局百分比。后续继续补录时，先以同一 API 子页取得规则原文，再用日文 Wiki 或浏览器中的 NGA 页面复核有冲突的条件。
+其中带有“约”“随机但未给比例”“原文带问号”或依赖分歧点系数/司令部系数的条件，使用 `approximate` 或 `unknown`；这类记录仍提供可能出口，但不产生伪造的全局百分比。原文明确写出“判定失败后继续”“继续下面判定”或“逐条依次判定”时，规则会保留已知命中概率并设置 `continueOnFailure`，将剩余概率交给同节点后续规则。当前临时估计约定为：未给出比例的两个出口按 50%/50% 并标记 `?`；索敌区间内“概率随索敌变化”的两个出口也按 50%/50% 并标记 `?`；只有一个出口且明确表示失败后继续判定时，该出口按 50% 并把剩余 50% 交给后续规则。固定单出口仍按 100% 处理，但保留未知/近似标记。规则面板对 KCWiki 原文中的多条同向条件逐行显示，评估器仍按来源顺序处理。7-3 A 点曾将去 B 和去 C 的条件错误合并，已按缓存原文顺序拆开并修正出口。后续继续补录时，先以同一 API 子页取得规则原文，再用日文 Wiki 或浏览器中的 NGA 页面复核有冲突的条件。

package/index.js

@@ -404,6 +404,58 @@ function outcomeText(outcome) {
   return `${outcome.to} ${formatPercent(outcome.probability, outcome.estimated)}`
 }
 
+// These predicates came from separate list items in the cached KCWiki route
+// tables.  Keep the evaluator's compact OR semantics for compatibility, but
+// render each source line separately so the UI does not invent one combined
+// rule where the source did not have one.
+const SEPARATE_SOURCE_LINE_RULE_IDS = new Set([
+  '2-5-C-heavy',
+  '1-5-F-heavy',
+  '1-6-start-heavy', '1-6-M-heavy',
+  '2-3-D-special',
+  '4-2-C-light-l',
+  '6-1-start-heavy3',
+  '6-2-C-a', '6-2-D-f', '6-2-E-f',
+  '6-4-start-right-lha', '6-4-A-noakitsu-heavy', '6-4-E-special', '6-4-E-g', '6-4-J-l', '6-4-J-i', '6-4-K-h',
+  '6-5-start-left', '6-5-C-e', '6-5-E-i', '6-5-I-h',
+  '7-1-B-a', '7-1-H-k',
+  '7-2-C-d', '7-2-E-g', '7-2-I-j',
+  '7-3-C-heavy', '7-3-G-special', '7-3-I-heavy', '7-3-J-m', '7-3-J-p', '7-3-M-n', '7-3-M-o',
+  '7-4-start-c', '7-4-start-a', '7-4-C-d', '7-4-J-k', '7-4-J-l', '7-4-M-heavy',
+  '7-5-B-c', '7-5-D-e', '7-5-D-fast', '7-5-J-N', '7-5-J-O-heavy', '7-5-P-r',
+])
+
+function visibleRuleLabel(rule) {
+  const label = predicateLabel(rule?.predicate)
+  return label
+    .replace(/（[^）]*(?:近似|约|原文|比例未知|分歧系数)[^）]*）/g, '')
+    .replace(/\([^)]*(?:approx|about|original|unknown|coefficient)[^)]*\)/gi, '')
+    .replace(/，?\s*失败后继续判定/g, '')
+    .replace(/：\s*[^，；：]+概率(?:未知|随索敌变化)/g, '')
+    .replace(/；\s*(?:近似|约)/g, '')
+    .replace(/（原文(?:标记\s*\?|比例未知)[^）]*）/g, '')
+    .replace(/（约）/g, '')
+    .replace(/\s{2,}/g, ' ')
+    .replace(/：\s*$/g, '')
+    .trim()
+}
+
+function rulePopoverNotes(rule, rawLabel, visibleLabel) {
+  const notes = []
+  if (rawLabel !== visibleLabel) notes.push(`原文补充：${rawLabel}`)
+  if (rule?.continueOnFailure === true) notes.push('本条判定失败后继续检查后续规则')
+  if (rule?.confidence === 'approximate') notes.push('该条件或概率来自近似资料')
+  if (rule?.confidence === 'unknown' || rule?.outcomes?.some((outcome) => outcome?.probability == null)) {
+    notes.push('来源没有给出明确概率；当前按均等概率暂估')
+  }
+  return notes
+}
+
+function displayPredicatesForRule(rule) {
+  if (!SEPARATE_SOURCE_LINE_RULE_IDS.has(rule?.id) || rule?.predicate?.kind !== 'any') return [rule?.predicate]
+  return rule.predicate.predicates?.length ? rule.predicate.predicates : [rule.predicate]
+}
+
 function conditionIcon(status, active) {
   if (active) return '✓'
   if (status === 'true') return '•'
@@ -423,11 +475,16 @@ function ruleRows(mapDefinition, node, context) {
   return (mapDefinition.rules || [])
     .filter((rule) => rule.node === node)
     .sort((left, right) => number(left.priority) - number(right.priority))
-    .map((rule) => ({
-      rule,
-      result: evaluatePredicate(rule.predicate, context),
-      outcomes: normalizeOutcomes(rule.outcomes, rule),
-    }))
+    .reduce((rows, rule) => {
+      displayPredicatesForRule(rule).forEach((predicate, index) => {
+        rows.push({
+          rule: { ...rule, id: `${rule.id}::${index}`, predicate, sourceRuleId: rule.id },
+          result: evaluatePredicate(predicate, context),
+          outcomes: normalizeOutcomes(rule.outcomes, rule),
+        })
+      })
+      return rows
+    }, [])
 }
 
 function fleetSummary(context) {
@@ -613,10 +670,10 @@ class Compass extends React.Component {
       `制空 ${air.min === air.max ? air.min : `${air.min}～${air.max}`}`)
   }
 
-  setManualOverride(node, to, edgeId = null) {
+  setManualOverride(node, to, edgeId = null, selectedNode = node) {
     this.setState((state) => ({
       overrides: { ...state.overrides, [node]: to },
-      selectedNode: node,
+      selectedNode,
       selectedEdge: edgeId,
       exportRoute: null,
       exportError: null,
@@ -747,7 +804,7 @@ class Compass extends React.Component {
         const activateNode = (event) => {
           if (event.key !== 'Enter' && event.key !== ' ') return
           event.preventDefault()
-          if (manualTarget) this.setManualOverride(manualSource, node)
+          if (manualTarget) this.setManualOverride(manualSource, node, null, node)
           else this.selectNode(node)
         }
         return h('g', {
@@ -755,7 +812,7 @@ class Compass extends React.Component {
           className: classNames,
           role: 'button',
           tabIndex: 0,
-          onClick: () => manualTarget ? this.setManualOverride(manualSource, node) : this.selectNode(node),
+          onClick: () => manualTarget ? this.setManualOverride(manualSource, node, null, node) : this.selectNode(node),
           onKeyDown: activateNode,
         },
         h('title', null, nodeInfo?.label ? `${node} · ${nodeInfo.label}` : node),
@@ -960,22 +1017,31 @@ class Compass extends React.Component {
       h('h4', null, `${node} 点`),
       rows.length
         ? h('div', { className: 'compass-conditions' }, ...rows.map(({ rule, result, outcomes: ruleOutcomes }) => {
-          const active = decision?.rule?.id === rule.id
-          const displayedOutcomes = active ? decision.outcomes : ruleOutcomes
+          const sourceRuleId = rule.sourceRuleId || rule.id
+          const sourceWasMatched = decision?.matchedRuleIds?.includes(sourceRuleId) || decision?.rule?.id === sourceRuleId
+          const splitSourceRule = SEPARATE_SOURCE_LINE_RULE_IDS.has(sourceRuleId)
+          const active = splitSourceRule ? sourceWasMatched && result.status === 'true' : sourceWasMatched
+          const displayedOutcomes = active && (decision?.matchedRuleIds?.length || 0) <= 1
+            ? decision.outcomes
+            : ruleOutcomes
           const outcomes = displayedOutcomes.length ? displayedOutcomes.map(outcomeText).join(' / ') : '—'
+          const rawLabel = predicateLabel(rule.predicate)
+          const label = visibleRuleLabel(rule)
+          const notes = rulePopoverNotes(rule, rawLabel, label)
           return h('div', {
           key: rule.id,
           className: `compass-condition is-${result.status}${active ? ' is-active' : ''}`,
           tabIndex: 0,
-          'aria-label': `${conditionStatus(result.status)}：${predicateLabel(rule.predicate)}`,
+          'aria-label': `${conditionStatus(result.status)}：${label}`,
         },
           h('span', { className: 'compass-condition-icon', 'aria-hidden': 'true' }, conditionIcon(result.status, active)),
-          h('span', { className: 'compass-condition-label' }, predicateLabel(rule.predicate)),
+          h('span', { className: 'compass-condition-label' }, label),
           h('span', { className: 'compass-condition-outcomes' }, outcomes),
           h('div', { className: 'compass-condition-popover', role: 'tooltip' },
             h('div', null, `${conditionStatus(result.status)}${active ? ' · 当前出口规则' : ''}`),
+            h('div', null, `条件：${rawLabel}`),
             h('div', null, `出口：${outcomes}`),
-            rule.confidence === 'approximate' ? h('div', null, '概率为资料中的近似值') : null,
+            ...notes.map((note, index) => h('div', { key: `${rule.id}-note-${index}`, className: 'compass-condition-note' }, note)),
           ),
         )
         }))
@@ -1100,4 +1166,7 @@ exports.__test = {
   phaseOptionsForMap,
   pluginState,
   routeEdges,
+  ruleRows,
+  visibleRuleLabel,
+  separateSourceLineRuleIds: SEPARATE_SOURCE_LINE_RULE_IDS,
 }

package/logic.js

@@ -9,19 +9,20 @@ const SHIP_CATEGORIES = {
   CL_ALL: new Set([3, 4, 21]),
   CA: new Set([5]),
   CAV: new Set([6]),
+  CA_ALL: new Set([5, 6]),
   CVL: new Set([7]),
   BB: new Set([8, 9]),
   BBV: new Set([10]),
   BB_ALL: new Set([8, 9, 10]),
-  CV: new Set([11, 12, 18]),
-  CV_ALL: new Set([7, 11, 12, 18]),
+  CV: new Set([11, 12]),
+  CV_ALL: new Set([7, 11, 12]),
   SS: new Set([13, 14]),
   AO: new Set([15]),
   AV: new Set([16]),
   LHA: new Set([17]),
   AR: new Set([19]),
   AS: new Set([20]),
-  CV_MAIN: new Set([11, 12, 18]),
+  CV_MAIN: new Set([11, 12]),
 }
 
 const CATEGORY_LABELS = {
@@ -33,6 +34,7 @@ const CATEGORY_LABELS = {
   CL_ALL: 'CL系',
   CA: '重巡',
   CAV: '航巡',
+  CA_ALL: 'CA系',
   CVL: '轻空母',
   BB: '战舰（BB/FBB）',
   BBV: '航战',
@@ -45,7 +47,7 @@ const CATEGORY_LABELS = {
   LHA: '扬陆',
   AR: '工作舰',
   AS: '潜母',
-  CV_MAIN: '正规/装甲空母',
+  CV_MAIN: 'CV/CVB',
 }
 
 const EQUIPMENT_CATEGORY_LABELS = {
@@ -313,17 +315,152 @@ function normalizeOutcomes(outcomes, rule = null, options = {}) {
         : Number.isFinite(Number(outcome.probability)) ? Number(outcome.probability) : null,
     }))
 
+  if (!normalized.length) return []
+  const hasKnownProbability = normalized.some((outcome) => outcome.probability != null)
   const hasMissingProbability = normalized.some((outcome) => outcome.probability == null)
-  const equalize = options.equalizeUnknown !== false && (hasMissingProbability || rule?.confidence === 'unknown')
-  const estimated = equalize || rule?.confidence === 'approximate' && normalized.length > 1
-  return normalized.map((outcome) => {
+  const allUnknown = !hasKnownProbability
+  if (rule?.continueOnFailure === true) {
+    if (!hasKnownProbability) {
+      // A rule such as “within this LOS range, go to N; if the check fails,
+      // continue below” has two effective branches.  The source does not give
+      // a ratio, so expose the same temporary 50/50 estimate used by the
+      // route evaluator instead of showing an unhelpful “unknown” row.
+      const probability = 1 / (normalized.length + 1)
+      return normalized.map((outcome) => ({ to: outcome.to, probability, estimated: true }))
+    }
+    const estimated = rule.confidence === 'unknown' || rule.confidence === 'approximate'
+    return normalized
+      .filter((outcome) => outcome.probability != null)
+      .map((outcome) => ({
+        to: outcome.to,
+        probability: outcome.probability,
+        ...(estimated ? { estimated: true } : {}),
+      }))
+  }
+  if (allUnknown && options.equalizeUnknown === false) {
+    return normalized.map((outcome) => ({ to: outcome.to, probability: null }))
+  }
+  const equalize = options.equalizeUnknown !== false && (
+    allUnknown || !hasMissingProbability && rule?.confidence === 'unknown'
+  )
+  const estimated = equalize || hasMissingProbability || rule?.confidence === 'unknown'
+    || rule?.confidence === 'approximate' && normalized.length > 1
+  return normalized
+    .filter((outcome) => equalize || outcome.probability != null)
+    .map((outcome) => {
     const normalizedOutcome = {
       to: outcome.to,
       probability: equalize && normalized.length ? 1 / normalized.length : outcome.probability,
     }
     if (estimated) normalizedOutcome.estimated = true
     return normalizedOutcome
-  })
+    })
+}
+
+function ruleDistribution(rule) {
+  const raw = (Array.isArray(rule?.outcomes) ? rule.outcomes : [])
+    .filter((outcome) => outcome && typeof outcome.to === 'string')
+    .map((outcome) => ({
+      to: outcome.to,
+      probability: outcome.probability == null
+        ? null
+        : Number.isFinite(Number(outcome.probability)) ? Number(outcome.probability) : null,
+    }))
+  if (!raw.length) return { outcomes: [], residual: rule?.continueOnFailure === true ? 1 : 0 }
+
+  const known = raw.filter((outcome) => outcome.probability != null)
+  const knownTotal = known.reduce((total, outcome) => total + outcome.probability, 0)
+  const partial = rule?.continueOnFailure === true
+    || (known.length > 0 && knownTotal < 1 - 1e-9)
+    || (known.length > 0 && known.length < raw.length)
+
+  if (partial) {
+    if (known.length) {
+      return {
+        outcomes: normalizeOutcomes(raw, rule),
+        residual: Math.max(0, 1 - knownTotal),
+      }
+    }
+    const probability = 1 / (raw.length + 1)
+    return {
+      outcomes: raw.map((outcome) => ({ to: outcome.to, probability, estimated: true })),
+      residual: probability,
+    }
+  }
+
+  return { outcomes: normalizeOutcomes(raw, rule), residual: 0 }
+}
+
+function evaluateRouteRules(mapDefinition, node, context) {
+  const rules = rulesForNode(mapDefinition, node)
+  if (!rules.length) {
+    return { status: 'terminal', rule: null, predicate: null, matchedRuleIds: [], outcomes: [], unknownProbability: 0 }
+  }
+
+  const totals = new Map()
+  const matchedRuleIds = []
+  let residual = 1
+  let firstRule = null
+  let firstPredicate = null
+  let unresolvedPredicate = null
+  let terminal = false
+
+  function addOutcome(outcome, mass) {
+    if (!Number.isFinite(mass) || mass <= 0) return
+    const current = totals.get(outcome.to)
+    if (!current) {
+      totals.set(outcome.to, {
+        to: outcome.to,
+        probability: mass,
+        ...(outcome.estimated === true ? { estimated: true } : {}),
+      })
+      return
+    }
+    current.probability += mass
+    if (outcome.estimated === true) current.estimated = true
+  }
+
+  for (const rule of rules) {
+    if (residual <= 1e-9) break
+    const predicate = evaluatePredicate(rule.predicate, context)
+    if (predicate.status === 'false') continue
+    if (predicate.status === 'unknown') {
+      unresolvedPredicate = { rule, predicate }
+      break
+    }
+
+    if (!firstRule) {
+      firstRule = rule
+      firstPredicate = predicate
+    }
+    if (rule.id) matchedRuleIds.push(rule.id)
+    if (rule.terminal === true) {
+      residual = 0
+      terminal = true
+      break
+    }
+    const distribution = ruleDistribution(rule)
+    if (!distribution.outcomes.length) {
+      unresolvedPredicate = { rule, predicate }
+      break
+    }
+    distribution.outcomes.forEach((outcome) => addOutcome(outcome, residual * outcome.probability))
+    residual *= distribution.residual
+  }
+
+  const outcomes = [...totals.values()]
+  const unknownProbability = (unresolvedPredicate || residual > 1e-9) ? residual : 0
+  const status = unknownProbability > 1e-9
+    ? 'unknown'
+    : outcomes.length ? 'matched' : terminal ? 'terminal' : 'unknown'
+  return {
+    status,
+    rule: firstRule || unresolvedPredicate?.rule || null,
+    predicate: firstPredicate || unresolvedPredicate?.predicate || null,
+    matchedRuleIds,
+    outcomes,
+    unknownProbability,
+  }
 }
 
 function routeDecision(mapDefinition, node, context, overrides = {}) {
@@ -334,9 +471,17 @@ function routeDecision(mapDefinition, node, context, overrides = {}) {
   const manualOutcomes = Array.isArray(configuredManualOutcomes)
     ? normalizeOutcomes(configuredManualOutcomes, { confidence: 'unknown' }, { equalizeUnknown: false })
     : null
-  const autoOutcomes = selected.status === 'matched'
-    ? normalizeOutcomes(selected.rule?.outcomes, selected.rule)
-    : []
+  const automatic = manual
+    ? {
+      status: selected.status,
+      rule: selected.rule,
+      predicate: selected.predicate,
+      matchedRuleIds: selected.rule?.id ? [selected.rule.id] : [],
+      outcomes: selected.status === 'matched' ? normalizeOutcomes(selected.rule?.outcomes, selected.rule) : [],
+      unknownProbability: 0,
+    }
+    : evaluateRouteRules(mapDefinition, node, context)
+  const autoOutcomes = automatic.outcomes
   const phaseRuleMatched = manual && hasPhaseRules(mapDefinition, node) && selected.status === 'matched'
   const baseOutcomes = phaseRuleMatched
     ? autoOutcomes
@@ -349,9 +494,11 @@ function routeDecision(mapDefinition, node, context, overrides = {}) {
     : baseOutcomes
   return {
     node,
-    status: selected.status,
-    rule: selected.rule,
-    predicate: selected.predicate,
+    status: automatic.status,
+    rule: automatic.rule,
+    predicate: automatic.predicate,
+    matchedRuleIds: automatic.matchedRuleIds,
+    unknownProbability: automatic.unknownProbability,
     baseOutcomes,
     manualOutcomes,
     outcomes,
@@ -383,10 +530,12 @@ function propagateProbability(start, decisions) {
       return
     }
     const decision = decisions[node]
-    if (!decision || decision.status === 'unknown' || decision.status === 'terminal' && !decision.outcomes.length) {
+    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) => {

package/package.json

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