Michigan Rails

def parse(data: dict) -> Map:
    """A map from its file's JSON, checked: every route and ticket names
    real cities, doubles name each other, colors and ferries make sense."""
    cities = data["cities"]
    routes = {r["id"]: dict(r) for r in data["routes"]}
    tickets = {t["id"]: dict(t) for t in data["tickets"]}
    by_city = {c: [] for c in cities}
    for rid, r in routes.items():
        for end in (r["a"], r["b"]):
            if end not in cities:
                raise ValueError(f"Route {rid} goes to {end!r}, which isn't a city on the map.")
            by_city[end].append(rid)
        if r["color"] not in COLORS and r["color"] != GREY:
            raise ValueError(f"Route {rid} is {r['color']!r}: say one of {', '.join(COLORS)} or grey.")
        if not 1 <= r["length"] <= 8:
            raise ValueError(f"Route {rid} is {r['length']} long; routes are 1 to 8.")
        r.setdefault("tunnel", False)
        r["ferry"] = int(r.get("ferry") or 0)
        if r["ferry"] > r["length"]:
            raise ValueError(f"Ferry {rid} needs more locomotives than it has spaces.")
        pair = r.get("pair")
        if pair is not None:
            other = routes.get(pair)
            if not other or other.get("pair") != rid or {other["a"], other["b"]} != {r["a"], r["b"]}:
                raise ValueError(f"Route {rid}'s double, {pair!r}, isn't its twin.")
    for tid, t in tickets.items():
        if t["a"] not in cities or t["b"] not in cities:
            raise ValueError(f"Ticket {tid} names a city that isn't on the map.")
    return Map(id=data["id"], name=data.get("name", data["id"]), cities=cities, routes=routes, tickets=tickets,
               by_city=by_city)

