Millbury Mansion

# Doors: the room, and the corridor square just outside its gap in the wall.
DOORS = (
    ("conservatory", (6, 3)),
    ("ballroom", (7, 4)), ("ballroom", (10, 6)), ("ballroom", (13, 6)),
    ("kitchen", (20, 6)),
    ("seance", (6, 9)),
    ("library", (6, 15)), ("library", (3, 12)),
    ("dining", (16, 10)), ("dining", (16, 13)), ("dining", (20, 7)),
    ("study", (4, 18)),
    ("gallery", (11, 17)), ("gallery", (16, 20)),
    ("crypt", (17, 20)),
)

def reach(start, steps: int, blocked) -> dict:
    """Where a pawn can go with a roll of `steps`, moving up to that many
    squares: {key: path}. `start` is ("room", name) or ("cell", (x, y)).
    `blocked` holds the corridor squares other pawns stand on, which no one
    lands on or passes through. A room is entered through a door, and ends
    the move; the room a pawn starts in can't be entered again this turn.
    A key is "room:<name>" or "x,y"; a path lists the squares walked, and
    the room last if it ends in one."""
    out = {}
    dist = {}
    prev = {}
    todo = deque()
    if start[0] == "room":
        for cell in DOORS_OF[start[1]]:
            if cell not in blocked and cell not in dist:
                dist[cell] = 1
                prev[cell] = None
                todo.append(cell)
        home = start[1]
    else:
        dist[start[1]] = 0
        prev[start[1]] = None
        todo.append(start[1])
        home = None
    while todo:
        c = todo.popleft()
        d = dist[c]
        if d < steps:
            for n in neighbors(c):
                if n not in dist and n not in blocked:
                    dist[n] = d + 1
                    prev[n] = c
                    todo.append(n)
            for r in ROOM_AT_DOOR.get(c, ()):
                key = f"room:{r}"
                if r != home and key not in out:
                    out[key] = _path(prev, c) + [r]
    for c, d in dist.items():
        if d >= 1:
            out[f"{c[0]},{c[1]}"] = _path(prev, c)
    return out

/** How every word on the plan is set, for a plan drawn `k` px to the unit. */
export function wordSizes(k) {
  const least = FLOOR / k;
  // (a computer's plan, drawn at about 1px to the unit or more, keeps its pawns and marks as drawn)
  const grown = 12 * k < 12.1;
  // (room to breathe: 4px between a word and its box's edge, in units)
  const pad = Math.max(6, 4.25 / k);
  // The plates: one size, as large as the floor or the tightest room allows.
  const plates = (face, ls) => {
    let size = least;
    for (const r of [...ROOMS, 'hall']) {
      const { l, r: right } = roomBox(r);
      size = Math.min(size, (right - l - 2 - 2 * pad) / ems(r === 'hall' ? 'The case file' : NAMES[r], face));
    }
    return { face, size, ls };
  };
  let plate = { face: SC, size: 13, ls: 0.5 };
  if (least > 13) {
    plate = plates(SC, 0);
    if (plate.size * k < LEAST) plate = plates(ITALIC, 0);
  }
  // The passages' tabs: from the corner mark along the room's outer wall,
  // as far as the room goes. A name too long for that (the Crypt's
  // "Conservatory", on a small plan) takes the wall's whole width, and its
  // mark stands just inside it.
  const mark = grown ? { at: 20, r: 11 } : { at: 24, r: 12 };
  const fits = Object.fromEntries(Object.keys(PASSAGE_SPOTS).map(room => {
    const { l, r } = roomBox(room), em = ems(NAMES[PASSAGES[room]], ITALIC);
    return [room, { beside: (r - l - 1 - mark.at - mark.r - 2 * pad) / em, stacked: (r - l - 2 - 2 * pad) / em }];
  }));
  const want = Math.max(12, least);
  const tab = Math.max(12, Math.min(...Object.values(fits).map(f => Math.min(want, f.beside >= want ? want : Math.max(f.beside, f.stacked)))));
  const stacked = Object.keys(fits).filter(room => fits[room].beside < tab - 0.01);
  // A pawn grows round its initial (but no wider than a square and a bit, so neighbors don't cover each other).
  const pawnR = grown ? Math.max(12, Math.min(14, least * 0.5)) : 12;
  const pawn = grown ? Math.min(least, (pawnR - 0.5) / 0.47) : 12;
  return { k, pad, plate, tab, stacked, mark, pawn, pawnR, start: grown ? Math.min(least, 28) : 12, faceup: Math.max(12, least) };
}

