叙述者 (Narratore)

import Foundation
import Narratore

// ------ Define a game setting ------ //

enum MyGame: Setting {
  enum Generate: Generating {
    static func randomRatio() -> Double {
      Double((0...1000).randomElement()!)/1000
    }
    
    static func uniqueString() -> String {
      UUID().uuidString
    }
  }
  
  struct Message: Messaging {
    var id: String?
    var text: String
  }

  struct Tag: Tagging {
    var value: String
    
    init(_ value: String) {
      self.value = value
    }
  }
  
  struct World: Codable {
    var isEnjoyable = true
  }
}

// ------ Write a story ------ //

extension SceneType {
  typealias Game = MyGame
}

extension MyGame: Story {
  static let scenes: [RawScene<MyGame>] = [
    MyFirstScene.raw,
    MySecondScene_Main.raw,
    MySecondScene_Other.raw,
  ]
}

struct MyFirstScene: SceneType {
  typealias Anchor = String

  var steps: Steps {
    "Welcome"
    
    "This is your new game, built with narratore".with(tags: [.init("Let's play some sound effect!")])
    
    DO.check {
      .inCase($0.world.isEnjoyable) {
        .tell { "Enjoy!" }
      }
    }
    
    "Now choose".with(anchor: "We could jump right here from anywhere")
    
    DO.choose { _ in
      "Go to second scene, main path".onSelect {
        .tell {
          "Let's go to the second scene!"
            .with(id: "We can keep track of this message")
        } then: {
          .transitionTo(MySecondScene_Main(magicNumber: 42))  
        }
      }

      "Go to second scene, alternate path".onSelect {
        .tell {
          "Going to the alternate path of the second scene"
        } then: {
          .transitionTo(MySecondScene_Other())
        }
      }
    }
  }
}

struct MySecondScene_Main: SceneType {
  var magicNumber: Int

  var steps: [SceneStep<Self>] {
    "Welcome to the second scene"
    
    if magicNumber == 42 {
      "The magic number is \(magicNumber)"
    } else {
      "The magic number doesn't look right..."
    }
    
    "Hope you'll find this useful!"
  }
}

struct MySecondScene_Other: SceneType {
  var steps: [SceneStep<Self>] {
    "I see you chose the alternate path"
    
    "Bad luck!"
  }
}

// ------ Run the game ------ //

final class MyHandler: Handler {
  typealias Game = MyGame

  func handle(event: Event<MyGame>) {
    if case .gameEnded = event {
      print("Thanks for playing!")
    }
  }
  
  func acknowledge(narration: Narration<MyGame>) async -> Next<MyGame, Void> {
    for message in narration.messages {
      print(message)
      _ = readLine()
    }
    return .advance
  }
  
  func make(choice: Choice<MyGame>) async -> Next<MyGame, Option<MyGame>> {
    for (index, option) in choice.options.enumerated() {
      print(index, option.message)
    }
    
    while true {
      guard
        let captured = readLine(),
        let selected = Int(captured),
        choice.options.indices.contains(selected)
      else {
        print("Invalid input")
        continue
      }
      
      return .advance(with: choice.options[selected])
    }
  }
  
  func answer(request: Player<MyGame>.TextRequest) async -> Next<MyGame, Player<MyGame>.ValidatedText> {
    if let message = request.message {
      print(message)
    }

    guard let text = readLine() else {
      return .replay
    }

    switch request.validate(text) {
    case .valid(let validatedText):
      return .advance(with: validatedText)

    case .invalid(let optionalMessage):
      if let optionalMessage {
        print(optionalMessage)
      }
      return .replay
    }
  }
}

@main
enum Main {
  static func main() async {
    await Runner<MyGame>(
      handler: MyHandler(),
      status: .init(
        world: .init(),
        scene: MyFirstScene()
      )
    ).start()
  }
}