[Swift][SwiftUI] actor を使って、LifeGame を作る(その4: 複数の初期パターンと自動進化）

class LGViewModel: ObservableObject {
    var board: LGBoard
    @Published var cells: [CellIndex:LGCellState] = [:]

    // NEW !!
    let nextGenInterval: TimeInterval = 2 // 2 sec.
    @Published var timerPubliser: AnyCancellable? = nil

    init(numX: Int, numY: Int,_ closure: @escaping BoardSetupClosure) {
        board = LGBoard(numX: numX, numY: numY, closure)
    }

    @MainActor
    func updateCells() async {
        cells = await board.boardStatus()
    }

    var numX: Int {
        board.numX
    }
    var numY: Int {
        board.numY
    }

    func doPrep() async {
        await board.doPrep()
    }
    func moveToNextGen() async {
        await board.moveToNextGen()
    }

    // NEW !!
    func toggleAuto() {
        if timerPubliser == nil {
            // start
            timerPubliser = Timer.TimerPublisher(interval: nextGenInterval, runLoop: .current, mode: .default)
                .autoconnect()
                .sink(receiveValue: { newDate in
                    Task {
                        await self.doPrep()
                        await self.moveToNextGen()
                        await self.updateCells()
                    }
                })
        } else {
            // stop
            timerPubliser = nil
        }
    }
}

struct LGBoardView: View {
    @EnvironmentObject var viewModel: LGViewModel

    var body: some View {
        VStack {
            Grid(horizontalSpacing: 0, verticalSpacing: 0) {
                ForEach(0..<viewModel.numY, id: \.self) { yIndex in
                    GridRow {
                        ForEach(0..<viewModel.numX, id: \.self) { xIndex in
                            let cellIndex = CellIndex(x: xIndex, y: yIndex)
                            let cellState = viewModel.cells[cellIndex] ?? .alive
                            LGCellView(cellState: cellState)
                                .animation(.default, value: cellState)
                        }
                    }
                }
            }
            HStack {
                Button(action: {
                    Task {
                        await viewModel.doPrep()
                        await viewModel.moveToNextGen()
                        await viewModel.updateCells()
                    }
                }, label: {Text("NextGen")})
                .buttonStyle(.bordered)
                .disabled(viewModel.timerPubliser != nil)
                Button(action: {
                    viewModel.toggleAuto()
                }, label: {Text("NextGen(Auto)")
                        .hidden()
                        .overlay {
                            Text(viewModel.timerPubliser == nil ? "NextGen(Auto)" : "Stop" )
                        }
                })
                .buttonStyle(.bordered)
            }
        }
        .onAppear {
            Task {
                await viewModel.updateCells()
            }
        }
    }
}

class LGViewModel: ObservableObject {
    // .. omit ..
    func modelSetup(_ closure: BoardSetupClosure ) async {
        await board.setup(closure)
        await updateCells()
    }
    // .. omit ..
}

struct LGBoardView: View {
    @EnvironmentObject var viewModel: LGViewModel
    @State private var selectedPattern: Int = 0

    var body: some View {
        VStack {
            Grid(horizontalSpacing: 0, verticalSpacing: 0) {
                // .. snip .. cell 表示
            }
            HStack {
                // .. snip .. ボタン表示
            }
            // 🆕
            Picker(selection: $selectedPattern, content: {
                Text("Blinker").tag(0)
                Text("Beacon").tag(1)
                Text("Octagon").tag(2)
            }, label: {
                Text("select pattern")
            })
            .disabled(viewModel.timerPubliser != nil)
        }
        .onAppear { Task { await viewModel.updateCells() } }
        // 🆕
        .onChange(of: selectedPattern) { pattern in
            Task {
                switch selectedPattern {
                case 0:
                    await viewModel.modelSetup(LGBoard.setupBlinker)
                case 1:
                    await viewModel.modelSetup(LGBoard.setupBeacon)
                case 2:
                    await viewModel.modelSetup(LGBoard.setupOctagon)
                default:
                    break
                }
            }
        }
    }
}

extension LGBoard {
    static let setupBlinker: BoardSetupClosure = { index in
        let liveCells = [CellIndex(x: 3, y: 3),
                         CellIndex(x: 3, y: 4),
                         CellIndex(x: 3, y: 5),
        ]
        if liveCells.contains(index) { return .alive }
        return .dead
    }
    static let setupBeacon: BoardSetupClosure = { index in
        let liveCells = [CellIndex(x: 2, y: 2), CellIndex(x: 3, y: 2),
                         CellIndex(x: 2, y: 3), CellIndex(x: 3, y: 3),
                         CellIndex(x: 4, y: 4), CellIndex(x: 5, y: 4),
                         CellIndex(x: 4, y: 5), CellIndex(x: 5, y: 5),
        ]
        if liveCells.contains(index) { return .alive }
        return .dead
    }
    static let setupOctagon: BoardSetupClosure = { index in
        let liveCells = [CellIndex(x: 3, y: 0), CellIndex(x: 4, y: 0),
                         CellIndex(x: 2, y: 1), CellIndex(x: 5, y: 1),
                         CellIndex(x: 1, y: 2), CellIndex(x: 6, y: 2),
                         CellIndex(x: 0, y: 3), CellIndex(x: 7, y: 3),
                         CellIndex(x: 0, y: 4), CellIndex(x: 7, y: 4),
                         CellIndex(x: 1, y: 5), CellIndex(x: 6, y: 5),
                         CellIndex(x: 2, y: 6), CellIndex(x: 5, y: 6),
                         CellIndex(x: 3, y: 7), CellIndex(x: 4, y: 7),

        ]
        if liveCells.contains(index) { return .alive }
        return .dead
    }
}