def new(players: int, seed: str, now: float, settings: dict | None = None) -> dict:
    if not min_players <= players <= max_players:
        raise Illegal("Millbury Mansion is for three to six players.")
    rules = options(settings)
    rng = random.Random(f"{seed}:case")
    case = [rng.choice(SUSPECTS), rng.choice(WEAPONS), rng.choice(ROOMS)]
    rest = deck.shuffled([c for c in CARDS if c not in case], f"{seed}:deal")
    each = len(rest) // players
    hands = [sorted(rest[s * each:(s + 1) * each], key=CARDS.index) for s in range(players)]
    faceup = sorted(rest[each * players:], key=CARDS.index)
    homes = deck.shuffled(list(ROOMS), f"{seed}:heirlooms")
    state = {
        "game": slug, "n": players, "seed": seed, "rules": {"quick": rules["quick"]},
        "_pace": moves.BOT_PACE[rules["bot_pace"]],
        "seq": 0, "logged": 0, "events": [],
        "case": case, "hands": hands, "faceup": faceup,
        "cast": [None] * players,
        "at": {s: {"cell": list(STARTS[s])} for s in SUSPECTS},
        "heirlooms": {w: homes[i] for i, w in enumerate(WEAPONS)},
        "phase": "cast", "turn": None, "step": None, "turns": 0, "rolls": 0, "dice": None, "reach": None,
        "entered": False, "summoned": [False] * players, "from_room": None,
        "ledger": [], "showing": None, "out": [False] * players, "accusations": [],
        "winner": None, "scores": [], "totals": [0] * players, "ready": [False] * players,
    }
    log.event(state, "deal", each=each, faceup=faceup)
    return state

def _ask_round(state, entry, seat):
    """Round to the asker's left: each says they have none, until the first
    who holds any of the three shows one (themselves choosing, with two or
    three)."""
    asker = entry["asker"]
    while seat != asker:
        held = _holds(state, seat, entry)
        if not held:
            entry["answers"].append({"seat": seat, "card": None})
            log.event(state, "pass", seat=seat, asker=asker, n=entry["n"])
            seat = (seat + 1) % state["n"]
            continue
        if len(held) == 1:
            return _show(state, entry, seat, held[0])
        state["phase"] = "show"
        state["showing"] = {"seat": seat, "asker": asker, "n": entry["n"]}
        return
    entry["done"] = True
    log.event(state, "unanswered", seat=asker, n=entry["n"])
    state["step"] = "after"

def _finish(state, winner, by_default=False):
    n = state["n"]
    state["phase"] = "over"
    state["winner"] = winner
    state["step"] = None
    state["showing"] = None
    state["reach"] = None
    log.event(state, "over", winner=winner, case=list(state["case"]), by_default=by_default)
    # The solver first; everyone still in the running next; those who
    # accused wrong last.
    points = [2 if s == winner else 0 if state["out"][s] else 1 for s in range(n)]
    rounds.score(state, points)
    rounds.end(state, last=True)

def _entry(state, e, seat, over_):
    out = {k: e[k] for k in ("n", "asker", "suspect", "weapon", "room", "done")}
    out["answers"] = [{"seat": a["seat"], "had": a["card"] is not None,
                       **({"card": a["card"]} if a["card"] is not None and (over_ or seat in (a["seat"], e["asker"])) else {})}
                      for a in e["answers"]]
    return out

def propagate(self):
    counting = self.level == "hard"
    changed = True
    while changed:
        changed = False
        # one owner a card
        for c, p in self.poss.items():
            if len(p) == 1:
                (o,) = p
                if o == ENVELOPE:
                    for d in KINDS[KIND[c]]:
                        if d != c and d in self.poss and ENVELOPE in self.poss[d]:
                            self.poss[d].discard(ENVELOPE)
                            changed = True
        # someone showed one of three: if only one is still possible, it's that
        for seat, trio in self.hasone:
            maybe = [c for c in trio if c in self.poss and seat in self.poss[c]]
            if len(maybe) == 1 and self.poss[maybe[0]] != {seat}:
                self.poss[maybe[0]] = {seat}
                changed = True
        # the case file holds one of each kind
        for kind, cards in KINDS.items():
            could = [c for c in cards if c in self.poss and ENVELOPE in self.poss[c]]
            if len(could) == 1 and self.poss[could[0]] != {ENVELOPE}:
                self.poss[could[0]] = {ENVELOPE}
                changed = True
        if counting:
            for seat in range(self.n):
                known = [c for c, p in self.poss.items() if p == {seat}]
                maybe = [c for c, p in self.poss.items() if seat in p]
                if len(known) >= self.counts[seat]:
                    for c in maybe:
                        if self.poss[c] != {seat}:
                            self.poss[c].discard(seat)
                            changed = True
                elif len(maybe) == self.counts[seat]:
                    for c in maybe:
                        if self.poss[c] != {seat}:
                            self.poss[c] = {seat}
                            changed = True

/** Who could hold each card, and why each was ruled in or out. `name(seat)`
 * says a seat the notebook's way ("you", "Ann"). */
