crossmate

PuzzleCatalog.swift (5534B)

---

 import Foundation
 
 /// Knows about packaged `.xd` puzzle resources. Used by the new-game picker
 /// to list available puzzles. The catalog is built from each bundle's
 /// `manifest.json` (written by the Crossmake `Bundlemake` tool); raw `.xd`
 /// source is read only when a specific puzzle is opened.
 struct PuzzleCatalog {
     struct Entry: Identifiable {
         let id: String          // resource name (e.g. "cm-starter-0001")
         let title: String       // display title from the manifest
         let publisher: String?  // publisher from the manifest, if any
         let gridWidth: Int      // grid columns, for the row thumbnail
         let gridHeight: Int     // grid rows, for the row thumbnail
         /// Row-major block mask (`true` == block). Drives `GridThumbnailView`
         /// so the puzzle list can show the same preview as the game list.
         let blockCells: [Bool]
         /// The puzzle's `.xd` resource. The catalog is built from manifests
         /// and never holds source text; callers read it on demand.
         let sourceURL: URL
 
         /// Reads the puzzle's raw `.xd` source from the app bundle.
         func loadSource() throws -> String {
             try String(contentsOf: sourceURL, encoding: .utf8)
         }
     }
 
     /// A bundle of puzzles under `Puzzles/`, e.g. "Crossmate Starter".
     struct PuzzleBundle: Identifiable {
         let id: String       // bundle id, e.g. "cm-starter"
         let name: String     // display name, e.g. "Crossmate Starter"
         let puzzles: [Entry]
     }
 
     /// Bundle id of the debug-only fixture set.
     private static let debugBundleID = "debug"
 
     /// Manifests are immutable for the life of the process, so the catalog is
     /// read once, on first access. SwiftUI re-evaluates the picker's body
     /// freely without paying a re-read each time.
     private static let allBundles: [PuzzleBundle] = loadAllBundles()
 
     /// The puzzle bundles shown in the picker. Debug fixtures join the regular
     /// bundles when the app's debug mode is enabled.
     static func bundles(includeDebug: Bool = false) -> [PuzzleBundle] {
         includeDebug ? allBundles : allBundles.filter { $0.id != debugBundleID }
     }
 
     static func source(
         matchingResourceID resourceID: String?,
         title: String?
     ) -> Entry? {
         let entries = allPuzzles()
         if let resourceID {
             return entries.first { $0.id == resourceID }
         } else if let title {
             return entries.first { $0.title == title }
         } else {
             return nil
         }
     }
 
     /// Finds the catalog id of a bundled puzzle whose `.xd` source matches
     /// `source` exactly. Pre-filtered by title so a non-bundled source (an
     /// NYT or imported puzzle) reads no `.xd` files at all.
     static func resourceID(matching source: String) -> String? {
         guard let title = try? XD.parse(source).title else { return nil }
         return allPuzzles()
             .filter { $0.title == title }
             .first { (try? $0.loadSource()) == source }?
             .id
     }
 
     /// Every cataloged puzzle — bundled and debug — flattened for lookup.
     private static func allPuzzles() -> [Entry] {
         allBundles.flatMap(\.puzzles)
     }
 
     // MARK: - Manifest loading
 
     private struct Manifest: Decodable {
         let version: Int
         let bundleID: String
         let name: String
         let puzzles: [ManifestPuzzle]
     }
 
     private struct ManifestPuzzle: Decodable {
         let id: String
         let title: String
         let publisher: String?
         let gridWidth: Int
         let gridHeight: Int
         let blockMask: String
     }
 
     private static func loadAllBundles() -> [PuzzleBundle] {
         guard let puzzlesURL = Bundle.main.resourceURL?
             .appendingPathComponent("Puzzles", isDirectory: true) else {
             return []
         }
         let directories = (try? FileManager.default.contentsOfDirectory(
             at: puzzlesURL,
             includingPropertiesForKeys: [.isDirectoryKey]
         )) ?? []
 
         return directories
             .compactMap { url -> PuzzleBundle? in
                 guard (try? url.resourceValues(forKeys: [.isDirectoryKey]))?
                     .isDirectory == true else {
                     return nil
                 }
                 return bundle(in: url)
             }
             .sorted { $0.id.localizedStandardCompare($1.id) == .orderedAscending }
     }
 
     /// Builds a bundle from its `manifest.json`. Directories without a
     /// readable manifest are skipped — `Bundlemake` writes the manifest as
     /// part of authoring a bundle.
     private static func bundle(in directoryURL: URL) -> PuzzleBundle? {
         let manifestURL = directoryURL.appendingPathComponent("manifest.json")
         guard let data = try? Data(contentsOf: manifestURL),
               let manifest = try? JSONDecoder().decode(Manifest.self, from: data) else {
             return nil
         }
         let entries = manifest.puzzles.map { puzzle in
             Entry(
                 id: puzzle.id,
                 title: puzzle.title,
                 publisher: puzzle.publisher,
                 gridWidth: puzzle.gridWidth,
                 gridHeight: puzzle.gridHeight,
                 blockCells: puzzle.blockMask.map { $0 == "#" },
                 sourceURL: directoryURL.appendingPathComponent("\(puzzle.id).xd")
             )
         }
         return PuzzleBundle(id: manifest.bundleID, name: manifest.name, puzzles: entries)
     }
 }