Advisor: Black research runs always keep the gates and climb the tree #56

Merged
kathleen merged 1 commits from solver/never-rule-out-target into main 2026-11-22 02:20:54 +00:00
2 changed files with 49 additions and 7 deletions
Showing only changes of commit d9f3c200b8 - Show all commits
+26 -7
View File
@@ -236,14 +236,30 @@
if (!worlds) worlds = Array.from({ length: draws }, (_, i) => solveWith(rng(seed * 7919 + i + 1)).sol.choices);
return worlds.filter((c) => c.get(key) === choice).length / draws;
};
// What the game allows, whatever the data say: the same game solved with no runs at all, so every roll can come
// out every way except through a closed gate (game.yaml `requires`), and an encounter bonds only its own colour
// (and any colour seen there). An option after which X cannot happen at all is never advised while another option
// keeps X possible, however small the data make every option's odds. Without this, when the data put X near zero
// on every route (the Black on a later attempt), every option ties and a tie-breaking rider or bot may walk away
// from the squadmate or go to the valley: the Black needs the gates and the tree (game.yaml, the community PDF and
// the developer).
const emptyTables = { encounter: {}, ...Object.fromEntries(Object.keys(game.chance).map((k) => [k, {}])) };
const reach = solve(makeParams(emptyTables, { game, given: known }), game, support, X, 0, only).optVals;
const possibleAt = (key, vals) => Object.keys(vals).filter((o) => vals[o].x > 0 || (((reach.get(key) || {})[o]) || ZERO).x > 0);
/** The choice at a history among the options that keep X possible (if any does), and the options ruled out. */
const advisedAt = (key) => {
let vals = sol.optVals.get(key) || {}, choice = sol.choices.get(key);
const can = possibleAt(key, vals), ruledOut = Object.keys(vals).filter((o) => !can.includes(o));
if (can.length && ruledOut.length && !can.includes(choice)) choice = can.reduce((b, o) => (vals[o].x > vals[b].x ? o : b), can[0]);
return { vals, choice, ruledOut: can.length ? ruledOut : [] };
};
const VARS = new Set([...Object.keys(game.decisions), ...Object.keys(game.chance), "encounter"]);
const fmt = (v) => ({ pX: v.x, pOther: v.o, pReach: v.r });
const label = (k) => (game.decisions[k] || game.chance[k]).label;
const decisionAt = (name, key, extra) => {
const vals = sol.optVals.get(key) || {};
const choice = sol.choices.get(key);
const { vals, choice, ruledOut } = advisedAt(key);
return { kind: "decision", var: name, label: label(name), choice, propensity: propensityAt(key, choice),
options: Object.fromEntries(Object.entries(vals).map(([o, v]) => [o, fmt(v)])), ...extra };
options: Object.fromEntries(Object.entries(vals).map(([o, v]) => [o, fmt(v)])), ...(ruledOut.length ? { ruledOut } : {}), ...extra };
};
/** The next thing that happens after history h: a decision, a roll, or the end of the run. */
@@ -257,7 +273,7 @@
if (st.decision) {
const name = st.decision, key = name + "@" + canon(state);
if (h[name] != null) { value = h[name]; used.add(name); }
else if (later()) value = sol.choices.get(key);
else if (later()) value = advisedAt(key).choice;
else return decisionAt(name, key, risk ? { risk } : {});
risk = null;
} else {
@@ -286,7 +302,7 @@
/** the next decision only (null when the next step is a roll or the run is over) */
next(h) {
const s = step(h);
return s.kind === "decision" ? { decision: s.var, label: s.label, choice: s.choice, propensity: s.propensity, options: s.options } : null;
return s.kind === "decision" ? { decision: s.var, label: s.label, choice: s.choice, propensity: s.propensity, options: s.options, ...(s.ruledOut ? { ruledOut: s.ruledOut } : {}) } : null;
},
};
}
@@ -322,10 +338,13 @@
}
const pat = pats[rec.choice];
const idx = pat ? texts.findIndex((t) => new RegExp(pat).test(t)) : -1;
const values = Object.values(rec.options).map((v) => v.pX).sort((a, b) => b - a);
// options after which the target cannot happen at all are not offered to the bot (its tie rule picks among
// `options`): see advisor's `ruledOut`
const options = rec.ruledOut ? Object.fromEntries(Object.entries(rec.options).filter(([o]) => !rec.ruledOut.includes(o))) : rec.options;
const values = Object.values(options).map((v) => v.pX).sort((a, b) => b - a);
return { index: idx < 0 ? null : idx, decision: rec.decision, choice: rec.choice, propensity: rec.propensity,
margin: values.length > 1 ? values[0] - values[1] : null,
options: rec.options,
options, ...(rec.ruledOut ? { ruledOut: rec.ruledOut } : {}),
reason: idx < 0 && rec.decision !== "encounter" ? "the recommended choice is not on this screen; use the bot's own rules" : `${rec.label}: ${rec.choice}` };
}
+23
View File
@@ -145,3 +145,26 @@ test("known answers load and answer in the shape the bot expects", () => {
assert.ok(Array.isArray(r.choices));
}
});
test("the bot's tie rule never takes an option that rules the Black out, even when every option's odds are about zero", () => {
// the bot (src/atlasPolicy.js) picks at random among options within tieMargin of the best. On a later attempt the
// data put the Black near zero everywhere, so before the advisor ruled such options out every option tied, and the
// bot walked away from the squadmate or went to the valley (DragonKind research runs 90, 91, 102, November 2026).
const TIE = 0.002; // DEFAULT_TIE_MARGIN in the bot
const tiedAt = (offered, history) => {
const rec = advise({ targetDragon: "black", events: history, offered });
if (!rec || rec.margin === null) return rec ? [rec.choice] : [];
const best = Math.max(...Object.values(rec.options).map((v) => v.pX));
return Object.entries(rec.options).filter(([, v]) => best - v.pX < TIE).map(([o]) => o);
};
// the screens exactly as the bot saw them (DragonKind research run 91)
const start = [{ optionText: "Enter the valley alone" }, { optionText: "Head toward the center of the forest" }, { tint: "red", optionText: "Lower your eyes in respect" }, { optionText: "Head deeper into the forest" }];
const t1 = tiedAt(["Investigate the scream", "Keep walking. The cadets are just as dangerous as the dragons today"], [...start, {}]);
assert.ok(t1.length && !t1.includes("Keep walking"), `scream: ${t1}`);
const t2 = tiedAt(["Play it safe and leave them to their own defense so you can find your dragon", "Help your squadmate"], [...start, { optionText: "Investigate the scream" }, {}]);
assert.ok(t2.length && !t2.includes("Walk away"), `clearing: ${t2}`);
const path = [...start, { optionText: "Investigate the scream" }, { optionText: "Help your squadmate" }, { optionText: "Pause to assess the situation even though it may risk your squadmate's life" },
{ optionText: "Engage the smaller cadet" }, { optionText: "Allow your squadmate to exact their own revenge" }, { optionText: "Walk farther into the forest" }, {}];
const t3 = tiedAt(["Find the tallest tree and climb for a better view", "Continue toward the center of the valley"], path);
assert.deepStrictEqual(t3, ["Tree"], `hour: ${t3}`);
});