안내 시점, 그리고 피파가 말하는 거리

  /// Highway announcement plan from this speed (m/s; 19.4 = 70 km/h).
  public var highwaySpeed: Double = 19.4
  /// Two maneuvers closer than this are spoken together.
  public var chainDistance: Double = 180
  /// The town plan's trigger distances (the highway plan is fixed).
  public var townPlan: [AnnouncementStage: Double] = [.early: 1000, .prepare: 300, .imminent: 90]

  // ...

  /// The trigger distances for each stage at a given speed.
  public func stageDistances(speed: Double?) -> [AnnouncementStage: Double] {
    if let speed, speed >= highwaySpeed {
      return [.early: 2000, .prepare: 1000, .imminent: 300]
    }
    return townPlan
  }

  /// The most urgent stage the car has reached for the next maneuver, once.
  /// Crossing two triggers between fixes (a GPS gap) speaks only the later
  /// one; right after a maneuver, the next one inside its early band is
  /// spoken at once with its real distance ("then, in 600 m ...").
  private mutating func nextAnnouncement() -> Announcement? {
    guard let next = nextSpokenStep(), let stage = currentBand(for: next.step) else { return nil }
    let distance = next.step.maneuverAlong - progress
    if let done = announced[next.index], done >= stage { return nil }
    announced[next.index] = stage
    let following = route.maneuvers.first { $0.index > next.index }
    let chained: String? = {
      guard stage >= .prepare, let following,
        following.step.maneuverAlong - next.step.maneuverAlong <= config.chainDistance
      else { return nil }
      return following.step.instruction
    }()
    return Announcement(
      stepIndex: next.index, stage: stage,
      distance: stage == .imminent ? .soon : SpokenDistance.from(metres: distance),
      instruction: next.step.instruction, kind: next.step.kind, thenInstruction: chained)
  }

import Foundation

// SpokenDistance, verbatim from GuidanceEngine.swift (origin/main):
/// A distance in the words a driver hears: rounded, never "287 m".
public enum SpokenDistance: Hashable, Codable, Sendable {
  case soon
  case meters(Int)
  /// Tenths of a kilometre, so 1.5 km is `kilometers(tenths: 15)`.
  case kilometers(tenths: Int)

  public static func from(metres: Double) -> SpokenDistance {
    // A provider's "no route" sentinel or a NaN is not a distance: said as
    // "soon", never converted (an Int conversion of it would trap).
    guard metres.isFinite, metres < 100_000_000 else { return .soon }
    // Ten-metre steps below the driving plan's shortest stage (walking).
    if metres < 75 {
      return .meters(max(10, Int((metres / 10).rounded()) * 10))
    }
    if metres < 950 {
      let rounded = max(100, Int((metres / 100).rounded()) * 100)
      return .meters(min(rounded, 900))
    }
    if metres < 2900 {
      // Half-kilometre steps up to 3 km ("1.5 km", "2 km", "2.5 km").
      return .kilometers(tenths: max(10, Int((metres / 500).rounded()) * 5))
    }
    return .kilometers(tenths: Int((metres / 1000).rounded()) * 10)
  }
}

// A driver (written for this lesson): the words PhraseBook.words(for:) builds.
func words(_ d: SpokenDistance) -> String {
  switch d {
  case .soon: return "잠시 후"
  case .meters(let m): return "\(m)미터"
  case .kilometers(let t):
    return t % 10 == 0 ? "\(t / 10)킬로미터" : String(format: "%.1f킬로미터", Double(t) / 10)
  }
}

for measured in [7.0, 43, 74, 76, 149, 287, 951, 1260, 2740, 2950, 7420, .infinity] {
  print("measured \(measured) m -> said \(words(SpokenDistance.from(metres: measured)))")
}
// measured 7.0 m -> said 10미터
// measured 43.0 m -> said 40미터
// measured 74.0 m -> said 70미터
// measured 76.0 m -> said 100미터
// measured 149.0 m -> said 100미터
// measured 287.0 m -> said 300미터
// measured 951.0 m -> said 1킬로미터
// measured 1260.0 m -> said 1.5킬로미터
// measured 2740.0 m -> said 2.5킬로미터
// measured 2950.0 m -> said 3킬로미터
// measured 7420.0 m -> said 7킬로미터
// measured inf m -> said 잠시 후