import SwiftUI


struct ContentView: View {
    @ObservedObject var viewModel: EmoojiMemoryGame
    
    var body: some View {
        
        ScrollView {
            LazyVGrid(columns: [GridItem(.adaptive(minimum: 65))]){
                ForEach(viewModel.cards) { card in
                    CardView(card: card).aspectRatio(2/3, contentMode: .fit)
                        .onTapGesture {
                            viewModel.choose(card)
                        }
                }
            }
        }
        .foregroundColor(.red)
        .padding(.horizontal)
        
    }
    
}

struct CardView: View {
    var card: MemoryGame<String>.Card
    
    var body: some View {
        ZStack {
            let shape = RoundedRectangle(cornerRadius: 20)
            if card.isFaceUp {
                shape.fill().foregroundColor(.white)
                shape.strokeBorder(lineWidth: 3)
                Text(card.content).font(.largeTitle)
            } else if card.isMatched {
                shape.opacity(0)
            } else {
                shape.fill()
            }
        }
 
    }
}


struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        let game = EmoojiMemoryGame()
        ContentView(viewModel: game)
            .preferredColorScheme(/*@START_MENU_TOKEN@*/.dark/*@END_MENU_TOKEN@*/)
        ContentView(viewModel: game)
            .preferredColorScheme(.light)
    }
}

EmojiMemoryGame.swift

import SwiftUI

class EmoojiMemoryGame: ObservableObject {
    
    static var emojis = ["??", "??", "?", "??", "??", "??", "??", "?", "??", "??","??","??", "??"]
    
    static func makeMemoryGame() -> MemoryGame<String> {
        MemoryGame<String>(numberOfPairOfCards: 4) {pairIndex in
            emojis[pairIndex]
        }
    }
    
    @Published private var model: MemoryGame<String> = makeMemoryGame()
    
    var cards: Array<MemoryGame<String>.Card> {
        model.cards
    }
    
    //MARK: Indent(s)
    func choose(_ card: MemoryGame<String>.Card) {
        model.choose(card)
    }
}

import Foundation

struct MemoryGame<CardContent> where CardContent: Equatable {
    private(set) var cards: Array<Card>
    
    private var indexOfTheOneAndOnlyFaceUpCard: Int?
  
    
    mutating func choose(_ card: Card) {
        if let chosenIndex = cards.firstIndex(where: {$0.id == card.id}), !cards[chosenIndex].isMatched,
            !cards[chosenIndex].isFaceUp
        {
            //匹配上了的規(guī)則
            if let potentialMatchIndex = indexOfTheOneAndOnlyFaceUpCard {
                if cards[chosenIndex].content == cards[potentialMatchIndex].content {
                    cards[chosenIndex].isMatched = true
                    cards[potentialMatchIndex].isMatched = true
                }
                //匹配上了則唯一朝上卡的index為nil，不存在了
                indexOfTheOneAndOnlyFaceUpCard = nil
            } else {
                //沒匹配上則所有卡都朝下
                for index in cards.indices {
                    cards[index].isFaceUp = false
                }
                //唯一朝上卡的index就是你選中的
                indexOfTheOneAndOnlyFaceUpCard = chosenIndex
            }

        cards[chosenIndex].isFaceUp.toggle()
        }
    }
    
    init(numberOfPairOfCards: Int, createCardContent:(Int) -> CardContent) {
        cards = []
        for pairIndex in 0..<numberOfPairOfCards {
            let content = createCardContent(pairIndex)
            cards.append(Card(content: content, id: pairIndex*2))
            cards.append(Card(content: content, id: pairIndex*2+1))
        }
    }
    
    struct Card: Identifiable {
        var isFaceUp: Bool = false
        var isMatched: Bool = false
        var content: CardContent
        var id: Int
    }
}