asterism-games 0.19.1 → 0.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d10ded9e6550829d2169bb7be24ba662f11d69cec3eaf0fe676923104aa44727
-  data.tar.gz: '039b615f91c53f50c6bb10500b4e9516c7893bd213af57d1f7823c2bc67e84f5'
+  metadata.gz: 0a35db1346246e5d20505026e701fef357536cc75fa53f22bf47878398fb01c3
+  data.tar.gz: 79c4c46763e2104c3e4d03ba521327e9ceb5fa77fc74521cec6041eb3ca48b89
 SHA512:
-  metadata.gz: c2571c2374914e2f9bb3d299e0482cd3f2f43b9c6ebe7fb4f5423b5c37c121cd5b06c06eb058ee91ecb5b05ddd0d6db22ce89e9b8b06eaf40cd3ab6ac6081f65
-  data.tar.gz: 260165d7df98b105ec8070f0c850d80f783b220cf4cf819c3a17de189c0ed7b0ccb78f43dc7ce29fe8f31f08aa4d4793c0eca1a2e600a265e52c61c67833852e
+  metadata.gz: 2b31fdedf12d610dca0c8cbd4f1ae060b5b42eeab54dee46d62f0ced96d8895468b48e84db2eae2904489448329a19ef5888cf9cb2a514684c2610d4e0937d87
+  data.tar.gz: 9908df82204210223cecd09b651da9d12e3a27ee832433d0e57b74d4d895a7a9753c83c20b75cadfeff88ef94eb91f6564290be193b1e501a37ce209124b67d3

data/CHANGELOG.md

@@ -3,6 +3,43 @@
 Versions before 0.11.1 are noted in the README where each feature is
 described ("games 0.10.0" and the like).
 
+## 0.20.0
+
+- **Watch games** (README "Watch games"): the owner of a mahjong table
+  may start a game of CPUs and AI players only, and watch it with the
+  others at the table (and a commentary, `commentate mahjong`). The owner
+  need not be seated: a member that joins a table where nobody is seated
+  and there is no owner is the owner (`join`'s `"owner"`, the new `"mo"`
+  of the member's own view); once somebody sits the first seated is the
+  owner as before, so a game with people seated goes as it did. The new
+  method `watch(token)` starts it when the four seats are CPUs or AI
+  players, nobody is seated and at most one seat is Claude's (Jev may take
+  all four; `"human"`, `"ai limit"`, `"seats"`, `"not owner"` otherwise).
+  The lobby view's `"wc"` says whether it may start (1), is over the AI
+  limit (2) or not (0); views during it have `"wm" => 1` and the host's
+  `@status` `"watch" => true`. Nobody is seated, so the table's
+  abandoning does not apply; instead the game stops (unrecorded) when
+  every member has left. One game, then the lobby with the same seats.
+  The record is kept with `"watch" => true` (also on `records`' entries)
+  and counts in the stats for the CPU and the AI kinds only, never for a
+  person. The AI players' daily limits work as before.
+- **The game's AI decisions are each seat's own**: `ASTERISM_GAMES_AI_CALLS_PER_GAME`
+  (400) is now how many decisions each AI seat may ask in a game (mahjong
+  and othello, every game, watch games or not); a seat past it becomes a
+  CPU alone. Before, the seats of a game shared it, so a game with three
+  or four AI seats stopped them all part way through a tonpuu. A game's
+  most is now 400 times its AI seats; the daily limits are as before.
+- `play mahjong`: `W` (and the command `watch`) starts a watch game, for
+  the owner with or without a seat; `A` then a seat's number turns that
+  seat into a CPU, Claude, Jev and back (the kinds the lobby offers); the
+  owner's commands (`cpu`, `ai`, `watch`, `--commands`) work for an owner
+  without a seat; the lobby marks the owner among those watching and says
+  the AI limit when the seats are over it; a watch game is headed
+  `観戦対局`.
+- Family mruby's mahjong app (fmruby-core) has a `観戦で始める[W]` button
+  for the owner when the host says it may start (`"wc"`); with an older
+  host it is not shown.
+
 ## 0.19.1
 
 - The commentary tells where to get VOICEVOX when it finds no engine:

data/README.md

@@ -476,7 +476,8 @@ asterism/games/games/@status
 
 `last` is the four in rank order as `[name, rank, score]`, by the names
 the table shows its members anyway (a table app shows them to whoever
-joins); it is there once a game has ended. The rooms' status file
+joins); it is there once a game has ended. During a watch game the
+table's entry has `"watch" => true` (games 0.20.0). The rooms' status file
 (`GET /status` of the rooms' host) stays counts only.
 
 `ais` counts the AI players' seats (they are counted in `cpus` too), and
@@ -701,6 +702,7 @@ connects again after 3 s; while a client of a router only reconnects
 | `stand` | token | `"ok"` or why not (lobby only) |
 | `cpu` | token, seat, on | the owner: a CPU into an empty seat (on) or out of it (a CPU or an AI player); seat -1 with on fills every empty seat; on as a name the lobby offers (`"claude"`, `"jev"`) puts that AI player in ("AI players"), `"no ai"` when it is not offered; on one seat that holds a CPU or an AI player of another kind, on turns it into the one asked for (games 0.12.1) |
 | `start` | token | the owner, once the four seats are taken and one is a member: the seats are drawn (who deals first) and the game starts |
+| `watch` | token | the owner: a watch game ("Watch games", games 0.20.0): the four seats CPUs or AI players, nobody seated, Claude in one seat at most; `"ok"` or why not (`"not owner"`, `"not waiting"`, `"seats"`, `"human"`, `"ai limit"`) |
 | `rule` | token, item, value | the owner, in the lobby: a local rule ("Local rules"); `"ok"` or why not (`"not owner"`, `"not waiting"`, `"no rule"`, `"value"`, `"no change"`) |
 | `view` | token, assist | the member's view (below), or `{"error" => "token"}`; assist: the help its screen shows (Assist, 0-3) |
 | `act` | token, sv, type, tiles | `"ok"`, or why not: `"token"`, `"not seated"`, `"stale"` (sv is not the current one), `"not offered"`, `"not playing"` |
@@ -712,8 +714,9 @@ connects again after 3 s; while a client of a router only reconnects
 
 - People join a table and wait in its lobby (`"st" => "wait"`): a member
   sits in a seat or watches. The first member who sat is the owner (when the
-  owner stands or leaves, the member seated longest takes over). The owner
-  fills empty seats with CPUs and starts. At the end of a game the owner's
+  owner stands or leaves, the member seated longest takes over). While
+  nobody is seated the owner may be a member without a seat (games 0.20.0,
+  "Watch games"). The owner fills empty seats with CPUs and starts. At the end of a game the owner's
   next (or `over_seconds`) brings the table back to the lobby with the same
   seats, for another game.
 - The node that calls is the caller in the call's key (`from:`, filled