def track_shape(p0, p1, n, side, bow=False):
    """A track for n cars from p0 to p1, as its corners and the cars on each
    leg. Straight when the stops are far enough apart (any spare track is
    shared out by lay()); else bent as the published maps bend theirs, with
    every car on a straight leg and each corner in a gap between cars: one
    corner (a V) where it isn't too sharp, else out, along and back (three
    legs). `side` is the way it bends: +1 left, -1 right, from p0 to p1."""
    c = math.dist(p0, p1)
    ux, uy = (p1[0] - p0[0]) / c, (p1[1] - p0[1]) / c
    nx, ny = uy * side, -ux * side
    if bow and n > 1:  # a long track bowed clear of a neighbor: a shallow V
        apex = (p0[0] + ux * c / 2 + nx * c * BOW, p0[1] + uy * c / 2 + ny * c * BOW)
        return [p0, apex, p1], [(n + 1) // 2, n // 2]
    if n == 1 or c >= run_length(n) + 2 * END:
        return [p0, p1], [n]

    def leg(k, ends):  # a leg's length: its cars, half a gap at each corner, END at a stop
        return run_length(k) + ends * END + (2 - ends) * GAP / 2

    k1 = (n + 1) // 2
    l1, l2 = leg(k1, 1), leg(n - k1, 1)
    if l1 + l2 > c and abs(l1 - l2) < c:
        along = (l1 * l1 - l2 * l2 + c * c) / (2 * c)
        out = math.sqrt(max(l1 * l1 - along * along, 0))
        corner = math.degrees(math.acos(max(-1, min(1, (l1 * l1 + l2 * l2 - c * c) / (2 * l1 * l2)))))
        if corner >= MIN_CORNER or n < 3:
            apex = (p0[0] + ux * along + nx * out, p0[1] + uy * along + ny * out)
            return [p0, apex, p1], [k1, n - k1]
    k = max(1, n // 4) if n >= 4 else 1
    l1, l2 = leg(k, 1), leg(n - 2 * k, 0)
    lean = math.acos(max(-1, min(1, (c - l2) / (2 * l1))))
    q1 = (p0[0] + (ux * math.cos(lean) + nx * math.sin(lean)) * l1, p0[1] + (uy * math.cos(lean) + ny * math.sin(lean)) * l1)
    q2 = (q1[0] + ux * l2, q1[1] + uy * l2)
    return [p0, q1, q2, p1], [k, n - 2 * k, k]

def new(players: int, seed: str, now: float, settings: dict | None = None) -> dict:
    if not min_players <= players <= max_players:
        raise Illegal("Michigan Rails is for two to five players.")
    rules = options(settings)
    m = board.load(rules["map"])
    cards = deck.shuffled([c for c in COLORS for _ in range(EACH_COLOR)] + [LOCO] * LOCOS, f"{seed}:cards")
    hands = [{k: 0 for k in KINDS} for _ in range(players)]
    for _ in range(HAND):
        for s in range(players):
            hands[s][cards.pop()] += 1
    longs = deck.shuffled(m.long, f"{seed}:long")
    regular = deck.shuffled(m.regular, f"{seed}:tickets")
    offers = []
    for s in range(players):
        offers.append({"ids": [longs.pop(), regular.pop(), regular.pop(), regular.pop()], "keep": 2})
    # (The long tickets no one was dealt leave the game, unseen.)
    first = int.from_bytes(seed.encode(), "big") % players
    state = {
        "game": slug, "n": players, "seed": seed, "map": m.id,
        "rules": {"map": m.id}, "_pace": moves.BOT_PACE[rules["bot_pace"]],
        "seq": 0, "logged": 0, "events": [],
        "hands": hands, "deck": cards, "discards": [], "faceup": [None] * FACE_UP, "shuffles": 0,
        "ticket_deck": regular, "tickets": [[] for _ in range(players)], "offers": offers,
        "trains": [TRAINS] * players, "stations": {}, "claimed": {}, "points": [0] * players,
        "phase": "tickets", "first": first, "turn": None, "turns": 0, "drawn": 0, "tunnel": None,
        "ending": None, "left": None, "passes": 0, "last": None,
        "final": None, "winners": None,
        "scores": [], "totals": [0] * players, "ready": [False] * players,
    }
    _refill(state)
    log.event(state, "start", first=first)
    return state

MOVES = {"draw": draw, "claim": claim, "tunnel": tunnel, "station": station, "tickets": draw_tickets,
         "keep": keep, "pass": pass_turn}

def payment(hand: dict, length: int, color: str, locos: int = 0):
    """The plainest way to pay `length` cards of `color` (LOCO: locomotives
    only) with at least `locos` locomotives: as few locomotives as can be.
    None if this hand can't."""
    if color == LOCO:
        return {LOCO: length} if hand[LOCO] >= length else None
    use = min(hand[color], length - locos)
    wild = length - use
    if wild > hand[LOCO]:
        return None
    return {k: v for k, v in ((color, use), (LOCO, wild)) if v}

def why_not_route(state: dict, seat: int, rid) -> str | None:
    """Why this seat can't claim this route now (whatever its cards), or None."""
    m = the_map(state)
    r = m.routes.get(rid) if isinstance(rid, str) else None
    if r is None:
        return "Pick a route on the map."
    if rid in state["claimed"]:
        return "That route is taken."
    if state["trains"][seat] < r["length"]:
        return f"You have {state['trains'][seat]} trains left; that route takes {r['length']}."
    pair = r.get("pair")
    if pair and pair in state["claimed"]:
        if state["claimed"][pair] == seat:
            return "You can't claim both routes of a double."
        if state["n"] < DOUBLES_FROM:
            return f"With {state['n']} players, only one route of a double is used."
    return None

def claim(state, seat, action, now):
    """Claim a route with cards of one color (any one, on a grey route),
    locomotives wild; a ferry needs its locomotives. A tunnel may cost more
    (flip())."""
    _fresh(state, seat)
    rid = action.get("route")
    why = why_not_route(state, seat, rid)
    if why:
        raise Illegal(why)
    r = the_map(state).routes[rid]
    cards, used = _paid(state, seat, action, r["length"], r["color"], r["ferry"])
    if not r["tunnel"]:
        _spend(state, seat, cards)
        return _claimed(state, seat, rid, cards)
    # A tunnel: the cards are laid down, then the deck's top three turned up.
    _spend(state, seat, cards, to_discards=False)
    flipped = [c for c in (_deal_one(state) for _ in range(TUNNEL_FLIP)) if c is not None]
    extra = sum(1 for c in flipped if c == LOCO or (used != LOCO and c == used))
    log.event(state, "tunnel", seat=seat, route=rid, flipped=flipped, extra=extra, color=used)
    if not extra:
        state["discards"] += flipped
        state["discards"] += [k for k, v in cards.items() for _ in range(v)]
        return _claimed(state, seat, rid, cards)
    state["tunnel"] = {"seat": seat, "route": rid, "laid": cards, "color": used, "flipped": flipped, "extra": extra}
    state["last"] = {"seat": seat, "kind": "tunnel", "route": rid, "flipped": flipped, "extra": extra}

def borrowed(state: dict, seat: int, tickets: list[str]) -> dict:
    """Each of this seat's stations lends it one route of another player's
    into its city: the ones that complete the most of these tickets' points.
    {city: route id or None}."""
    m = the_map(state)
    mine = [board.ends(m, rid) for rid in own_routes(state, seat)]
    cities = sorted(c for c, s in state["stations"].items() if s == seat)
    choices = [[None] + [rid for rid in m.by_city[c] if rid in state["claimed"] and state["claimed"][rid] != seat]
               for c in cities]
    best, pick = None, {c: None for c in cities}
    for combo in product(*choices):
        edges = mine + [board.ends(m, rid) for rid in combo if rid]
        score = sum(m.tickets[t]["points"] if _connected(edges, m.tickets[t]["a"], m.tickets[t]["b"])
                    else -m.tickets[t]["points"] for t in tickets)
        if best is None or score > best:
            best, pick = score, dict(zip(cities, combo))
    return pick

def longest_path(state: dict, seat: int) -> int:
    """The longest continuous path of this seat's own routes, in trains: a
    trail that may pass through a city more than once but uses each route
    once. Stations don't count."""
    m = the_map(state)
    edges = [(rid, *board.ends(m, rid), m.routes[rid]["length"]) for rid in own_routes(state, seat)]
    at: dict = {}
    for rid, a, b, w in edges:
        at.setdefault(a, []).append((rid, b, w))
        at.setdefault(b, []).append((rid, a, w))
    best = 0

    def walk(city, used, length):
        nonlocal best
        best = max(best, length)
        for rid, nxt, w in at.get(city, ()):
            if rid not in used:
                used.add(rid)
                walk(nxt, used, length + w)
                used.discard(rid)
    for city in at:
        walk(city, set(), 0)
    return best

def _tiebreak(seats: list[dict]) -> list[int]:
    """Level on points: most tickets completed, then fewest stations built,
    then the Michigan Express."""
    return [x["completed"] * 100 + x["stations_left"] * 10 + (1 if x["express"] else 0) for x in seats]

def view(state: dict, seat) -> dict:
    m = the_map(state)
    n = state["n"]
    mine = seat is not None
    phase = state["phase"]
    offer = state["offers"][seat] if mine else None
    my_turn = mine and phase == "play" and state["turn"] == seat
    fresh = my_turn and not state["drawn"] and not state["tunnel"] and not offer
    done = ticket_status(state, seat) if mine else {}
    can = {"draw": [], "claim": {}, "station": [], "tickets": False, "pass": False}
    if my_turn and not offer and not state["tunnel"]:
        second = state["drawn"] == 1
        if state["deck"] or state["discards"]:
            can["draw"].append("deck")
        can["draw"] += [i for i, c in enumerate(state["faceup"]) if c is not None and not (second and c == LOCO)]
    if fresh:
        for rid in m.routes:
            colors = route_colors(state, seat, rid)
            if colors:
                can["claim"][rid] = colors
        if len(state["stations"]) < len(m.cities):
            can["station"] = station_colors(state, seat)
        can["tickets"] = bool(state["ticket_deck"])
        can["pass"] = not _anything(state, seat)
    t = state["tunnel"]
    return {
        "game": slug, "seq": state["seq"], "n": n, "seat": seat, "map": state["map"],
        "phase": phase, "turn": state["turn"], "turns": state["turns"], "first": state["first"],
        "drawn": state["drawn"],
        "faceup": list(state["faceup"]), "deck": len(state["deck"]), "discards": len(state["discards"]),
        "ticket_deck": len(state["ticket_deck"]),
        "hand": dict(state["hands"][seat]) if mine else None,
        "hands": [sum(h.values()) for h in state["hands"]],
        "tickets": [_ticket(m, x, done[x]) for x in state["tickets"][seat]] if mine else None,
        "ticket_counts": [len(x) for x in state["tickets"]],
        "offer": {"tickets": [_ticket(m, x) for x in offer["ids"]], "keep": min(offer["keep"], len(offer["ids"]))}
        if offer else None,
        "choosing": [s for s in range(n) if state["offers"][s]],
        "trains": list(state["trains"]),
        "stations": dict(state["stations"]),
        "stations_left": [_stations_left(state, s) for s in range(n)],
        "station_cost": station_cost(state, seat) if mine and _stations_left(state, seat) else None,
        "claimed": dict(state["claimed"]),
        "points": list(state["points"]),
        "tunnel": {"seat": t["seat"], "route": t["route"], "laid": dict(t["laid"]), "color": t["color"],
                   "flipped": list(t["flipped"]), "extra": t["extra"],
                   "can_pay": tunnel_payment(state, seat) is not None if seat == t["seat"] else None} if t else None,
        "ending": state["ending"], "left": state["left"],
        "can": can,
        "last": dict(state["last"]) if state["last"] else None,
        "final": state["final"], "winners": state["winners"],
        "events": log.recent(state, seat),
    }

LEVEL = {
    "easy": {"wander": 0.15, "late": 3, "mid_budget": 0.5, "lambda": 0.15, "budget": 0.6, "noise": 6.0, "face": 0.4,
             "loco": False, "critical": False, "more_tickets": 34, "station": False},
    "medium": {"wander": 0, "late": 4, "mid_budget": 0.6, "lambda": 0.3, "budget": 0.55, "noise": 0.3, "face": 1.0,
               "loco": False, "critical": False, "more_tickets": 28, "station": True},
    "hard": {"wander": 0, "late": 4, "mid_budget": 0.5, "lambda": 0.35, "budget": 0.55, "noise": 0.0, "face": 1.0,
             "loco": True, "critical": True, "more_tickets": 15, "station": True},
}

# Ticket appetite, for measuring riskier bots (tools/michigan-rails/strength.py);
# a level that doesn't say takes these, which are how the levels above play.
# risk: how hard a set of tickets over budget is marked down (0 ignores the
# budget); long_bonus: points added for keeping the deal's long ticket;
# spare: draw tickets with some still open once the plan leaves this many
# trains over (None: only with every ticket done); others_min: no ticket
# draw once another player is down to this many trains.
APPETITE = {"risk": 1.0, "long_bonus": 0.0, "spare": None, "others_min": 12}

/** Take tickets: a whole turn, so the ticket deck asks first, in place
 * (docs/design-language.md, "Confirm in place"). The first press lifts it
 * and the status line asks; a second press (or T) takes them. The
 * question goes after 6s, or when anything else happens. */
takeTickets() {
  const v = this.v;
  if (!v || !this.seated()) return;
  if (!this.myTurn()) return this.hint(v.phase === 'play' ? `It’s ${this.name(v.turn)}’s turn.` : 'Not now.');
  if (!v.can?.tickets) return this.hint(v.drawn ? 'Draw your second card: tickets are a whole turn.' : !v.ticket_deck ? 'There are no tickets left.' : 'Not now.');
  if (!this.ticketsAsked) return this.askTickets(true);
  this.askTickets(false);
  this.act({ type: 'tickets' });
}

pickOnMap(t, how) {
  const v = this.v;
  if (!v) return;
  if (t.kind === 'city') return this.citySheet(t.id);
  const rid = t.id;
  const r = this.routes[rid];
  const owner = v.claimed[rid];
  if (this.t.you === null) return this.hint(`${this.routeName(rid)}${owner !== undefined ? `: ${this.name(owner)}’s` : ''}. You’re watching.`);
  if (owner !== undefined) return this.hint(`${this.routeName(rid)} is ${this.you(owner) ? 'yours' : `${this.name(owner)}’s`}.`);
  if (v.phase !== 'play') return this.hint(v.phase === 'over' ? 'The game’s over.' : 'Choose your tickets first.');
  if (!this.myTurn()) return this.hint(`It’s ${this.name(v.turn)}’s turn.`);
  if (v.offer) return this.hint('Choose your tickets first.');
  if (v.tunnel) return this.hint('Pay for the tunnel, or take your cards back, first.');
  if (v.drawn) return this.hint('Draw your second card: a claim is a whole turn.');
  const colors = v.can.claim?.[rid];
  if (!colors) { this.pickRoute(null); return this.hint(this.whyNot(r)); }
  // Claiming can't be taken back, so it's never one press (a slip never
  // spends cards): one way to pay picks the route, and a second press on
  // it (or the dock's Claim) claims it; a choice of colors, or a tunnel
  // to explain, is the chooser's.
  if (colors.length > 1 || (r.tunnel && assistOn('tunnel'))) { this.pickRoute(null); return this.claimSheet(rid); }
  if (this.picked === rid) return this.claim(rid, colors[0]);
  this.pickRoute(rid);
  const pay = payment(v.hand, r.length, colors[0], r.ferry);
  // (the status line says it; this says it to a screen reader)
  this.el.hintSay.textContent = `${this.routeName(rid)}: ${payWords(pay)}, +${POINTS[r.length]}. ${how === 'mouse' ? 'Click' : 'Tap'} it again, or press Claim.`;
}

/** What's under a point on screen: the nearest city within reach, else
 * the nearest route. Reach is a finger's on a touch screen. `ambiguous`:
 * the next nearest city or route is within a few pixels of it, so a
 * finger can't tell them apart at this zoom. */
hit(cx, cy, type = 'mouse') {
  const [x, y] = this.toMap(cx, cy);
  const s = this.scale();
  const reach = (type === 'mouse' ? 10 : 22) / s;  // in map units
  let city = null, dc = Infinity, dc2 = Infinity;
  for (const id of this.cityIds) {
    const c = this.map.cities[id];
    const d = Math.hypot(c.x - x, c.y - y);
    if (d < dc) { dc2 = dc; dc = d; city = id; } else if (d < dc2) dc2 = d;
  }
  let route = null, dr = Infinity, dr2 = Infinity;
  for (const r of this.map.routes) {
    let best = Infinity;
    for (const [px, py] of this.geo[r.id].samples) best = Math.min(best, (px - x) ** 2 + (py - y) ** 2);
    best = Math.sqrt(best);
    if (best < dr) { dr2 = dr; dr = best; route = r.id; } else if (best < dr2) dr2 = best;
  }
  const close = 10 / s;  // ten pixels on screen
  // On a city's stop it's the city; near one, the city unless a route is
  // plainly nearer (a tap on a route's middle is the route's).
  if (dc <= Math.max(7.5, 6 / s) || (dc <= reach && dc <= dr * 1.25)) {
    return { kind: 'city', id: city, ambiguous: dc2 - dc < close || dr - dc < close };
  }
  if (dr <= Math.max(5.5, reach)) return { kind: 'route', id: route, ambiguous: dr2 - dr < close };
  return null;
}

// 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: 'claimable', label: 'Light up routes you can claim', hint: 'On your turn, routes your cards can pay for glow on the map.' },
  { key: 'rings', label: 'Ring your tickets’ cities', hint: 'The two cities of each ticket you haven’t finished are ringed on the map.' },
  { key: 'path', label: 'Show a ticket’s cheapest way', hint: 'Point at or tap a ticket and the fewest trains that would link its cities are drawn bold in its spotlight.' },
  { key: 'done', label: 'Mark tickets done', hint: 'A ticket whose cities your routes (and stations) link is stamped done.' },
  { key: 'lastround', label: 'Warn when the last round starts', hint: 'A banner when someone’s down to two trains or fewer: everyone has one more turn.' },
  { key: 'tunnel', label: 'Say what a tunnel might cost', hint: 'Before you lay cards for a tunnel, how many more it could take and what you have to spare.' },
];

/** What everyone else did since your last move, in turn order, from their
 * rows ("Lou claimed Lakeport – Detroit · +7"); none before a whole round
 * has been played. */
sinceYours() {
  const { v, t } = this;
  if (t.you === null || v.phase !== 'play' || v.turns < v.n) return [];
  const out = [];
  for (let k = 1; k < v.n; k++) {
    const s = (t.you + k) % v.n;
    if (this.did[s]) out.push(`${this.name(s)} ${this.did[s]}`);
  }
  return out;
}

/** A route claimed: the cards spent fly to the discard pile, the
 * claimer's cars are laid one by one along it, and its points float up. */
claimCue(e, spent) {
  const n = this.routes[e.route]?.length || 1;
  const step = 70;
  const shown = Math.min(spent.length, 8);
  return {
    ms: MOTION.flight + shown * step + n * 90 + 600, hold: true,
    play: async signal => {
      if (this.shown.claimed[e.route] === e.seat) return;
      this.draws = null;
      const from = this.you(e.seat) ? this.el.rack : this.placeOf(e.seat);
      await Promise.all(spent.slice(0, shown).map((k, i) => fly(h('span.cardfly', card(k)), from, this.discardsAt(),
        { ms: MOTION.flight, delay: i * step, scale: [0.9, 0.5], fade: [1, 0.4], layer: this.felt, signal })));
      if (signal.aborted) return;
      this.shown.claimed[e.route] = e.seat;
      await this.board.lay(e.route, e.seat, !still());
      this.board.floatPoints(e.route, `+${e.points}`);
      await wait(still() ? 0 : 450, signal);
    },
    end: () => {
      // (counted once, however the cue ended: the map's claim may be shown already)
      if (!this.counted.has(e.id)) {
        this.counted.add(e.id);
        this.shown.points[e.seat] += e.points;
        this.shown.trains[e.seat] -= this.routes[e.route]?.length || 0;
      }
      this.shown.claimed[e.route] = e.seat;
      this.didThis(e.seat, `claimed ${this.routeName(e.route)} · +${e.points}`, { kind: 'route', id: e.route });
    },
  };
}