[Swift][SwiftUI] actor を使って、LifeGame を作る(その6：パターン作成・保存機能)

class LGViewModel: ObservableObject {
    // ...snip...
    func toggleCell(_ index: CellIndex) async {
        await board.toggleCell(index)
        await updateCells()
    }
}

actor LGBoard: ObservableObject {
    // ...snip...
    func toggleCell(_ index: CellIndex) {
        cells[index]?.toggle()
    }
}

class LGCell {
　　// ...snip...
    func toggle() {
        state.toggle()
    }
}

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

    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)
                                .onTapGesture {
                                    Task {
                                        await viewModel.toggleCell(cellIndex)
                                    }
                                }
                        }
                    }
                }
            }
            // ...snip...
        }
    }
}

struct BoardData {
    let numX: Int
    let numY: Int
    let cells:[CellIndex: LGCellState]
}

actor LGBoard: ObservableObject {
    // ... omit ...
    init(_ boardData: BoardData ) {
        self.numX = boardData.numX
        self.numY = boardData.numY
        for index in boardData.cells.keys {
            cells[index] = LGCell(state: boardData.cells[index] ?? .alive)
        }
    }
    func boardData() async -> BoardData {
        let cellStatus = await self.boardStatus()
        return BoardData(numX: numX, numY: numY, cells: cellStatus)
    }
}

class LGViewModel: ObservableObject {
    var board: LGBoard
    @Published var cells: [CellIndex:LGCellState] = [:]
    // !!! NEW !!!
    @Published var savedBoards: [(String,BoardData)] = []
}

class LGViewModel: ObservableObject {
    // ... omit ...
    @MainActor
    func save(_ name: String) async {
        let boardData = await board.boardData()
        self.savedBoards.append((name, boardData))
    }
}

        .sheet(isPresented: $showSheet) {
            VStack {
                TextField(text: $patternName, label: { Text("Pattern Name: ") })
                    .textFieldStyle(.roundedBorder).padding()
                HStack {
                    Button(action: {
                        guard patternName != "" else { return }
                        Task {
                            await viewModel.save(patternName)
                            patternName = ""
                        }
                        showSheet.toggle()
                    }, label: { Text("OK") }).disabled(patternName=="")
                    Button(action: { showSheet.toggle() }, label: { Text("Cancel") })
                }
            }
            .presentationDetents([.fraction(0.3)]) // half-modal
            .padding()
        }

Picker(selection: $selectedPattern, content: {
    // (1)
    Text("Blinker").tag("Blinker")
    Text("Beacon").tag("Beacon")
    Text("Octagon").tag("Octagon")
    // (2)
    ForEach(viewModel.savedBoards, id: \.0) { item in
        // (3)
        Text(item.0)
          // (4)
          .tag(item.0)
    }
}, label: {
    Text("select pattern")
})
.onChange(of: selectedPattern) { name in
    Task {
        // (5)
        switch name {
        // (6)
        case "Blinker":
            await viewModel.modelSetup(LGBoard.setupBlinker)
        case "Beacon":
            await viewModel.modelSetup(LGBoard.setupBeacon)
        case "Octagon":
            await viewModel.modelSetup(LGBoard.setupOctagon)
        default:
            // (7)
            if let data = viewModel.savedBoards.first(where: {$0.0 == name}) {
                await viewModel.modelSetup(data.1)
            }
        }
    }
}

class LGViewModel: ObservableObject {
    // ... omit ...
    @MainActor
    func remove(_ name: String) {
        if let index = savedBoards.firstIndex(where: {$0.0 == name}) {
            savedBoards.remove(at: index)
        }
    }
}

Button(action: {
    viewModel.remove(selectedPattern)
    selectedPattern = "Blinker"
}, label: { Image(systemName: "trash") })

Button(action: {
    Task {
        await viewModel.modelSetup({ _ in
             .dead
        })
    }
 }, label: { Text("Clear") })

//
//  LifeGame2022App.swift
//
//  Created by : Tomoaki Yagishita on 2022/11/11
//  © 2022  SmallDeskSoftware
//

import SwiftUI

@main
struct LifeGame2022App: App {
    @StateObject var viewModel: LGViewModel = LGViewModel(numX: 8, numY: 8, LGBoard.setupBlinker)
    var body: some Scene {
        WindowGroup {
            MainView()
                .environmentObject(viewModel)
        }
    }
}

//
//  LGBoardView.swift
//
//  Created by : Tomoaki Yagishita on 2023/01/10
//  © 2023  SmallDeskSoftware
//

import SwiftUI

