1Suit = { Spades, Hearts, Diamonds, Clubs }

1Rank = { Ace, Two, Three, Four, Five, Six, Seven,
2         Eight, Nine, Ten, Jack, Queen, King }

1Card
2  properties:
3    rank : Rank
4    suit : Suit
5
6  methods:
7    toString() → "Ace of Spades"
8    toShortString() → "A♠"

 1Deck
 2  properties:
 3    cards : list of Card
 4
 5  methods:
 6    create()
 7      -- build one Card for every (Rank, Suit) combination → 52 cards total
 8
 9    shuffle()
10      -- randomize card order in place
11
12    deal(n) → list of Card
13      -- remove and return the top n cards
14      -- error if fewer than n cards remain
15
16    drawOne() → Card or null
17      -- remove and return the top card
18      -- return null if deck is empty
19
20    size() → number
21    isEmpty() → boolean

 1Hand
 2  properties:
 3    cards : list of Card
 4
 5  methods:
 6    add(cards)
 7      -- append one or more cards to the hand
 8
 9    hasRank(rank) → boolean
10      -- return true if at least one card of this rank exists
11
12    takeByRank(rank) → list of Card
13      -- remove and return all cards matching rank
14
15    collectBooks() → list of Rank
16      -- find every rank that appears exactly 4 times
17      -- remove those cards from the hand
18      -- return the list of completed ranks
19
20    size() → number
21    isEmpty() → boolean
22    toString() → human-readable card list

 1Player
 2  properties:
 3    id       : number
 4    name     : string
 5    hand     : Hand
 6    books    : list of Rank    -- completed four-of-a-kind sets
 7    isHuman  : boolean
 8
 9  methods:
10    bookCount() → number
11      -- return length of books list
12
13    recordBook(rank)
14      -- append rank to books
15
16    score() → number
17      -- same as bookCount, used at end of game
18
19    -- AI only --
20
21    chooseRank() → Rank
22      -- pick the rank in hand with the most copies
23      -- (ties broken randomly)
24
25    chooseTarget(otherPlayers) → Player
26      -- pick a random opponent who still has cards

1Phase = { Ask, GoFish, GameOver }

 1TurnResult
 2  properties:
 3    asker          : Player
 4    target         : Player
 5    rankAsked      : Rank
 6    cardsReceived  : list of Card   -- cards transferred from target → asker
 7    wentFishing    : boolean        -- true if target had no matching cards
 8    drawnCard      : Card or null   -- card drawn when fishing (null if deck empty)
 9    booksScored    : list of Rank   -- any books completed this turn
10    turnEnds       : boolean        -- false means asker gets to go again

 1Game
 2  properties:
 3    players       : list of Player
 4    deck          : Deck
 5    currentIndex  : number    -- index of the active player
 6    phase         : Phase
 7    history       : list of TurnResult
 8
 9  methods:
10    create(playerNames, humanFlags)
11      -- validate 2–6 players
12      -- build Player objects
13      -- create and shuffle the Deck
14
15    start()
16      -- deal 7 cards each for 2 players, 5 cards each for 3–6 players
17      -- collect any opening books from starting hands
18      -- set phase = Ask
19
20    currentPlayer() → Player
21      -- return players[currentIndex]
22
23    ask(targetIndex, rank) → TurnResult
24      -- validate phase is Ask
25      -- validate targetIndex is a different, eligible player
26      -- validate rank exists in asker's hand
27
28      -- if target has rank:
29         cards = target.hand.takeByRank(rank)
30         asker.hand.add(cards)
31         books = asker.hand.collectBooks()
32         record any new books on asker
33         set turnEnds = false   (asker goes again)
34
35      -- if target does not have rank:
36         set phase = GoFish
37         set wentFishing = true
38         set turnEnds = true
39
40      -- build and store TurnResult
41      -- if turnEnds: call advanceTurn()
42      -- return TurnResult
43
44    goFish() → TurnResult
45      -- validate phase is GoFish
46      -- draw one card from deck
47      -- add card to asker's hand
48      -- check for new book
49      -- set phase = Ask
50      -- advanceTurn()
51      -- return TurnResult
52
53    advanceTurn()
54      -- move currentIndex to the next player who still has cards
55      -- if no eligible players remain: set phase = GameOver
56
57    isOver() → boolean
58      -- return true when deck is empty AND all hands are empty
59
60    winners() → list of Player
61      -- return the player(s) with the highest book count
62
63    scores() → map of name → bookCount
64
65    eligiblePlayers() → list of Player
66      -- return players who still have cards in hand

 1main()
 2  game = setupGame()
 3  game.start()
 4  runGameLoop(game)
 5
 6setupGame() → Game
 7  -- prompt for number of players
 8  -- prompt for each player's name and whether they are human or AI
 9  -- return Game.create(names, humanFlags)
10
11runGameLoop(game)
12  -- loop until game.isOver():
13       printState(game)
14       takeTurn(game)
15  -- printFinalScores(game)
16
17takeTurn(game)
18  -- if currentPlayer is human: humanTurn(game)
19  -- else: aiTurn(game)
20
21humanTurn(game)
22  -- display hand to the player
23  -- prompt: choose a target player
24  -- prompt: choose a rank to ask for
25  -- result = game.ask(targetIndex, rank)
26  -- printResult(result)
27  -- if result.wentFishing:
28       result = game.goFish()
29       printResult(result)
30
31aiTurn(game)
32  -- target = currentPlayer.chooseTarget(otherPlayers)
33  -- rank   = currentPlayer.chooseRank()
34  -- result = game.ask(target, rank)
35  -- printResult(result)
36  -- if result.wentFishing:
37       result = game.goFish()
38       printResult(result)
39
40printState(game)
41  -- show current player's name
42  -- show human player's hand (hide AI hands)
43  -- show book counts for all players
44  -- show cards remaining in deck
45
46printResult(result)
47  -- narrate what happened: who asked whom, for what, and the outcome
48
49printFinalScores(game)
50  -- display winner(s) and full score table

 1main
 2 └── setupGame()       → creates Game
 3 └── game.start()      → shuffle + deal
 4 └── runGameLoop()
 5      └── takeTurn()
 6           ├── humanTurn()  or  aiTurn()
 7           │    └── game.ask(target, rank)
 8           │         ├── success → cards transferred, check books
 9           │         │             turnEnds = false → ask again
10           │         └── "Go Fish" → phase = GoFish
11           │              └── game.goFish() → draw card, check book
12           │                                  advanceTurn()
13           └── (repeat until game.isOver())