crossmate

Game.swift (7767B)

---

 import Foundation
 import Observation
 
 /// The shared, eventually-synced state of a single crossword game. Everything
 /// on `Game` is content that both players see — the puzzle itself, the
 /// letters that have been entered, and the per-cell marks for pencil / check
 /// / reveal state. Anything that's local to a single player (cursor position,
 /// pencil-mode toggle, chosen colour) lives on `PlayerSession`, not here.
 @MainActor
 @Observable
 final class Game {
     let puzzle: Puzzle
     var squares: [[Square]]
     @ObservationIgnored private let fillableCellCount: Int
     private var filledCellCount: Int = 0
     private var wrongCellCount: Int = 0
 
     init(puzzle: Puzzle) {
         self.puzzle = puzzle
         self.fillableCellCount = puzzle.cells.reduce(0) { count, row in
             count + row.filter { !$0.isBlock && $0.solution != nil }.count
         }
         self.squares = Array(
             repeating: Array(repeating: Square(), count: puzzle.width),
             count: puzzle.height
         )
     }
 
     // MARK: - Letter writes
 
     /// Writes `letter` into `(row, col)`. If `pencil` is true the cell is
     /// marked `.pencil(checkedWrong: false)`; otherwise the mark is cleared
     /// to `.none`. Revealed cells are locked — writes are silently ignored.
     /// When the new letter matches the existing entry, `letterAuthorID` is
     /// preserved — typing over an existing answer (common when filling a
     /// crossing word) shouldn't reattribute the square to the second typist.
     func setLetter(_ letter: String, atRow row: Int, atCol col: Int, pencil: Bool, authorID: String? = nil) {
         let cell = puzzle.cells[row][col]
         guard !cell.isBlock else { return }
         guard !squares[row][col].mark.isRevealed else { return }
         let oldEntry = squares[row][col].entry
         let newEntry = letter.uppercased()
         squares[row][col].entry = newEntry
         squares[row][col].mark = pencil ? .pencil(checkedWrong: false) : .none
         if newEntry != oldEntry {
             squares[row][col].letterAuthorID = authorID
         }
         noteEntryChange(from: oldEntry, to: newEntry, for: cell)
     }
 
     /// Clears the entry and mark at `(row, col)`. No-op on revealed cells.
     func clearLetter(atRow row: Int, atCol col: Int) {
         let cell = puzzle.cells[row][col]
         guard !cell.isBlock else { return }
         guard !squares[row][col].mark.isRevealed else { return }
         let oldEntry = squares[row][col].entry
         squares[row][col].entry = ""
         squares[row][col].mark = .none
         squares[row][col].letterAuthorID = nil
         noteEntryChange(from: oldEntry, to: "", for: cell)
     }
 
     // MARK: - Check / Reveal / Clear
 
     /// For each non-empty, non-revealed target cell, compares the current
     /// entry against the solution. Wrong entries get `checkedWrong = true`
     /// (preserving pen-vs-pencil style); correct entries have the wrong mark
     /// cleared. Empty cells and cells without a known solution are skipped.
     func checkCells(_ cells: [Puzzle.Cell]) {
         for cell in cells {
             guard !cell.isBlock else { continue }
             guard cell.solution != nil else { continue }
             let entry = squares[cell.row][cell.col].entry
             guard !entry.isEmpty else { continue }
             guard !squares[cell.row][cell.col].mark.isRevealed else { continue }
 
             let isWrong = !cell.accepts(entry)
             switch squares[cell.row][cell.col].mark {
             case .pencil:
                 squares[cell.row][cell.col].mark = .pencil(checkedWrong: isWrong)
             case .none, .pen:
                 squares[cell.row][cell.col].mark = isWrong ? .pen(checkedWrong: true) : .none
             case .revealed:
                 break // unreachable; guarded above
             }
         }
     }
 
     func checkPuzzle() {
         checkCells(puzzle.cells.flatMap { $0 })
     }
 
     /// For each target cell, writes the solution into the entry and sets the
     /// mark to `.revealed` (which locks the cell against future edits). Cells
     /// whose entry already matches the solution are left untouched — the user
     /// got it right, so there's no reason to overwrite their mark or lock the
     /// cell.
     func revealCells(_ cells: [Puzzle.Cell]) {
         for cell in cells {
             guard !cell.isBlock else { continue }
             guard let solution = cell.solution else { continue }
             let expected = solution.uppercased()
             let oldEntry = squares[cell.row][cell.col].entry
             if cell.accepts(oldEntry) { continue }
             squares[cell.row][cell.col].entry = expected
             squares[cell.row][cell.col].mark = .revealed
             squares[cell.row][cell.col].letterAuthorID = nil
             noteEntryChange(from: oldEntry, to: expected, for: cell)
         }
     }
 
     func revealPuzzle() {
         revealCells(puzzle.cells.flatMap { $0 })
     }
 
     /// Clears the entry and mark for each non-revealed target cell. Revealed
     /// cells are left untouched — once revealed, a cell's contents are
     /// permanent for the rest of the game.
     func clearCells(_ cells: [Puzzle.Cell]) {
         for cell in cells {
             guard !cell.isBlock else { continue }
             guard !squares[cell.row][cell.col].mark.isRevealed else { continue }
             let oldEntry = squares[cell.row][cell.col].entry
             squares[cell.row][cell.col].entry = ""
             squares[cell.row][cell.col].mark = .none
             squares[cell.row][cell.col].letterAuthorID = nil
             noteEntryChange(from: oldEntry, to: "", for: cell)
         }
     }
 
     func clearPuzzle() {
         clearCells(puzzle.cells.flatMap { $0 })
     }
 
     // MARK: - Completion
 
     enum CompletionState: Sendable, Equatable {
         case incomplete
         case filledWithErrors
         case solved
     }
 
     /// `.incomplete` while any cell with a known solution is empty; once every
     /// known-solution cell has an entry, `.solved` if every entry matches its
     /// solution (cells with no known solution are ignored) and `.filledWithErrors`
     /// otherwise.
     var completionState: CompletionState {
         guard filledCellCount == fillableCellCount else { return .incomplete }
         return wrongCellCount > 0 ? .filledWithErrors : .solved
     }
 
     /// Rebuilds the O(1) completion counters after bulk state restoration
     /// paths that write directly into `squares`.
     func recomputeCompletionCache() {
         filledCellCount = 0
         wrongCellCount = 0
         for r in 0..<puzzle.height {
             for c in 0..<puzzle.width {
                 let cell = puzzle.cells[r][c]
                 guard !cell.isBlock, cell.solution != nil else { continue }
                 let entry = squares[r][c].entry
                 if !entry.isEmpty { filledCellCount += 1 }
                 if isWrongEntry(entry, for: cell) { wrongCellCount += 1 }
             }
         }
     }
 
     private func noteEntryChange(from oldEntry: String, to newEntry: String, for cell: Puzzle.Cell) {
         guard cell.solution != nil else { return }
 
         if oldEntry.isEmpty, !newEntry.isEmpty {
             filledCellCount += 1
         } else if !oldEntry.isEmpty, newEntry.isEmpty {
             filledCellCount -= 1
         }
 
         let wasWrong = isWrongEntry(oldEntry, for: cell)
         let isWrong = isWrongEntry(newEntry, for: cell)
         if wasWrong, !isWrong {
             wrongCellCount -= 1
         } else if !wasWrong, isWrong {
             wrongCellCount += 1
         }
     }
 
     private func isWrongEntry(_ entry: String, for cell: Puzzle.Cell) -> Bool {
         guard !entry.isEmpty, cell.solution != nil else { return false }
         return !cell.accepts(entry)
     }
 }