struct LGBoardView: View {
    @EnvironmentObject var viewModel: LGViewModel
    @State private var selectedPattern: String = "Blinker"
    @State private var showSheet: Bool = false
    @State private var patternName: String = ""

    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)
                                .onTapGesture {
                                    Task {
                                        await viewModel.toggleCell(cellIndex)
                                    }
                                }
                        }
                    }
                }
            }
            Button(action: {
                Task {
                    await viewModel.doPrep()
                    await viewModel.moveToNextGen()
                    await viewModel.updateCells()
                }
            }, label: {Text("NextGen")})
            .buttonStyle(.bordered)
            .disabled(viewModel.timerPubliser != nil)
            HStack {
                Button(action: {
                    viewModel.toggleAuto()
                }, label: {Text("NextGen(Auto)")
                        .hidden()
                        .overlay {
                            Text(viewModel.timerPubliser == nil ? "NextGen(Auto)" : "Stop" )
                        }
                })
                .buttonStyle(.bordered)
                HStack {
                    Image(systemName: "hare")
                    Text(viewModel.nextGenIntervalString)
                    Slider(value: Binding(get: {
                        log10(viewModel.nextGenInterval / (0.01) )
                    }, set: { newValue in
                        viewModel.nextGenInterval = 0.01 * pow(10.0, newValue)
                    }),
                           in: 1...2.5,
                           label: { Text("Interval") })
                    Image(systemName: "tortoise")
                }
            }
            HStack {
                Picker(selection: $selectedPattern, content: {
                    Text("Blinker").tag("Blinker")
                    Text("Beacon").tag("Beacon")
                    Text("Octagon").tag("Octagon")
                    ForEach(viewModel.savedBoards, id: \.0) { item in
                        Text(item.0)
                            .tag(item.0)
                    }
                }, label: {
                    Text("select pattern")
                })
                .fixedSize()
                .disabled(viewModel.timerPubliser != nil)
                Button(action: {
                    showSheet.toggle()
                }, label: {Text("Save")})
                Button(action: {
                    viewModel.remove(selectedPattern)
                    selectedPattern = "Blinker"
                }, label: { Image(systemName: "trash") })
                Button(action: {
                    Task {
                        await viewModel.modelSetup({ _ in
                                .dead
                        })
                    }
                }, label: { Text("Clear") })
            }
        }
        .onAppear { Task { await viewModel.updateCells() } }
        .onChange(of: selectedPattern) { name in
            Task {
                switch name {
                case "Blinker":
                    await viewModel.modelSetup(LGBoard.setupBlinker)
                case "Beacon":
                    await viewModel.modelSetup(LGBoard.setupBeacon)
                case "Octagon":
                    await viewModel.modelSetup(LGBoard.setupOctagon)
                default:
                    if let data = viewModel.savedBoards.first(where: {$0.0 == name}) {
                        await viewModel.modelSetup(data.1)
                    }
                }
            }
        }
        .sheet(isPresented: $showSheet) {
            VStack {
                TextField(text: $patternName, label: { Text("Pattern Name: ") })
                    .textFieldStyle(.roundedBorder)
                    .padding()
                HStack {
                    Button(action: {
                        guard patternName != "" else { return }
                        Task {
                            await viewModel.save(patternName)
                        }
                        showSheet.toggle()
                    }, label: { Text("OK") }).disabled(patternName=="")
                    Button(action: { showSheet.toggle() }, label: { Text("Cancel") })
                }
            }
            .presentationDetents([.fraction(0.3)])
            .padding()
        }
    }
}

struct LGBoardView_Previews: PreviewProvider {
    static var previews: some View {
        LGBoardView()
    }
}

//
//  LGCellView.swift
//
//  Created by : Tomoaki Yagishita on 2023/01/10
//  © 2023  SmallDeskSoftware
//

import SwiftUI

struct LGCellView: View {
    let cellState: LGCellState
    var body: some View {
        Image(systemName: symbolName)
            .resizable().aspectRatio(contentMode: .fit)
            .frame(maxWidth: .infinity)
            .rotation3DEffect(.degrees(cellState == .alive ? 0: 180), axis: (x: 0, y: -1, z: 0))
    }

    var symbolName: String {
        switch cellState {
        case .alive:
            return "circle"
        case .dead:
            return "xmark"
        }
    }
}

struct LGCellView_Previews: PreviewProvider {
    static var previews: some View {
        HStack {
            LGCellView(cellState: .alive)
            LGCellView(cellState: .dead)
        }
    }
}

//
//  LGViewModel.swift
//
//  Created by : Tomoaki Yagishita on 2023/01/10
//  © 2023  SmallDeskSoftware
//

import Combine
import SwiftUI

class LGViewModel: ObservableObject {
    var board: LGBoard
    @Published var cells: [CellIndex:LGCellState] = [:]
    @Published var savedBoards: [(String,BoardData)] = []

    @Published var nextGenInterval: TimeInterval = 2 { // 3 sec. {
        didSet {
            self.restartAuto()
        }
    }
    @Published var timerPubliser: AnyCancellable? = nil

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

    func modelSetup(_ closure: BoardSetupClosure ) async {
        await board.setup(closure)
        await updateCells()
    }

    func modelSetup(_ boardData: BoardData) async {
        board = LGBoard(boardData)
        await updateCells()
    }


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

    func toggleCell(_ index: CellIndex) async {
        await board.toggleCell(index)
        await updateCells()
    }

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

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