export function deduce(v, mode = 'facts', name = s => `Seat ${s + 1}`) {
  const me = v.seat;
  const n = v.n;
  const seats = Array.from({ length: n }, (_, s) => s);
  const cards = CARDS.filter(c => !v.faceup.includes(c));
  const poss = Object.fromEntries(cards.map(c => [c, new Set([...seats, ENV])]));
  const why = {}; // `${card}|${owner}` -> words (for an owner ruled out, or the one owner)
  const tags = []; // { n, seat, asker, trio }: a show this seat didn't see
  const pass = []; // { n, seat, trio }
  const say = (c, o, words) => { const k = `${c}|${o}`; if (!why[k]) why[k] = words; };
  const cut = (c, o, words) => { if (poss[c]?.has(o) && poss[c].size > 1) { poss[c].delete(o); say(c, o, words); return true; } return false; };
  const fix = (c, o, words) => {
    if (!poss[c] || (poss[c].size === 1 && poss[c].has(o))) return false;
    for (const x of [...poss[c]]) if (x !== o) { poss[c].delete(x); say(c, x, x === ENV ? `${name(o, true)} ${o === me ? 'have' : 'has'} it, so it isn’t in the case file.` : `${name(o, true)} ${o === me ? 'have' : 'has'} it, and a card has one owner.`); }
    poss[c] = new Set([o]);
    say(c, o, words);
    return true;
  };
  if (mode === 'blank') return result();
  if (me !== null && me !== undefined) {
    for (const c of cards) {
      if (v.hand.includes(c)) fix(c, me, 'In your hand.');
      else cut(c, me, 'Not in your hand.');
    }
  }
  for (const e of v.ledger) {
    const trio = [e.suspect, e.weapon, e.room];
    for (const a of e.answers) {
      if (a.card) {
        if (e.asker === me) fix(a.card, a.seat, `${name(a.seat, true)} showed you this on turn ${e.n}.`);
        else if (a.seat === me) fix(a.card, a.seat, `In your hand (you showed it to ${name(e.asker)} on turn ${e.n}).`);
      } else if (a.had) {
        tags.push({ n: e.n, seat: a.seat, asker: e.asker, trio });
      } else {
        pass.push({ n: e.n, seat: a.seat, trio });
        for (const c of trio) cut(c, a.seat, `${name(a.seat, true)} had none of the three on turn ${e.n}.`);
      }
    }
  }
  if (mode === 'full') reason();
  return result();

  function reason() {
    const counts = v.counts;
    for (let loop = 0; loop < 50; loop++) {
      let changed = false;
      for (const t of tags) {
        const left = t.trio.filter(c => poss[c]?.has(t.seat));
        if (left.length === 1 && poss[left[0]].size > 1) {
          const others = t.trio.filter(c => c !== left[0]);
          changed = fix(left[0], t.seat, `${name(t.seat, true)} showed ${name(t.asker)} a card on turn ${t.n} and has neither ${the(others[0])} nor ${the(others[1])}: so it was ${the(left[0])}.`) || changed;
        }
      }
      for (const kind of Object.keys(KINDS)) {
        const could = KINDS[kind].filter(c => poss[c]?.has(ENV));
        if (could.length === 1 && poss[could[0]].size > 1) {
          const c = could[0];
          for (const s of seats) changed = cut(c, s, `It’s the only ${kind === 'suspect' ? 'suspect' : kind === 'weapon' ? 'heirloom' : 'room'} that can be in the case file, so no one holds it.`) || changed;
        }
        const sealed = KINDS[kind].find(c => poss[c]?.size === 1 && poss[c].has(ENV));
        if (sealed) for (const c of KINDS[kind]) if (c !== sealed) changed = cut(c, ENV, `${the(sealed)} is in the case file: one of each kind.`) || changed;
      }
      for (const s of seats) {
        const known = cards.filter(c => poss[c].size === 1 && poss[c].has(s));
        const maybe = cards.filter(c => poss[c].has(s));
        if (known.length >= counts[s]) {
          for (const c of maybe) if (poss[c].size > 1) changed = cut(c, s, `${name(s, true)} ${s === me ? 'hold' : 'holds'} ${counts[s]} cards and all ${counts[s]} are known.`) || changed;
        } else if (maybe.length === counts[s]) {
          for (const c of maybe) if (poss[c].size > 1) changed = fix(c, s, `${name(s, true)} ${s === me ? 'hold' : 'holds'} ${counts[s]} cards, and only ${counts[s]} are still possible.`) || changed;
        }
      }
      // (a card no player can hold is in the case file)
      for (const c of cards) {
        if (poss[c].size > 1 && poss[c].has(ENV) && seats.every(s => !poss[c].has(s))) changed = fix(c, ENV, 'No one can hold it.') || changed;
      }
      if (!changed) break;
    }
  }

  function result() {
    const mark = (c, s) => {
      if (v.faceup.includes(c)) return 'up';
      const p = poss[c];
      if (mode === 'blank') return null;
      if (p.size === 1 && p.has(s)) return 'has';
      if (!p.has(s)) return 'not';
      return null;
    };
    const owner = c => (poss[c] && poss[c].size === 1 ? [...poss[c]][0] : null);
    const out = c => v.faceup.includes(c) || (mode !== 'blank' && owner(c) !== null && owner(c) !== ENV) || (mode === 'full' && poss[c] && !poss[c].has(ENV));
    const sealed = c => mode === 'full' && owner(c) === ENV;
    return { poss, why, tags, pass, mark, owner, out, sealed, mode };
  }
}