@@ -973,6 +976,47 @@ going for everyone (the other away seats are played for as before). A
 table of CPUs only (`humans: 0`, the permanent spectator tables) is never
 abandoned.
 
+### Watch games
+
+A game of CPUs and AI players only, which the people at the table watch
+(games 0.20.0): the owner fills the four seats and starts it without
+sitting down, and a commentary (`commentate mahjong`, "Commentary") can
+follow it like any other table.
+
+- **The owner without a seat.** A member that joins a table where nobody
+  is seated and nobody is the owner is the owner (`join`'s `"owner"`, the
+  member's own view's `"mo"`). When somebody sits, the first to sit is the
+  owner as before: whenever a member is seated the role is where it always
+  was (the seated member who sat first, "Players that drop out"). An owner
+  who stands up with nobody else seated keeps the role; an owner who
+  leaves with nobody seated hands it to the member who joined first, of
+  those there. An older table app, which knows only `"ow"` (the owner's
+  seat), shows an owner without a seat as no owner, as it showed a lobby
+  without one before.
+- **Starting.** `watch(token)`, the owner, in the lobby: the four seats
+  are CPUs or AI players (`cpu`), no member is seated, and at most one seat
+  is Claude's (`WATCH_AI_MAX`: Claude 1, Jev 4). The lobby view's `"wc"`
+  tells the screens whether it may start (1), or the seats are all CPUs
+  and AI players but over the AI limit (2), or not (0); a host before
+  0.20.0 has no `"wc"`, and the screens offer no watch game then. The
+  seats are drawn as for `start`. The AI players' money is as for any
+  game ("AI players"): a kind past its day's limit becomes a CPU.
+- **During it.** Nobody is seated, so nobody is played for and the
+  table's abandoning does not apply ("Players that drop out"); the results
+  move on by themselves as at a table of CPUs (`result_seconds`), and the
+  end of the game after `over_seconds`. The members watch with the four
+  hands ("Spectators", the spectator delay too). Views have `"wm" => 1`
+  and the host's `@status` has `"watch" => true` for the table ("Status").
+  When every member has left the table (`leave`, or forgotten after being
+  away six times `away_seconds`) the game stops: back to the lobby, an
+  unfinished game not recorded. The log says `watch game started (...)`
+  and `watch game stopped: nobody at the table (not recorded)`.
+- **One game.** At the end the table goes back to the lobby with the same
+  seats; the owner starts another with `watch` again.
+- **Records.** The game is recorded as any other with `"watch" => true`
+  (in `records`' entries and in `record(id)`). Its seats count in the
+  stats for their kinds (CPU, Claude, Jev), never for a person ("Stats").
+
 ### Views
 
 A Hash (MessagePack); tiles are one byte each in binary strings (bin).
@@ -986,7 +1030,9 @@ A Hash (MessagePack); tiles are one byte each in binary strings (bin).
 | `sk` | the four seats: 0 empty, 1 a member, 2 a CPU (an AI player too) |
 | `ai`, `ak` | when an AI player sits: each seat's kind (`"claude"`, `"jev"`, `""` for the others); in the lobby, the AI players the owner may seat ("AI players") |
 | `aw` | the seats whose member is away, as bits |
-| `ow` | the owner's seat (-1: nobody seated) |
+| `ow` | the owner's seat (-1: nobody seated, or an owner without a seat) |
+| `mo` | the member's own view only: 1 when this member is the owner, seated or not (games 0.20.0, "Watch games") |
+| `wc`, `wm` | in the lobby, whether a watch game may start: 1 yes, 2 the seats are all CPUs and AI players but over the AI limit, 0 no; during a watch game `wm` 1 ("Watch games", games 0.20.0) |
 | `mb` | the members in the order they joined: `[name, seat (-1 none), flags (1 away, 2 owner)]` |
 | `r` | `[bakaze (0 east, 1 south, 2 west), kyoku, honba, riichi sticks, dealer seat, tiles left, seat to act, phase (0 draw, 1 discard, 2 calls, 3 end)]` |
 | `sc`, `ri` | the scores; riichi as bits |
@@ -1171,7 +1217,7 @@ assistant through `asterism mcp`).
 
 | Method | Arguments | Returns |
 |---|---|---|