    let numberFormatter: NumberFormatter = {
        let nf = NumberFormatter()
        nf.numberStyle = .decimal
        nf.minimumFractionDigits = 2
        nf.maximumFractionDigits = 2
        return nf
    }()

    var nextGenIntervalString: String {
        numberFormatter.string(from: nextGenInterval as NSNumber)!
    }

    func restartAuto() {
        if timerPubliser == nil { return }
        timerPubliser = Timer.TimerPublisher(interval: nextGenInterval, runLoop: .current, mode: .default)
            .autoconnect()
            .sink(receiveValue: { newDate in
                Task {
                    await self.doPrep()
                    await self.moveToNextGen()
                    await self.updateCells()
                }
            })
    }

    func toggleAuto() {
        if timerPubliser == nil {
            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 {
            timerPubliser = nil
        }
    }

    @MainActor
    func save(_ name: String) async {
        let boardData = await board.boardData()
        self.savedBoards.append((name, boardData))
    }
    @MainActor
    func remove(_ name: String) {
        if let index = savedBoards.firstIndex(where: {$0.0 == name}) {
            savedBoards.remove(at: index)
        }
    }
}

//
//  LGBoard.swift
//
//  Created by : Tomoaki Yagishita on 2022/11/11
//  © 2022  SmallDeskSoftware
//

import Foundation
import Distributed

enum LGCellState: CustomStringConvertible, Codable {
    case alive, dead
    var description: String {
        switch self {
        case .alive:
            return "o"
        case .dead:
            return "x"
        }
    }
    mutating func toggle() {
        self = (self == .alive) ? .dead : .alive
    }
}

class LGCell: Codable {
    private(set) var state: LGCellState
    private(set) var nextState: LGCellState?

    init(state: LGCellState) {
        self.state = state
        self.nextState = nil
    }

    func toggle() {
        state.toggle()
    }

    func doPrep(_ nextState: LGCellState) {
        self.nextState = nextState
    }

    func moveToNextGen() {
        guard let nextState = nextState else { fatalError() }
        self.state = nextState
        self.nextState = nil
    }
}

struct CellIndex: Hashable, Codable {
    let x: Int
    let y: Int

    var north    : CellIndex { CellIndex(x: x-1, y: y  ) }
    var northWest: CellIndex { CellIndex(x: x-1, y: y-1) }
    var      west: CellIndex { CellIndex(x: x  , y: y-1) }
    var southWest: CellIndex { CellIndex(x: x+1, y: y-1) }
    var south    : CellIndex { CellIndex(x: x+1, y: y  ) }
    var southEast: CellIndex { CellIndex(x: x+1, y: y+1) }
    var      east: CellIndex { CellIndex(x: x  , y: y+1) }
    var northEast: CellIndex { CellIndex(x: x-1, y: y+1) }

    var nbrIndexes:[CellIndex] {
        [north, northWest, west, southWest,
         south, southEast, east, northEast]
    }
}

extension CellIndex: CustomStringConvertible {
    var description: String {
        return String("(\(x),\(y))")
    }
}

typealias BoardSetupClosure = (CellIndex) -> LGCellState

struct BoardData: Codable {
    let numX: Int
    let numY: Int
    let cells:[CellIndex: LGCellState]
}

actor LGBoard: ObservableObject {
    nonisolated let numX: Int
    nonisolated let numY: Int

    var cells:Dictionary = [:]
    init(numX: Int, numY: Int,_ closure: BoardSetupClosure = { index in .alive }) {
        self.numX = numX
        self.numY = numY
        for x in 0.. LGCellState? {
        return cells[index]?.state
    }

    func toggleCell(_ index: CellIndex) {
        cells[index]?.toggle()
    }
    func boardStatus() async -> [CellIndex: LGCellState] {
        var newDic: [CellIndex: LGCellState] = [:]
        for key in cells.keys {
            if let cell = cells[key] {
                newDic[key] = cell.state
            }
        }
        return newDic
    }

    func boardData() async -> BoardData {
        let cellStatus = await self.boardStatus()
        return BoardData(numX: numX, numY: numY, cells: cellStatus)
    }

    func countAliveInNbrCells(center: CellIndex) -> Int {
        var numOfAlive = 0
        for index in center.nbrIndexes {
            guard let cell = cells[index] else { continue }
            if cell.state == .alive {
                numOfAlive += 1
            }
        }
        return numOfAlive
    }

    func doPrep() {
        for index in cells.keys {
            guard let cell = cells[index] else { continue }
            let nbrNumOfAlive = countAliveInNbrCells(center: index)
            let nextState: LGCellState
            switch cell.state {
            case .alive:
                nextState = (nbrNumOfAlive == 2)||(nbrNumOfAlive == 3) ? .alive : .dead
            case .dead:
                nextState = nbrNumOfAlive == 3 ? .alive : .dead
            }
            cell.doPrep(nextState)
        }
    }

    func moveToNextGen() {
        for key in cells.keys {
            cells[key]?.moveToNextGen()
        }
    }

}

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
    }
}