Last One Standing

@cache
def answers(board: str) -> dict[str, frozenset]:
    """Each card's yes answers, by card id."""
    return {c["id"]: frozenset(c["yes"]) for c in load(board)["cards"]}

def deal(board: str, seed: str) -> list[str]:
    """The 24 cards on the board this game, in the order they stand."""
    pool = [c["id"] for c in load(board)["cards"]]
    if load(board).get("fixed") or len(pool) <= SIZE:
        return deck.shuffled(pool, f"{seed}:board")[:SIZE]
    best = None
    for k in range(DEALS):
        cards = deck.shuffled(pool, f"{seed}:deal:{k}")[:SIZE]
        miss = balanced(board, cards)
        if best is None or miss < best[0]:
            best = (miss, cards)
        if not miss:
            break
    return best[1]

/** The questions a face answers yes to, from its spec. */
export function yes(f) {
  const out = [];
  if (f.hat) out.push('hat');
  if (f.glasses) out.push('glasses');
  if (f.earrings) out.push('earrings');
  if (f.beard) out.push('beard');
  if (f.mustache) out.push('mustache');
  if (f.style === 'bald') out.push('bald');
  else out.push(f.hair);
  if (LONG.has(f.style)) out.push('long');
  if (CURLY.has(f.style)) out.push('curly');
  if (UP.has(f.style)) out.push('up');
  if (f.freckles) out.push('freckles');
  if (f.cheeks) out.push('cheeks');
  if (f.smile) out.push('smile');
  if (f.neck) out.push('neck');
  return out;
}

def new(players: int, seed: str, now: float, settings: dict | None = None) -> dict:
    if players != 2:
        raise Illegal("Last One Standing is for two players.")
    rules = options(settings)
    cards = board.deal(rules["board"], seed)
    rng = random.Random(f"{seed}:secret")
    state = {
        "game": slug, "n": 2, "seed": seed, "board": rules["board"], "rules": {"board": rules["board"]},
        "_pace": moves.BOT_PACE[rules["bot_pace"]],
        "seq": 0, "logged": 0, "events": [],
        "cards": cards,
        # Each draws their card from a pile of their own, so both may hold the same one.
        "secret": [rng.randrange(len(cards)), rng.randrange(len(cards))],
        "down": [[], []],
        "phase": "ask", "first": int.from_bytes(seed.encode(), "big") % 2, "turn": None, "turns": 0,
        "qa": [], "pending": None,
        "winner": None, "guess": None, "final": None,
        "scores": [], "totals": [0, 0], "ready": [False, False],
    }
    state["turn"] = state["first"]
    log.event(state, "start", first=state["first"], board=rules["board"])
    return state

def ask(state, seat, action, now):
    """One of the board's questions: the game answers it from the other's card."""
    _my_turn(state, seat)
    q = action["q"]
    if q not in board.questions(state["board"]):
        raise Illegal("That isn’t one of this board’s questions.")
    yes = truth(state, other(seat), q)
    entry = {"id": len(state["qa"]) + 1, "seat": seat, "q": q, "answer": "yes" if yes else "no"}
    state["qa"].append(entry)
    log.event(state, "ask", seat=seat, q=q, answer=entry["answer"])
    if action.get("flip"):
        _flip(state, seat, ruled_out(state, q, yes), True)
    _pass(state)

def reply(state, seat, action, now):
    """Yes, No or Not sure to a question typed in the other's own words,
    from a game that was waiting on one when they stopped being a move. (A
    bot that once read it as one of the board's said which, `as`.)"""
    p = state["pending"]
    if state["phase"] != "answer" or not p:
        raise Illegal("There’s no question to answer.")
    if seat == p["seat"]:
        raise Illegal("The other player answers your question.")
    answer = action["answer"]
    if answer not in ANSWERS:
        raise Illegal("Answer yes, no or not sure.")
    read_as = action.get("as")
    if read_as is not None and read_as not in board.questions(state["board"]):
        read_as = None
    entry = {"id": len(state["qa"]) + 1, "seat": p["seat"], "text": p["text"], "answer": answer}
    if read_as:
        entry["as"] = read_as
    state["qa"].append(entry)
    log.event(state, "reply", seat=seat, asker=p["seat"], text=p["text"], answer=answer, **({"as": read_as} if read_as else {}))
    state["pending"] = None
    state["phase"] = "ask"
    if answer != "unsure":
        _pass(state)

def deciding(state: dict) -> list[tuple[int, str, str]]:
    if state["phase"] == "ask":
        return [(state["turn"], "ask", f"t{state['turns']}-{len(state['qa'])}")]
    if state["phase"] == "answer":
        p = state["pending"]
        return [(other(p["seat"]), "answer", f"a{p['id']}")]
    return []

def view(state: dict, seat) -> dict:
    mine = seat is not None
    phase = state["phase"]
    p = state["pending"]
    ends = phase == "over"
    can = {
        "ask": mine and phase == "ask" and state["turn"] == seat,
        "reply": mine and phase == "answer" and p["seat"] != seat,
        "flip": mine and not ends,
    }
    return {
        "game": slug, "seq": state["seq"], "n": 2, "seat": seat, "board": state["board"], "cards": list(state["cards"]),
        "phase": phase, "turn": state["turn"], "first": state["first"], "turns": state["turns"],
        "secret": state["secret"][seat] if mine else None,
        "down": list(state["down"][seat]) if mine else None,
        # How many each has standing, as you'd see across the table.
        "standing": [len(state["cards"]) - len(d) for d in state["down"]],
        "qa": [dict(e) for e in state["qa"]],
        "pending": dict(p) if p else None,
        "can": can,
        "winner": state["winner"],
        "final": ({**state["final"], "down": [list(d) for d in state["down"]]} if ends else None),
        "events": log.recent(state, seat),
    }

def choose(v: dict, level: str, rng) -> dict:
    if v["can"]["reply"]:
        return answer(v)
    left = candidates(v)
    them = v["standing"][1 - v["seat"]]
    if len(left) == 1:
        return {"type": "guess", "card": left[0]}
    if len(left) == 2 and ((level != "easy" and them <= 1) or (level == "easy" and rng.random() < 0.5)):
        return {"type": "guess", "card": rng.choice(left)}
    options = splits(v, left)
    if not options:
        # Nothing left to ask that tells these apart: guess among them.
        return {"type": "guess", "card": rng.choice(left)}
    if level == "hard":
        best = options[0][0]
        pick = rng.choice([q for worst, q in options if worst == best])
    elif level == "medium":
        pick = rng.choice(options[:5])[1]
    else:
        pick = rng.choice(options)[1]
    return {"type": "ask", "q": pick, "flip": True}

def options(raw: dict | None) -> dict:
    """A table's settings: the board, and how fast the bot plays."""
    boards = board.ids() or (board.DEFAULT,)
    return {
        "board": moves.choice(raw, "board", boards, board.DEFAULT if board.DEFAULT in boards else boards[0]),
        "bot_pace": moves.choice(raw, "bot_pace", tuple(moves.BOT_PACE), "brisk"),
    }

/** Size the cards to the room there is: 24 in the columns (3, 4, 6, 8 or
 * 12) that give the biggest pictures with a name you can read under each.
 * A card is as wide as its column and at most 1 : 1.26; where the rows are
 * shorter than that (a phone), the card is shorter and its picture
 * smaller, so the name keeps its room: one line, or two or three for a
 * board dealt a name that needs them ("Construction worker"). */
fitTray() {
  const box = this.el.traywrap.getBoundingClientRect();
  if (!box.width || !box.height || !this.tiles.length) return;
  const pad = 8;
  const W = box.width - 2 * pad, H = box.height - 2 * pad;
  const layout = (cols, lines) => {
    const rows = 24 / cols;
    const cw = Math.min(150, W / (cols + (cols - 1) * GAP + RIM));
    const ch = Math.min(cw * RATIO, (H - cw * ((rows - 1) * GAP + RIM)) / rows);
    const fs = Math.min(15, Math.max(10.5, cw * 0.105));
    const pic = Math.min(cw * (1 - 2 * PAD), ch - cw * (2 * PAD + SPACE) - (lines * fs * LEAD + 4));
    return { cols, lines, cw, ch, fs, pic };
  };
  const choose = lines => {
    // (of the ways that show a picture worth seeing, those with room for a
    // name if any have it, and of those the biggest picture)
    const all = [3, 4, 6, 8, 12].map(cols => layout(cols, lines));
    const seen = all.filter(o => o.pic >= FLOOR);
    const named = seen.filter(o => o.cw >= NAMED);
    const pool = named.length ? named : seen.length ? seen : all;
    let best = pool.reduce((a, b) => (b.pic > a.pic ? b : a));
    // (a tray keeps its columns unless another way is clearly bigger, so a
    // panel coming or going beside it doesn't rearrange the cards)
    const kept = pool.find(o => o.cols === this.cols);
    if (kept && kept !== best && kept.pic > best.pic * 0.85) best = kept;
    // (on the smallest phones there isn't room for all 24 at a size you can
    // see: four across at the window's width, and the tray scrolls inside itself)
    if (best.pic < FLOOR) {
      const cw = Math.min(80, W / (4 + 3 * GAP + RIM));
      best = { cols: 4, lines, cw, ch: cw * RATIO, fs: Math.max(10.5, cw * 0.105), pic: cw * (1 - 2 * PAD), tight: true };
      best.pic = Math.min(best.pic, best.ch - cw * (2 * PAD + SPACE) - (lines * best.fs * LEAD + 4));
    }
    return best;
  };
  // The cards' size, and every name fitted to its plate, a size smaller if
  // need be (one squeezed onto a single line, hardly at all). A name or two
  // that still won't fit get a line or two more on their own card, its picture
  // that much smaller; more than that, and it's not this many lines. Whether it worked.
  const apply = (o, last) => {
    this.el.traywrap.classList.toggle('tight', !!o.tight);
    this.cols = o.cols;
    const cw = Math.floor(o.cw);
    const s = this.el.tray.style;
    s.setProperty('--cols', o.cols);
    s.setProperty('--cw', `${cw}px`);
    s.setProperty('--ch', `${Math.floor(o.ch)}px`);
    s.setProperty('--pic', `${Math.floor(o.pic)}px`);
    s.setProperty('--fs', `${o.fs.toFixed(1)}px`);
    s.setProperty('--gap', `${Math.round(cw * GAP)}px`);
    for (const el of this.tiles) el.style.removeProperty('--pic');
    const min = o.lines === 1 ? 10 : 9.5;
    const long = this.tiles.filter(el => !fitName(el, { min }));
    if (long.length > 2 && !last) return false;
    for (const el of long) {
      for (let more = 1; more <= 2; more++) {
        el.style.setProperty('--pic', `${Math.floor(o.pic - more * o.fs * LEAD)}px`);
        if (fitName(el, { min: 9.5 })) break;
      }
    }
    return true;
  };
  // (the fewest lines the names dealt fit in at a readable size: a board of
  // short names gives its pictures the room a second line would take; and
  // rather than a tray that scrolls, two lines and a few cards with three)
  for (const lines of [1, 2, 3]) {
    const o = choose(lines);
    if (apply(o, lines === 3 || (lines === 2 && !o.tight && choose(3).tight))) break;
  }
}

/**
 * The board's questions that what's typed so far most likely asks, best
 * first: [{ q, score, hits }] (hits: the typed words that found it). And
 * `cards`: cards the text names outright, for a guess. `partial` says the
 * last word is still being typed (the text doesn't end in a space or a
 * stop), so it may be the start of a word.
 */
export function rank(text, board, { limit = LIMIT } = {}) {
  const { qs, cards, own, known } = prepare(board);
  const all = words(text);
  const partial = /[a-z0-9']$/i.test(String(text));
  const typed = all.map((w, i) => ({ w, partial: partial && i === all.length - 1, known: known(w) }))
    .filter(x => (meant(x.w) || own.has(x.w)) && (x.w.length > 1 || !x.partial));
  const spaced = ` ${all.join(' ')} `;
  const found = [];
  for (const x of qs) {
    let score = 0;
    const hits = [];
    for (const { w, partial: p, known: k } of typed) {
      let best = 0;
      for (const [s, t] of x.terms) best = Math.max(best, fit(w, p, k, s, t) * t.weight);
      if (best > 0) { score += best; hits.push(w); }
    }
    for (const ph of x.phrases) if (spaced.includes(ph)) score += 2;
    // (typed just as the board asks it)
    if (all.length && x.plain === all.join(' ')) score += 10;
    if (score > 0) found.push({ q: x.q, order: x.order, score, hits });
  }
  found.sort((a, b) => b.score - a.score || a.order - b.order);
  const top = found[0]?.score || 0;
  const questions = found.filter(f => f.score >= FLOOR && f.score >= REL * top).slice(0, limit)
    .map(({ q, score, hits }) => ({ q, score: Math.round(score * 100) / 100, hits }));
  // A card named outright: what's typed is its whole name, give or take the
  // words round it ("is it the sea turtle?"), the last word perhaps begun.
  const named = [];
  if (typed.length) {
    for (const c of cards) {
      // (a name's possessive is name enough: "Frankenstein" is Frankenstein's monster)
      const whose = c.words.find(n => n.endsWith("'s"));
      const said = c.words.every(n => typed.some(({ w, partial: p }) => sameWord(n, w, p)))
        || (whose && typed.some(({ w, partial: p }) => sameWord(whose, w, p)));
      const only = typed.every(({ w, partial: p }) => c.words.some(n => sameWord(n, w, p)));
      if (said && only) named.push(c.card);
    }
  }
  return { questions, cards: named.slice(0, 2), partial };
}

/** A few words to try on this board, for the box's hint. */
export const tryWords = board => board.hint || board.questions.slice(0, 3).map(q => (q.words || [])[0]).filter(Boolean);

/** What's yours to do now and where: { kind, el, key, kicker, title, sub },
 * or null. Flipping comes first (what the answers rule out), then, on
 * your turn, a guess when one card's left, else a question. */
cueWant() {
  const { v, t } = this;
  if (!v || v.phase === 'over' || t.you === null || t.seats[t.you]?.bot || this.guessing) return null;
  const c = v.can || {};
  if (c.reply) return null;
  const game = `${this.table.code}:${t.game_no}`;
  const off = this.offer();
  if (off) {
    const a = off.last;
    const people = ['person', 'worker'].includes(this.board.noun);
    return {
      kind: 'flip', el: this.slots[2].el, key: `${game}:flip:${this.answers().length}`,
      kicker: a ? `They said ${a.yes ? 'yes' : 'no'}` : 'Your move',
      title: people ? 'Flip down who it isn’t' : 'Flip down what it isn’t',
      sub: `${off.cards.length === 1 ? 'The card' : `The ${off.cards.length} cards`} crossed in red: one press flips ${off.cards.length === 1 ? 'it' : 'them all'}.`,
    };
  }
  if (!c.ask) return null;
  const left = this.standingMine();
  if (left.length === 1) {
    return { kind: 'guess', el: this.slots[2].el, key: `${game}:guess:${v.turns}`, title: 'Make your guess', sub: `Only ${this.card(left[0]).name} is left standing.` };
  }
  const [a, b] = tryWords(this.board);
  return { kind: 'ask', el: this.el.input, key: `${game}:ask:${v.turns}`, title: 'Ask a question', sub: `Type a word about their card, like ${a} or ${b}, and pick a question.` };
}

/** The cards still standing that your answers rule out (the helper's
 * offer), and whether the latest answer is what ruled any out. Every
 * answer counts, so a flip put off till later is still offered. */
offer() {
  const v = this.v;
  if (!assistOn('offer') || this.t.you === null || v.phase === 'over') return null;
  const all = this.answers();
  if (!all.length) return null;
  const last = all.at(-1);
  const out = this.standingMine().filter(i => this.against(i).length);
  if (!out.length) return null;
  const fresh = out.some(i => this.card(i).yes.has(last.q) !== last.yes);
  return { cards: out, last: fresh ? last : null };
}