-| `records` | from (optional, 0) | `{"records" => [...], "total", "next"}`: the games, newest first, from the from-th, as many as fit one message; `next` is the from of the next page (none: the end). Each: `id`, `at` (the host's local time, `"2026-10-18 21:05"`), `game` (`hanchan` / `tonpuu`), `names`, `ranks`, `scores` (in seat order) |
+| `records` | from (optional, 0) | `{"records" => [...], "total", "next"}`: the games, newest first, from the from-th, as many as fit one message; `next` is the from of the next page (none: the end). Each: `id`, `at` (the host's local time, `"2026-10-18 21:05"`), `game` (`hanchan` / `tonpuu`), `names`, `ranks`, `scores` (in seat order), `watch` (`true` for a watch game, "Watch games"; else absent) |
 | `record` | id | the game's head: `id`, `at`, `time` (Unix seconds), `table`, `game`, `rules` (as `look`'s), `names`, `kinds` (human / cpu / ai), `final` (`[[seat, rank, score, points x 10], ...]`), `reason` (as the view's `fr`), `rounds` (`[[wind, number, honba, kind, [four changes]], ...]`) |
 | `record` | id, round | round `round` (from 0) as below, with `id`, `round`, `of` (how many rounds), `part`, `parts` |
 | `record` | id, round, part | a round too big for one message comes in parts (`parts` > 1): part 0 has everything with the first moves, part k the moves from `move_from` on |
@@ -1331,7 +1377,9 @@ pipe or a file (and the tests) they read lines as before, and
 | `1`..`4` | the lobby: sit there (an empty seat or a CPU's) |
 | `S` | the lobby: stand |
 | `C` | the lobby, the owner: CPUs into the empty seats |
+| `A`, then `1`..`4` | the lobby, the owner: that seat's next player: an empty seat a CPU, a CPU the first AI player offered, an AI player the next one, the last back a CPU (games 0.20.0; another key gives it up) |
 | Enter | the lobby, the owner: start (four seats taken) |
+| `W` | the lobby, the owner (seated or not): a watch game, the four seats CPUs or AI players ("Watch games", games 0.20.0) |
 
 | Othello | |
 |---|---|
@@ -1460,6 +1508,7 @@ Typed (in a pipe or a file each line; on a terminal after `:`):
 | `cpu [1-4]`, `nocpu 1-4`, `ai 1-4 KIND` | the owner: CPUs into the empty seats (or one), a CPU out, an AI player in when the lobby offers one ("AI players") |
 | `tonpuu`, `hanchan`, `rule ITEM VALUE` | the owner: the game's length, any local rule ("Local rules") |
 | `start` | the owner: start |
+| `watch` | the owner, seated or not: a watch game ("Watch games", games 0.20.0); `--commands "cpu,ai 1 claude,watch"` from a client that does not sit |
 | `auto` | the client plays for you: wins when offered, passes calls, discards the drawn tile, OKs the results (again to stop) |
 | `tables`, `view`, `help`, `quit` | |
 
@@ -1825,9 +1874,12 @@ offered), and show the seat by its name (`Claude`, `Jev`, numbered when there ar
   reports, per day (the host's local date), in `state_dir/ai_usage.json`
   (shared by the rooms' hosts and the permanent tables; counts and money
   only). When today's total reaches `ASTERISM_GAMES_AI_DAILY_USD` (3.0) no
-  table offers an AI player any more and the seated ones become CPUs; a
-  game asks at most `ASTERISM_GAMES_AI_CALLS_PER_GAME` (400) decisions,
-  then its AI seats become CPUs. `bin/asterism-games status` prints the
+  table offers an AI player any more and the seated ones become CPUs; each
+  AI seat asks at most `ASTERISM_GAMES_AI_CALLS_PER_GAME` (400) decisions
+  in a game, then that seat becomes a CPU (games 0.20.0: the count is each
+  seat's own, so a game's most is 400 times its AI seats; before, the
+  seats of a game shared the 400 and every AI seat stopped together). A
+  tonpuu takes about 150-200 decisions a seat, a hanchan about twice that. `bin/asterism-games status` prints the
   day's decisions, tokens and money per kind; the host's `@status` has the
   totals (`ai_today`).
 - **A limit per kind** (games 0.15.0). `ASTERISM_GAMES_AI_DAILY_USD_CLAUDE`
@@ -1840,7 +1892,7 @@ offered), and show the seat by its name (`Claude`, `Jev`, numbered when there ar
   0.15.0. A value that is not a number of dollars (0 or more) is ignored,
   with a line in the log. The log says the limits at the start
   (`games: AI players: claude, jev (at most $10.0 a day for claude, $2.0
-  for jev, 400 decisions a game)`) and once for each kind that stops
+  for jev, 400 decisions a seat in a game)`) and once for each kind that stops
   (`today's limit for claude ($10.0) is reached`); a new day lets it play
   again. `ai_today` on `@status` then has `kinds` (README "Status").
 - **Prices.** USD per million tokens, settings with the published prices
@@ -1904,8 +1956,9 @@ game between two machines without a host is fmruby-core's
   "moves" => [{"n", "square", "turns", "text"}]}`; the answer is a move's
   `n`. One out of range, one that does not come in `ai_turn_seconds` (30 s)
   or a failure is played by the CPU, and the game goes on. When the day's
-  money is spent, or the game has asked `ASTERISM_GAMES_AI_CALLS_PER_GAME`
-  decisions, Jev's seat becomes the CPU. The table apps show Jev by its
+  money is spent, or the seat has asked `ASTERISM_GAMES_AI_CALLS_PER_GAME`
+  decisions in the game (each seat its own count, games 0.20.0), Jev's
+  seat becomes the CPU. The table apps show Jev by its
   name with `[AI]` and say when it is thinking; `dl` counts its time down.
 - Nothing in othello is hidden, so every member sees the same view: the
   table's view (the one the host puts on the state key) and `me`, the

data/VERSION

@@ -1 +1 @@
-0.19.1
+0.20.0

data/lib/asterism_games/host.rb

@@ -107,7 +107,7 @@ module AsterismGames
                                     prices: ->(k) { settings.prices(k) })
       unless deciders.empty?
         @log.call("games: AI players: #{deciders.keys.join(', ')} (#{AI::Hub.limits_text(deciders.keys, budget)}, " \
-                  "#{settings.calls_per_game} decisions a game)")
+                  "#{settings.calls_per_game} decisions a seat in a game)")
       end
       AI::Hub.new(deciders, budget, calls_per_game: settings.calls_per_game, threads: settings.threads, log: @log)
     end

data/lib/asterism_games/othello/table.rb

@@ -78,7 +78,7 @@ module AsterismGames
         @stats = Hash.new(0)
         @ai_kinds = []         # the AI players the host can offer now (the lobby view's "ak")
         @ai_calls_per_game = nil
-        @ai_calls = 0          # decisions asked this game
+        @ai_calls = Hash.new(0) # seat => decisions asked this game
         @ai_want = nil         # the decision asked of the AI seat to move: {seat:, key:, kind:, at:, sent:}
         @ai_got = nil          # [key, move number or nil] come back
         load_saved(0)
@@ -205,7 +205,7 @@ module AsterismGames
         @seats = @seats.shuffle(random: Random.new(SecureRandom.random_number(2**32)))
         @game = Othello::Match.new
         @result = nil
-        @ai_calls = 0
+        @ai_calls = Hash.new(0)
         @status = "play"
         @log&.call("othello: #{@name}: game started (#{@seats.map { |s| s['name'] }.join(' (black), ')} (white))")
         schedule(now)
@@ -272,7 +272,8 @@ module AsterismGames
       # does not come in time, or fails, is the CPU's. A turn with one legal
       # move is not asked (it is played as the CPU plays). The host turns
       # the AI seats into CPUs when the day's money is spent, and the table
-      # does when the game has asked ai_calls_per_game decisions.
+      # turns an AI seat into a CPU when that seat has asked
+      # ai_calls_per_game decisions in the game (each seat its own count).
 
       def ai_seat?(seat)
         s = @seats[seat]
@@ -291,12 +292,12 @@ module AsterismGames
       def ai_requests(now)
         w = @ai_want
         return [] if w.nil? || w[:sent]
-        if @ai_calls_per_game && @ai_calls >= @ai_calls_per_game
-          ai_off!("#{@ai_calls_per_game} decisions in this game")
+        if @ai_calls_per_game && @ai_calls[w[:seat]] >= @ai_calls_per_game
+          ai_off!("#{@ai_calls_per_game} decisions of seat #{w[:seat]} in this game", seats: [w[:seat]])
           return []
         end
         w[:sent] = true
-        @ai_calls += 1
+        @ai_calls[w[:seat]] += 1
         @stats["ai_asked"] += 1
         [{ seat: w[:seat], key: w[:key], kind: w[:kind], until: w[:at],
            request: { "game" => "othello", "table" => @name, "seat" => w[:seat],
@@ -313,10 +314,12 @@ module AsterismGames
         true
       end
 
-      # The AI seats become CPUs (the day's money, or the game's decisions,
-      # are used up): all of them, or those of one kind.
-      def ai_off!(why, kind: nil)
-        seats = (0...SEATS).select { |i| ai_seat?(i) && (kind.nil? || @seats[i]["ai"] == kind) }
+      # The AI seats become CPUs (the day's money, or a seat's decisions of
+      # the game, are used up): all of them, those of one kind, or the
+      # seats named.
+      def ai_off!(why, kind: nil, seats: nil)
+        only = seats
+        seats = (0...SEATS).select { |i| ai_seat?(i) && (kind.nil? || @seats[i]["ai"] == kind) && (only.nil? || only.include?(i)) }
         return false if seats.empty?
         seats.each { |i| @seats[i].delete("ai") }
         @stats["ai_off"] += 1

data/lib/asterism_games/play/mahjong.rb

@@ -21,7 +21,8 @@ module AsterismGames
         On a terminal it reads keys, as the table app does: Left/Right choose a tile,
         Enter or Space discards it; R riichi, T tsumo/ron, P pon, C V B chi, K L J kan,
         N nine kinds, Esc pass, Enter the result's OK; in the lobby 1-4 sit, S stand,
-        C CPUs, Enter start; Q or Ctrl+C quits; : (or /) opens a line for a command.
+        C CPUs, A then 1-4 a seat's CPU or AI player, Enter start, W a watch game;
+        Q or Ctrl+C quits; : (or /) opens a line for a command.
         Mahjong commands (one per line, or after :):
           a .. n         discard that tile of the hand (the drawn tile is the last letter)
           6s, 0p, 東     discard that tile (0: the red five; 1z..7z for the honours too)
@@ -33,7 +34,8 @@ module AsterismGames
           ok             the result's OK (an empty line too); at the end, the owner: back to the lobby
           sit [1-4], stand, cpu [1-4] (empty seats to CPUs; the owner), nocpu 1-4,
           ai 1-4 KIND (an AI player, when the lobby offers one), tonpuu, hanchan,
-          rule ITEM VALUE (README "Local rules"), start (the owner)
+          rule ITEM VALUE (README "Local rules"), start (the owner),
+          watch (the owner: the four seats CPUs or AI players, a game only watched)
           auto           let the client play for you (wins, passes, discards the drawn tile,
                          OKs the results); again to stop
           tables, view, help, quit
@@ -50,8 +52,8 @@ module AsterismGames
       TIMER_EVERY_S = 1.0
 
       # --commands that only work in the lobby, and those of the owner.
-      LOBBY_WORDS = %w[sit stand cpu nocpu ai start tonpuu hanchan rule].freeze
-      OWNER_WORDS = %w[cpu nocpu ai start tonpuu hanchan rule].freeze
+      LOBBY_WORDS = %w[sit stand cpu nocpu ai start watch tonpuu hanchan rule].freeze
+      OWNER_WORDS = %w[cpu nocpu ai start watch tonpuu hanchan rule].freeze
 
       REASONS = {
         "token" => "卓の人ではない", "not seated" => "席に着いていない", "stale" => "画面が古い: 読み直し中",
@@ -60,7 +62,8 @@ module AsterismGames
         "not owner" => "卓の主だけができる", "seats" => "4 席がそろっていない", "no human" => "人が 1 人もいない",
         "no change" => "変わらない", "full" => "卓が満員", "spectators" => "観戦の人数が上限",
         "value" => "選べない値", "no rule" => "その項目は無い", "no ai" => "その AI は今は出せない",
-        "identity" => "この部屋での名乗りが合わない"
+        "identity" => "この部屋での名乗りが合わない", "human" => "人が座っている (観戦対局は 4 席とも CPU か AI)",
+        "ai limit" => MahjongText::WATCH_AI_NOTE
       }.freeze
 
       # The whole run: connect, find the table, play until quit (or over).
@@ -120,6 +123,7 @@ module AsterismGames
         @keys = keys
         @sel = -1
         @pick = false
+        @ai_pick = false # A in the lobby: a seat's number comes next
         @typing = false
         @path = path
         @name = name
@@ -233,7 +237,8 @@ module AsterismGames
       # One key (Play.key_loop); false to quit, :line for a line to type.
       def key(k)
         v = @view.is_a?(Hash) ? @view : nil
-        r = MahjongText.key_command(k, v, sel: @sel, pick: @pick)
+        r = MahjongText.key_command(k, v, sel: @sel, pick: @pick, ai_pick: @ai_pick)
+        @ai_pick = false unless r[0] == :ai_pick
         case r[0]
         when :quit then return false
         when :line then return :line
@@ -248,6 +253,12 @@ module AsterismGames
             @note = ""
             draw
           end
+        when :ai_pick
+          @lock.synchronize do
+            @ai_pick = r[1]
+            @note = ""
+            draw
+          end
         when :act
           answer = act(r[1], r[2])
           say(answer == "ok" ? "" : answer)
@@ -315,9 +326,10 @@ module AsterismGames
         return "画面を待っています" unless v.is_a?(Hash) && !v["error"]
         return "待ち合わせを待っています" unless v["st"] == "wait"
         return nil unless OWNER_WORDS.include?(w)
-        return "席に着くのを待っています" unless v["me"].to_i >= 0
-        return "卓の主を待っています" unless v["ow"] == v["me"]
-        return "4 席がそろうのを待っています" if w == "start" && (v["sk"] || [0]).any?(&:zero?)
+        unless MahjongText.owner?(v)
+          return v["me"].to_i >= 0 ? "卓の主を待っています" : "席に着くのを待っています"
+        end
+        return "4 席がそろうのを待っています" if %w[start watch].include?(w) && (v["sk"] || [0]).any?(&:zero?)
         nil
       end
 
@@ -394,6 +406,7 @@ module AsterismGames
         when "nocpu" then args.empty? ? "nocpu 1-4" : reason(@table.cpu(@token, seat_arg(args), false))
         when "ai" then args.size < 2 ? "ai 1-4 KIND" : reason(@table.cpu(@token, seat_arg(args), args[1]))
         when "start" then reason(@table.start(@token))
+        when "watch" then reason(@table.watch(@token))
         when "tonpuu" then reason(@table.rule(@token, 0, 1))
         when "hanchan" then reason(@table.rule(@token, 0, 0))
         when "rule"
@@ -453,7 +466,7 @@ module AsterismGames
 
       # What the screen needs of the keys (nil: commands are typed).
       def key_state
-        @keys && !@typing ? { sel: @sel, pick: @pick } : nil
+        @keys && !@typing ? { sel: @sel, pick: @pick, ai_pick: @ai_pick } : nil
       end
 
       # The countdown on a terminal (the move's time and the bank, the

data/lib/asterism_games/play/mahjong_screen.rb

@@ -157,6 +157,7 @@ module AsterismGames
       def lobby
         v = @v
         out = ["#{v['t'] || @path}  待ち合わせ#{"  ゲームホスト #{v['hv']}" if v['hv']}"]
+        out << "  (卓の主: 自分)" if v["mo"] == 1 && @me.negative?
         sk = v["sk"] || [0, 0, 0, 0]
         ai = v["ai"] || []
         4.times do |s|
@@ -169,8 +170,11 @@ module AsterismGames
           out << "  席#{s + 1}  #{n}#{" (#{tags.join(', ')})" unless tags.empty?}"
         end
         out << "  ルール: #{rules_text}" if v["ru"]
-        watchers = (v["mb"] || []).select { |m| m[1] == -1 }.map(&:first)
+        # Members without a seat; the owner among them (an owner without a
+        # seat, README "Watch games") marked.
+        watchers = (v["mb"] || []).select { |m| m[1] == -1 }.map { |m| m[2].to_i & 2 == 2 ? "#{m[0]}(卓の主)" : m[0] }
         out << "  観戦: #{watchers.join(' ')}" unless watchers.empty?
+        out << "  #{MahjongText::WATCH_AI_NOTE}" if v["wc"] == 2 && MahjongText.owner?(v)
         out
       end
 
@@ -189,6 +193,7 @@ module AsterismGames
         v = @v
         r = v["r"] || []
         out = []
+        out << "観戦対局 (CPU と AI だけ)" if v["wm"] == 1
         if r.size >= 4
           h = row.text("#{round_name(r)}  供託#{r[3]}  残り#{r[5]}  ドラ ")
           bytes(v["dora"]).each { |t| tile_cell(h, t) }
@@ -463,12 +468,16 @@ module AsterismGames
         types = opts.map(&:first).uniq
         case v["st"]
         when "wait"
-          return "観戦中: sit で座る、quit で出る" if @me.negative?
-          owner = v["ow"] == @me
+          owner = MahjongText.owner?(v)
+          if @me.negative?
+            return "観戦中 (卓の主): sit で座る、cpu [席]、ai 席 KIND、watch (観戦で始める)、quit" if owner
+            return "観戦中: sit で座る、quit で出る"
+          end
           return "stand、cpu [席] (空きを CPU で)、nocpu 席、tonpuu / hanchan、start、quit" if owner
           return "4 席がそろったら卓の主が始める (stand、quit)"
         when "over"
           return "ok で待ち合わせに戻す (quit で出る)" if types.include?(NEXT)
+          return "観戦対局: しばらくすると待ち合わせに戻る (quit で出る)" if v["wm"] == 1
           return "次へ: 卓の主が待ち合わせに戻す (quit で出る)"
         when "result"
           return "ok で次へ" if types.include?(NEXT)
@@ -512,6 +521,7 @@ module AsterismGames
         when "wait" then return lobby_keys
         when "over"
           return "[Enter]待ち合わせに戻す  #{COMMON_KEYS}" if types.include?(NEXT)
+          return "観戦対局: しばらくすると待ち合わせに戻る  #{COMMON_KEYS}" if v["wm"] == 1
           return "次へ: 卓の主が待ち合わせに戻す  #{COMMON_KEYS}"
         when "result"
           return "[Enter]OK  #{COMMON_KEYS}" if types.include?(NEXT)
@@ -567,26 +577,37 @@ module AsterismGames
       end
 
       # The lobby's keys: 1-4 for the seats that may be taken (empty or a
-      # CPU's), S stand, C CPUs and Enter start (the owner).
+      # CPU's), S stand, C CPUs, A then 1-4 a seat's CPU or AI player,
+      # Enter start and W a watch game (the owner; README "Watch games").
       def lobby_keys
         v = @v
         sk = v["sk"] || [0, 0, 0, 0]
+        if @keys && @keys[:ai_pick]
+          return "AI: [1]-[4] 席を選ぶ (空き→CPU→#{Array(v['ak']).map { |k| AI_LABELS[k] || k }.join('→')}→CPU) " \
+                 "ほかのキーでやめる"
+        end
+        owner = MahjongText.owner?(v)
         free = (0..3).select { |s| sk[s] != 1 && s != @me }.map { |s| "[#{s + 1}]" }
         words = []
         words << "#{free.join}座る" unless free.empty?
-        if @me >= 0
-          words << "[S]立つ"
-          if v["ow"] == @me
-            words << "[C]CPU で埋める" if sk.any?(&:zero?)
-            words << "[Enter]始める" unless sk.any?(&:zero?)
-          else
-            words << "(卓の主が始める)"
+        words << "[S]立つ" if @me >= 0
+        if owner
+          words << "[C]CPU で埋める" if sk.any?(&:zero?)
+          words << "[A]AI" unless Array(v["ak"]).empty?
+          if v["wc"] == 1
+            words << "[W]観戦で始める"
+          elsif @me >= 0 && sk.none?(&:zero?)
+            words << "[Enter]始める"
           end
+        elsif @me >= 0
+          words << "(卓の主が始める)"
         end
         words << COMMON_KEYS
-        "#{@me.negative? ? '観戦中: ' : ''}#{words.join(' ')}"
+        "#{@me.negative? ? (owner ? '観戦中 (卓の主): ' : '観戦中: ') : ''}#{words.join(' ')}"
       end
 
+      AI_LABELS = { "claude" => "Claude", "jev" => "Jev" }.freeze
+
       def turn_text(r)
         cur = r[6]
         return "" if cur.nil? || cur.negative? || r[7].to_i >= 2

data/lib/asterism_games/play/mahjong_text.rb

@@ -378,30 +378,71 @@ module AsterismGames
       #   [:quit]
       #   [:error, text]            why not (Japanese, for the screen)
       #   [:none]                   nothing
-      def key_command(key, view, sel: -1, pick: false)
+      # ai_pick: A was pressed in the lobby, a seat's number comes next
+      # ([:ai_pick, on] turns it on or off).
+      def key_command(key, view, sel: -1, pick: false, ai_pick: false)
         k = key.is_a?(String) ? key.downcase : key
         return [:quit] if QUIT_KEYS.include?(k)
         return [:line] if LINE_KEYS.include?(k)
         return [:none] unless view.is_a?(Hash) && !view["error"]
         me = view["me"].to_i
-        return lobby_key(k, view, me) if view["st"] == "wait"
+        return lobby_key(k, view, me, ai_pick) if view["st"] == "wait"
         return [:none] if me.negative? || !%w[play result over].include?(view["st"])
         table_key(k, view, sel, pick)
       end
 
-      # The lobby: 1-4 sit there, S stand, C CPUs into the empty seats and
-      # Enter start (the owner's).
-      def lobby_key(k, view, me)
-        owner = me >= 0 && view["ow"] == me
+      # The lobby: 1-4 sit there, S stand, C CPUs into the empty seats,
+      # A then 1-4 that seat's next player (CPU, the AI players offered),
+      # Enter start and W a watch game (the owner's).
+      def lobby_key(k, view, me, ai_pick = false)
+        owner = owner?(view)
+        if ai_pick
+          return [:ai_pick, false] unless %w[1 2 3 4].include?(k)
+          return ai_seat_command(view, k.to_i - 1)
+        end
         case k
         when "1", "2", "3", "4" then [:cmd, "sit", [k]]
         when "s" then me >= 0 ? [:cmd, "stand", []] : [:none]
         when "c" then owner ? [:cmd, "cpu", []] : [:error, "卓の主だけができる"]
+        when "a"
+          return [:error, "卓の主だけができる"] unless owner
+          return [:error, "ゲームホストが AI を出していない"] if Array(view["ak"]).empty?
+          [:ai_pick, true]
+        when "w"
+          return [:error, "卓の主だけができる"] unless owner
+          return [:error, "このゲームホストは観戦対局ができない"] unless view.key?("wc")
+          return [:error, WATCH_AI_NOTE] if view["wc"] == 2
+          return [:error, "4 席を CPU か AI で埋めると観戦で始められる"] unless view["wc"] == 1
+          [:cmd, "watch", []]
         when :enter then owner ? [:cmd, "start", []] : [:none]
         else [:none]
         end
       end
 
+      WATCH_AI_NOTE = "観戦対局の AI は Claude 1 席・Jev 4 席まで"
+
+      # This member is the owner: "mo" (games 0.20.0; an owner without a
+      # seat too), or its seat is the owner's.
+      def owner?(view)
+        return true if view["mo"] == 1
+        me = view["me"].to_i
+        me >= 0 && view["ow"] == me
+      end
+
+      # A then a seat's number: an empty seat gets a CPU, a CPU the first AI
+      # player offered, an AI player the next one, the last back a CPU.
+      def ai_seat_command(view, seat)
+        sk = view["sk"] || [0, 0, 0, 0]
+        return [:error, "その席は人が座っている"] if sk[seat] == 1
+        n = (seat + 1).to_s
+        return [:cmd, "cpu", [n]] if sk[seat].to_i.zero?
+        kinds = Array(view["ak"])
+        cur = Array(view["ai"])[seat].to_s
+        i = cur.empty? ? -1 : kinds.index(cur)
+        nxt = i.nil? ? nil : kinds[i + 1]
+        nxt ? [:cmd, "ai", [n, nxt]] : [:cmd, "cpu", [n]]
+      end
+
       def table_key(k, view, sel, pick)
         opts = options(view)
         has = ->(type) { opts.any? { |t, _| t == type } }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: asterism-games
 version: !ruby/object:Gem::Version
-  version: 0.19.1
+  version: 0.20.0
 platform: ruby
 authors:
 - Katsuhiko Kageyama