Question

我正在尝试做一个小的家庭作业纸牌游戏，我需要帮助。我正在构建一个Set游戏，并且当我选择三张卡时，我试图检查Array中的三张卡是否相等。问题是我正在使用模型来构建此逻辑，因此其中的内容是通用的，我不知道如何比较两个CardContents。

这是我的模型：

struct SetGame<CardContent> {
   private(set) var cards: Array<Card>
   private(set) var initialCards: Int
   private var selected: Array<Card> {
       get { cards.filter { $0.isSelected } }
   }

   init(deck: Array<CardContent>, initialCards: Int) {
       cards = [Card]()
       self.initialCards = initialCards
       let starterSet = Array(deck[0..<initialCards])
       for (index, card) in starterSet.enumerated() {
           cards.append(Card(content: card, id: index))
       }
   }

   mutating func select(card: Card) {
       if let selectedIndex = cards.firstIndex(matching: card) {
           cards[selectedIndex].isSelected = !cards[selectedIndex].isSelected && selected.count < 3
       }
       if selected.count == 3 {
           let isSet = selected.allEqual()
           print(isSet)
       }
   }

   struct Card: Identifiable, Equatable {
       var content: CardContent
       var id: Int
       var isSelected: Bool = false
    
       // Binary operator '==' cannot be applied to two 'CardContent' operands
       static func ==(lhs: Card, rhs: Card) -> Bool {
           return lhs.content == rhs.content
       }
}

}

您可以看到我正在尝试向Card结构添加'=='方法，但是我无法比较CardContents。在我的 ViewModel 中，我正在构建具有自定义Feature结构作为内容的卡。

class SetGameViewModel: ObservableObject {
@Published private var game: SetGame<Feature> = SetGame<Feature>(deck: createDeck(), initialCards: 12)

private static func createDeck() -> Array<Feature> {
    var deck = [Feature]()
    
    for number in Feature.Number.allCases {
        for shape in Feature.Shape.allCases {
            for shade in Feature.Shading.allCases {
                for color in Feature.Color.allCases {
                    deck.append(Feature(number: number, shape: shape, shading: shade, color: color))
                }
            }
        }
    }
    deck.shuffle()
    return deck

    // ...
}

这是我的功能结构：

struct Feature: Equatable {
private var number: Number
private var shape: Shape
private var shading: Shading
private var color: Color

init(number: Number, shape: Shape, shading: Shading, color: Color) {
    self.number = number
    self.shape = shape
    self.shading = shading
    self.color = color
}

static func ==(first: Feature, second: Feature) -> Bool {
    return first.shape == second.shape
}

func equals(compareWith: Feature) -> Bool {
    return self.shape == compareWith.shape
}

enum Number: Int, CaseIterable {
    case one = 1, two, three
}

enum Shape: String, CaseIterable {
    case diamond, squiggle, oval
}

enum Shading: String, CaseIterable {
    case solid, striped, open // striped will be translucent to be easier
}

enum Color: String, CaseIterable {
    case red, green, purple
}

}

感谢您的帮助。 谢谢！

Answer 1

您可以通过确保即使您的通用参数也符合Equatable来解决此问题，如下所示：

struct SetGame<CardContent: Equatable> {

}

如何通过通用属性比较结构

1 个答案: