Sixty-Six

def _deal(state: dict) -> None:
    """Three each from the dealer's opponent, the trump card turned, three
    each; the rest is the stock, face down over it."""
    dealer = (state["first_dealer"] + state["deals"]) % 2
    elder = 1 - dealer
    pack = deck.shuffled(cards(), f"{state['seed']}:{state['deals']}")
    hands = [[], []]
    for seat in (elder, dealer):
        hands[seat] += [pack.pop() for _ in range(3)]
    turned = pack.pop()
    for seat in (elder, dealer):
        hands[seat] += [pack.pop() for _ in range(3)]
    state["deals"] += 1
    state.update(
        dealer=dealer, hands=hands, stock=pack, trump_card=turned, trump=turned[1],
        phase="play", turn=elder, leader=elder, trick=[], done=[], tricks=[0, 0], taken=[0, 0],
        marriages=[], declared=None, exchanged=None, closed=None, draw=None, shown=[[], []], outcome=None,
    )
    log.event(state, "deal", dealer=dealer, trump_card=turned, deal=state["deals"])

def beats(card: str, led: str, trump: str) -> bool:
    """Whether `card`, played second, takes the trick `led` opened."""
    if card[1] == led[1]:
        return higher(card, led)
    return card[1] == trump

def _draw(state: dict, first: int) -> None:
    """The winner draws, then the other; the last face-down card's taker's
    opponent takes the trump card."""
    got_trump = None
    for seat in (first, 1 - first):
        if state["stock"]:
            state["hands"][seat].append(state["stock"].pop())
        else:
            got_trump = state["trump_card"]
            state["hands"][seat].append(got_trump)
            state["shown"][seat].append(got_trump)
            state["trump_card"] = None
    log.event(state, "draw", first=first, trump_card=got_trump, left=stock_left(state))

def legal(hand: list[str], trick: list[dict], trump: str, strict: bool) -> list[str]:
    """Anything while the stock lasts. Once it's closed or gone, the second
    player must follow suit and win if they can; without the suit, trump if
    they can; else anything."""
    if not trick or not strict:
        return list(hand)
    led = trick[0]["card"]
    same = [c for c in hand if c[1] == led[1]]
    if same:
        return [c for c in same if higher(c, led)] or same
    trumps = [c for c in hand if c[1] == trump]
    return trumps or list(hand)

def marry(state, seat, action, now):
    _on_lead(state, seat)
    suit = action.get("suit")
    if state["draw"] is not None:
        raise Illegal("Draw first, or close the stock.")
    if state["declared"]:
        raise Illegal("One marriage a lead.")
    if not isinstance(suit, str) or len(suit) != 1 or suit not in SUITS:
        raise Illegal("Declare a marriage in a suit.")
    if suit not in marriages_held(state, seat):
        raise Illegal("You need the king and queen of that suit.")
    worth = 40 if suit == state["trump"] else 20
    state["marriages"].append({"seat": seat, "suit": suit, "points": worth})
    state["declared"] = suit
    for c in (f"K{suit}0", f"Q{suit}0"):
        if c not in state["shown"][seat]:
            state["shown"][seat].append(c)
    log.event(state, "marriage", seat=seat, suit=suit, points=worth, counts=state["tricks"][seat] > 0)

def points(state: dict, seat: int) -> int:
    """A seat's card points so far: its tricks, and its marriages once it has
    taken a trick."""
    total = state["taken"][seat]
    if state["tricks"][seat]:
        total += pending_marriages(state, seat)
    return total

def can_exchange(state: dict, seat: int) -> bool:
    """Only at the start of a hand, before anyone has played a card, by
    whoever holds the trump 9: on the lead or not."""
    return (state["phase"] == "play" and not state["done"] and not state["trick"] and state["closed"] is None
            and state["trump_card"] is not None and low_trump(state) in state["hands"][seat])

def can_close(state: dict, seat: int) -> bool:
    """Whenever you're leading and the stock has cards: before you draw, or after."""
    return (state["phase"] == "play" and state["turn"] == seat and not state["trick"] and state["closed"] is None
            and stock_left(state) > 0)

def judge(pts, tricks, seat: int) -> tuple[int, int, str]:
    """Who wins a hand and for how many game points when `seat` claims 66:
    (winner, game points, how it ended). Pure, so the bots' search can score
    with it. A correct claim takes 1 game point, 2 if the other has under 33
    (and a trick), 3 if the other has taken no trick at all; a claim short of
    66 gives the other 1. `pts` and `tricks` are per seat."""
    other = 1 - seat
    if pts[seat] >= GOAL:
        gp = 3 if not tricks[other] else 2 if pts[other] < SCHNEIDER else 1
        return seat, gp, "claim"
    return other, 1, "short"

def _settle(state: dict, seat: int, claimed: bool) -> None:
    """Score the hand: `seat` claimed 66 (right or wrong), or every card is
    played and nobody did (`claimed` False: no one scores)."""
    pts = [points(state, 0), points(state, 1)]
    if claimed:
        won, gp, result = judge(pts, state["tricks"], seat)
        log.event(state, "claim", seat=seat, ok=won == seat)
    else:
        won, gp, result = None, 0, "unclaimed"
    rounds.score(state, [gp if s == won else 0 for s in range(2)])
    state["outcome"] = {
        "winner": won, "points": gp, "how": result, "by": seat if claimed else None,
        "card_points": pts, "tricks": list(state["tricks"]),
        "closed": state["closed"]["seat"] if state["closed"] else None,
    }
    log.event(state, "hand", **state["outcome"])
    state["turn"] = None
    state["draw"] = None
    done = max(state["totals"]) >= TARGET
    if done:
        log.event(state, "won", seat=won)
    rounds.end(state, last=done)

def deciding(state: dict) -> list[tuple[int, str, str]]:
    phase = state["phase"]
    if phase == "scored":
        return rounds.ready_deciding(state)
    if phase != "play":
        return []
    turn = state["turn"]
    step = (f"{len(state['done'])}.{len(state['trick'])}.{len(state['marriages'])}"
            f".{1 if state['exchanged'] else 0}{1 if state['closed'] else 0}{1 if state['draw'] is not None else 0}")
    fresh = not state["done"] and not state["trick"] and not state["marriages"] and not state["exchanged"] and not state["closed"]
    kind = "draw" if state["draw"] == turn else "open" if fresh else "play"
    out = [(turn, kind, f"p{state['deals']}-{step}-{turn}")]
    other = 1 - turn
    if can_exchange(state, other):
        # The dealer holding the trump 9 may exchange it before the first lead.
        out.append((other, "exchange", f"p{state['deals']}-x-{other}"))
    return out

class SixtySixContract(TableGameContract, SimpleTestCase):
    """Sixty-Six meets what every table game must (tests/table_contract.py)."""

    game = game

    def scramble(self, state, keep, rng):
        # The other hand (beyond what it's shown) and the stock's face-down
        # cards: dealt out again, each pile its own size.
        other = 1 - keep
        shown = state["shown"][other]
        hidden = [c for c in state["hands"][other] if c not in shown]
        pool = hidden + state["stock"]
        rng.shuffle(pool)
        state["hands"][other] = list(shown) + pool[:len(hidden)]
        state["stock"] = pool[len(hidden):]

def counted(v: dict) -> tuple[list[int], list[int]]:
    """What a careful player carries in their head: each seat's card points
    (marriages only once it has a trick) and the marriage points still
    waiting for its first trick."""
    taken, married = _taken(v), _married(v)
    pts = [taken[s] + (married[s] if v["tricks"][s] else 0) for s in range(2)]
    pending = [0 if v["tricks"][s] else married[s] for s in range(2)]
    return pts, pending

def choose(state: dict, seat: int, level: str, rng) -> dict:
    v = rules.view(state, seat)
    if v["phase"] == "scored":
        return {"type": "ready"}
    can = v["can"]
    if can.get("claim") and _claims(v, level, rng):
        return {"type": "claim"}
    if can.get("exchange"):
        return {"type": "exchange"}
    if can.get("pass"):
        return {"type": "pass"}
    if can.get("draw"):
        # Before drawing: a hard bot may close on the hand it holds.
        if can.get("close") and level == "hard" and _close(v, level, rng):
            return {"type": "close"}
        return {"type": "draw"}
    if not v["trick"]:
        if can.get("close") and level != "easy" and _close(v, level, rng):
            return {"type": "close"}
        if can.get("marry"):
            return {"type": "marry", "suit": can["marry"][0]}
    return {"type": "play", "card": _play(v, level, rng)}

def _deals(v: dict, rng) -> list[tuple]:
    """The other's hands this seat should play against: every card it can't
    place is theirs once the stock is gone; otherwise a sample."""
    other = v["opponent"]
    unseen = _unseen(v)
    shown = list(v["shown"][other])
    need = v["counts"][other] - len(shown)
    if need < 0 or need > len(unseen):
        return []
    if need == len(unseen):
        return [tuple(sorted(shown + unseen))]
    out = []
    for _ in range(SAMPLES):
        out.append(tuple(sorted(shown + rng.sample(unseen, need))))
    return out

def _searched(v: dict, rng) -> str:
    """The card that scores best, summed over the other's possible hands."""
    _fresh()
    deals = _deals(v, rng)
    if not deals:
        return _follow(v, "medium") if v["trick"] else _lead(v, "medium", rng)
    score = {c: 0.0 for c in v["legal"]}
    for theirs in deals:
        for c in v["legal"]:
            score[c] += _value(v, theirs, c)
    # Ties go to the cheaper card (keep the good ones for later).
    hand, trump = v["mine"], v["trump"]
    return max(v["legal"], key=lambda c: (score[c], -_cost(c, hand, trump), c))

// Sixty-Six: two-handed, as David's family plays it (docs/sixty-six.md),
// against a bot or a friend at a shared table. The lobby and waiting room are
// the room kit's (../room/kit/), the cards and table styles the card room's
// (../cards/kit/); this game brings its rules and its table.

import { start } from '../room/kit/room.js';
import { look } from '../cards/kit/looks.js';
import { rules } from './rules.js';
import { play, sixtySixOptions, shareText, progress } from './table.js';

start({
  game: 'sixty-six',
  title: 'Sixty-Six',
  kicker: 'Card game · 2 players',
  blurb: 'Race to 66 card points, counted in your head. Marry a king and queen, close the stock when you’re sure, and claim 66 first.',
  // Always two at the table: a bot takes the other seat if nobody does.
  min: 2,
  max: 2,
  defaultBots: 1,
  fill: true,
  rules,
  play,
  look,
  devices: 'desktop',
  spectate: true,
  firstRun: true,
  cues: true,
  progress,
  shareText,
  shortcuts: 'Single keys, shown on the buttons: 1 to 6 play a card, D draws, M declares a marriage, E exchanges, X closes, C claims 66, P says you have no claim, O sorts.',
  options: () => sixtySixOptions(),
  // The one table setting (tables/sixty_six/rules.py options()): the game is
  // 24 cards, to 7, no last-trick bonus, as David's family plays it.
  settings: [{
    key: 'bot_pace', label: 'Bot speed', value: 'brisk',
    hint: 'Relaxed is easier to follow.',
    choices: [['brisk', 'Brisk'], ['relaxed', 'Relaxed']],
  }],
});

// The helpers, on by default (docs/design-language.md, "Options"), each with
// its own row to turn it off; and Banners, a preference (Playing).
const HELPERS = [
  { key: 'legal', label: 'Light up cards I can play', hint: 'Once the stock’s closed or gone, dims the cards you can’t play.' },
  { key: 'known', label: 'Remember what they’ve shown', hint: 'Cards you know your opponent holds (a marriage, the trump card they took) stay on their seat.' },
];

/** The table shows the play a move at a time (room/kit/motion.js Cues):
 * each card flies from its player to the trick; a finished trick is ringed
 * and swept to its winner, who draws, then the other; an exchange and a
 * close play out where they happen; only then comes the next lead. A first
 * look, a new deal or a new game shows the table as it is (a new deal is
 * dealt out). `arrived`: cards new in your hand, kept from view until the
 * draw or exchange that brings them lands. */
syncTable(was, arrived) {
  const v = this.v;
  const now = { deal: v.deal, done: v.done.length, cards: v.trick.map(p => ({ ...p })) };
  const copy = x => ({ deal: x.deal, done: x.done, cards: x.cards.map(p => ({ ...p })) });
  const stockNow = () => ({ deal: v.deal, left: v.stock_left, card: v.trump_card, closed: !!v.closed });
  if (!was || !this.planned || this.planned.deal !== v.deal || v.done.length < this.planned.done) {
    const newDeal = !!this.planned && this.planned.deal !== v.deal;
    this.cues.skip();
    this.landing.clear();
    this.held.clear();
    this.sweeping = null;
    this.shownTrick = copy(now);
    this.planned = copy(now);
    this.stockShown = stockNow();
    this.wedShown = new Set(v.marriages.map(m => `${m.seat}${m.suit}`));
    this.lastEvent = v.events.at(-1)?.id ?? 0;
    // A new hand is dealt out, from the dealer's seat (not a late arrival's).
    const fresh = !v.done.length && !v.trick.length;
    if (fresh && (newDeal || (!was && v.hand === 0))) this.cues.add(this.dealCue());
    return;
  }
  const plan = this.planned;
  const play = p => { plan.cards.push({ ...p }); this.cues.add(this.playCue(p)); };
  const mine = [...arrived];
  const fresh = v.events.filter(e => e.id > (this.lastEvent ?? 0));
  this.lastEvent = v.events.at(-1)?.id ?? this.lastEvent;
  for (const e of fresh) {
    if (e.type === 'trick' && e.no > plan.done) {
      const t = v.done[e.no - 1];
      if (!t) continue;
      for (const p of t.cards) if (!plan.cards.some(x => x.seat === p.seat)) play(p);
      this.cues.add(this.sweepCue(t, e.no - 1));
      plan.done = e.no;
      plan.cards = [];
    } else if (e.type === 'draw') {
      // The winner's card first, then the other's; yours is the one that
      // arrived in your hand (or the trump card, if it came to you).
      const order = [e.first, 1 - e.first];
      const cards = order.map(s => {
        if (!this.you(s)) return null;
        if (e.trump_card && s !== e.first) return mine.includes(e.trump_card) ? (mine.splice(mine.indexOf(e.trump_card), 1), e.trump_card) : null;
        return mine.length ? mine.shift() : null;
      });
      for (const c of cards) if (c) this.held.add(c);
      this.cues.add(this.drawCue(e, order, cards));
    } else if (e.type === 'exchange') {
      const got = this.you(e.seat) && mine.includes(e.took) ? e.took : null;
      if (got) { mine.splice(mine.indexOf(got), 1); this.held.add(got); }
      this.cues.add(this.exchangeCue(e, got));
    } else if (e.type === 'close') {
      this.cues.add(this.closeCue(e));
    } else if (e.type === 'marriage') {
      this.cues.add(this.marriageCue(e));
    }
  }
  for (const p of now.cards) if (!plan.cards.some(x => x.seat === p.seat)) play(p);
  // It's your turn and there's a lot still to show: the room catches up,
  // still playing the last move (and the last trick's sweep).
  if (this.myTurn()) this.cues.catchUp();
}