iOS版Poker2048游戏开发实战解析

最新推荐文章于 2025-04-26 15:14:22 发布

原创最新推荐文章于 2025-04-26 15:14:22 发布 · 881 阅读

CC 4.0 BY-SA版权

简介：Poker2048结合了经典数字游戏2048与扑克元素，增加了游戏的挑战性和趣味性。玩家通过滑动操作合并扑克牌以达到消除的目的。本文将从游戏机制、源码结构、Swift编程应用、UI设计与动画效果、数据持久化及测试调试等方面深入解析iOS版Poker2048的开发过程，提供学习iOS游戏开发的宝贵资料。技术专有名词：iOS

1. Poker2048游戏机制介绍

1.1 游戏概述

Poker2048是结合了经典2048拼图游戏与扑克牌元素的变体，旨在为玩家提供新颖的游戏体验。游戏的核心机制是通过简单的滑动操作合并相同数值的扑克牌，直到达到2048这一目标点数。

1.2 游戏规则

玩家通过上下左右滑动屏幕上的扑克牌，相同数值的扑克牌接触后会合并，每次操作后会随机生成新的扑克牌。游戏结束条件通常是玩家无法再进行合并操作或达到一定的分数。

1.3 游戏逻辑与优化

为了保证游戏的可玩性和挑战性，游戏逻辑经过精心设计，包括初始牌面的生成、游戏难度的逐步提升以及游戏结束后的重新开始机制。同时，游戏界面的简洁性和流畅的动画效果也为玩家提供了更好的游戏体验。

2. ViewController.swift文件解析

2.1 ViewController的生命周期

2.1.1 初始化与视图加载

在iOS应用开发中， ViewController 的生命周期涉及到从初始化到视图加载完毕的多个阶段。在此过程中，开发者可以执行各种操作以满足应用的具体需求。当一个 ViewController 实例被创建时，其构造器 init 被调用，接着 loadView 方法被用来加载或创建一个视图层次结构，最后通过 viewDidLoad 方法通知视图已经被成功加载。

override init(nibName nibNameOrNil: String?, bundle nibBundleOrNil: Bundle?) {
    super.init(nibName: nibNameOrNil, bundle: nibBundleOrNil)
    // 初始化代码
}

override func loadView() {
    super.loadView()
    // 加载视图代码
}

override func viewDidLoad() {
    super.viewDidLoad()
    // 视图加载完毕后的代码
}

初始化 ( init ) : 在这个方法里，我们通常做一些基本的配置，比如设置初始值。
加载视图 ( loadView ) : loadView 是用来加载或创建视图层次结构的地方，开发者可以自定义视图层次结构，也可以调用 super.loadView() 来使用默认的视图层次结构。
视图加载完毕 ( viewDidLoad ) : 在视图层次结构加载完毕后， viewDidLoad 方法会被调用，此时可以对视图进行进一步的配置。

2.1.2 视图控制器的状态转换

视图控制器（ ViewController ）存在多种状态，包括活跃、非活跃、展示或隐藏等。开发者需要理解这些状态的转换，以实现流畅的用户交互体验。状态转换通常伴随生命周期方法的调用。

override func viewWillAppear(_ animated: Bool) {
    super.viewWillAppear(animated)
    // 视图即将出现在屏幕上时调用
}

override func viewDidAppear(_ animated: Bool) {
    super.viewDidAppear(animated)
    // 视图已经出现在屏幕上时调用
}

override func viewWillDisappear(_ animated: Bool) {
    super.viewWillDisappear(animated)
    // 视图即将消失时调用
}

override func viewDidDisappear(_ animated: Bool) {
    super.viewDidDisappear(animated)
    // 视图已经消失时调用
}

即将出现 ( viewWillAppear ) : 在视图即将被添加到视图层次结构中时调用。
已出现 ( viewDidAppear ) : 在视图已经被添加到视图层次结构中并且显示在屏幕上后调用。
即将消失 ( viewWillDisappear ) : 在视图从视图层次结构中被移除之前调用。
已消失 ( viewDidDisappear ) : 在视图被从视图层次结构中移除并且不再显示在屏幕上后调用。

2.2 ViewController与视图交互

2.2.1 视图布局与事件处理

ViewController 负责管理其视图的布局和事件处理。布局通常在 viewDidLoad 方法中完成，事件处理则依赖于视图控制器响应视图动作的方法。

@IBOutlet weak var myButton: UIButton! // Interface Builder中的IBOutlet连接

override func viewDidLoad() {
    super.viewDidLoad()
    setupViews() // 自定义方法，用于布局
}

@IBAction func buttonPressed(_ sender: UIButton) {
    // 处理按钮点击事件
}

视图布局 ( setupViews ) : 通过约束或直接操作视图属性来设置视图的布局。
事件处理 ( buttonPressed ) : 通过 IBAction 方法响应用户的交互动作。

2.2.2 视图控制器的数据传递

当需要在不同视图控制器之间传递数据时，通常会使用代理（Delegate）模式或者闭包（Closure）。

protocol ViewControllerDelegate: AnyObject {
    func sendData(data: String)
}

class SecondViewController: UIViewController {
    weak var delegate: ViewControllerDelegate?
    func sendBackData() {
        let data = "传递的数据"
        delegate?.sendData(data: data)
    }
}

// 在使用的地方
let secondVC = SecondViewController()
secondVC.delegate = self

代理模式 : 定义一个协议 ViewControllerDelegate ，在视图控制器中声明一个遵循此协议的代理对象。
闭包 : 也可以使用闭包来完成类似代理的操作，闭包可以封装需要传递的数据和相关操作。

2.3 ViewController在游戏中的应用

2.3.1 游戏界面的切换逻辑

在游戏开发中，通常需要根据游戏的状态切换不同的界面，如开始菜单、游戏过程、暂停界面等。这些界面的切换需要在 ViewController 中妥善管理。

enum GameState {
    case mainMenu, playing, paused
}

var gameState = GameState.mainMenu

func showMainMenu() {
    gameState = GameState.mainMenu
    // 隐藏其他界面，显示主菜单
}

func startGame() {
    gameState = GameState.playing
    // 启动游戏
}

func pauseGame() {
    gameState = GameState.paused
    // 暂停游戏
}

游戏状态 ( GameState 枚举) : 定义游戏状态，通过状态控制不同界面的显示。
切换游戏界面 : 根据 gameState 的值来决定显示哪个界面，并隐藏其他界面。

2.3.2 与GameModel的交互机制

游戏模型（ GameModel ）负责维护游戏的数据状态，而 ViewController 则需要与之进行交互，以显示正确的游戏状态并响应用户操作。

class GameModel {
    var score: Int = 0
    // 游戏数据的其他属性和方法
}

class ViewController: UIViewController {
    var gameModel: GameModel!

    func updateScoreLabel() {
        scoreLabel.text = "\(gameModel.score)"
    }
    func resetGame() {
        gameModel.reset()
        updateScoreLabel()
    }
}

// GameModel的实现
class GameModel {
    func reset() {
        score = 0
        // 重置其他游戏数据
    }
}

更新UI ( updateScoreLabel ) : 根据 GameModel 的数据更新UI元素。
重置游戏 ( resetGame ) : 与 GameModel 交互以重置游戏状态，并同步更新UI。

通过以上代码块和逻辑分析，我们可以看到 ViewController.swift 文件对于整个游戏项目的重要性和核心功能。它不仅涉及到界面的展示和用户交互，还涉及到游戏状态的管理以及与游戏模型的数据同步。这些都是构建一个流畅和响应用户操作的游戏体验不可或缺的部分。在后续章节，我们将探讨如何通过 Card.swift 和 GameModel.swift 文件来管理游戏逻辑和数据，以及如何实现用户界面的流畅切换和数据的实时更新。

3. Card.swift和GameModel.swift文件解析

3.1 Card类的设计与实现

3.1.1 Card类的属性和方法

Card 类是 Poker2048 游戏中的核心对象之一，它代表了游戏中的一张牌。在 Card.swift 文件中，这个类的设计与实现涉及了多个关键的属性和方法，使得每张牌都能承载游戏的逻辑和状态。

属性方面，每张 Card 对象可能包括其代表的数字值、当前是否为活跃状态以及在游戏板上的位置信息。例如：

value ：牌的数值，是2的倍数，如2、4、8等。
isActive ：标志牌当前是否可被操作。
position ：牌在游戏板上的坐标位置。

方法方面， Card 类提供了对牌进行操作的接口，比如翻转、移动、合并等：

flip() ：翻转牌面，通常用于开始或重置游戏时。
move(direction:) ：根据传入的方向参数移动牌。
combine() ：在牌与相邻的同数值牌相遇时触发合并。

class Card {
    var value: Int
    var isActive: Bool
    var position: (x: Int, y: Int)

    init(value: Int, position: (Int, Int)) {
        self.value = value
        self.isActive = true
        self.position = position
    }

    func flip() {
        // 翻转牌面逻辑
    }

    func move(direction: Direction) {
        // 移动牌逻辑
    }

    func combine() {
        // 合并牌逻辑
    }
}

3.1.2 Card类的实例化与使用

在 GameModel.swift 文件中， GameModel 类会负责管理所有 Card 实例的集合，并在游戏逻辑层面上使用这些实例。比如，当用户想要移动牌时， GameModel 会找到可以移动的牌，并调用 Card 实例的 move 方法。

实例化 Card 类通常是在游戏初始化阶段， GameModel 会创建一个 Card 实例数组，每个位置初始化为特定的值：

class GameModel {
    var cards: [Card] = []

    func initializeGameBoard() {
        // 初始化游戏板逻辑
        for x in 0..<4 {
            for y in 0..<4 {
                let card = Card(value: initialValueForPosition(x, y), position: (x, y))
                cards.append(card)
            }
        }
    }
}

// 辅助函数，用于获取每个位置的初始值
func initialValueForPosition(x: Int, y: Int) -> Int {
    // 根据位置计算初始值，比如中间两个位置为4，其余为2
}

3.2 GameModel的数据管理

3.2.1 游戏状态的数据结构

GameModel 是游戏的核心数据管理类，负责维护整个游戏的状态，包括当前所有的 Card 实例、分数以及游戏是否结束等信息。它使用了多种数据结构来存储这些状态信息。

例如，可以使用数组来存储所有的 Card 对象：

class GameModel {
    var cards: [Card] = []
    var score: Int = 0
    var isGameOver: Bool = false
    // 其他可能的状态变量
}

此外， GameModel 还可能使用字典或其他集合类型来存储额外的游戏信息，比如特殊事件的触发条件、历史分数等。

3.2.2 数据更新与状态同步

在游戏运行过程中， GameModel 需要实时更新游戏状态，并与 ViewController 同步以反映在用户界面上。每当 Card 状态发生变化时（例如牌被合并）， GameModel 会更新分数，并且可能触发游戏结束的逻辑判断。

数据同步是一个关键点，当 GameModel 的数据发生变化时，需要通过某种机制通知 ViewController 。这通常通过观察者模式或代理模式实现：

class GameModel {
    // 使用KVO或者其他通知机制通知ViewController
    func notifyScoreChange() {
        // 发送通知，更新UI等
    }

    func notifyGameOver() {
        // 游戏结束通知
    }
}

class ViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        // 注册监听GameModel的通知
    }
}

3.3 Model与ViewController的交互

3.3.1 游戏逻辑的实现与控制

GameModel 负责实现游戏的核心逻辑，例如牌的移动、合并等，而 ViewController 则将这些逻辑展示在界面上。当用户进行操作时， ViewController 会捕获到这些事件，并要求 GameModel 执行相应的操作。

例如，当用户触摸屏幕并滑动时：

class ViewController: UIViewController {
    // 滑动事件处理
    override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
        // 用户开始触摸
    }

    override func touchesMoved(_ touches: Set<UITouch>, with event: UIEvent?) {
        // 用户滑动
        // 将滑动方向传递给GameModel
    }
}

GameModel 接收到方向参数后，会调用相应的方法来移动牌，并返回操作结果。

3.3.2 数据变化对视图的影响

GameModel 中数据的变化需要实时反映到 ViewController 的视图上。当 GameModel 更新了 Card 的位置或状态时， ViewController 需要监听这些变化并刷新视图。

这通常通过属性观察者或通知机制实现：

class GameModel {
    // 使用属性观察者来观察卡片位置的变化
    private var cards: [Card] = [] {
        didSet {
            // 通知视图更新
        }
    }
}

class ViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        // 观察GameModel的属性变化
    }
}

通过以上实现，用户在游戏中的操作能即时被处理并以视觉反馈的形式展示出来，提供流畅的游戏体验。

4. GameDelegate.swift与Constants.swift文件解析

4.1 GameDelegate的代理模式应用

代理协议的定义与实现

代理模式是iOS开发中常见的设计模式之一，它允许一个类将某些任务的执行委托给另一个对象。GameDelegate类在Poker2048游戏中扮演着中心协调者的角色，它定义了一系列代理协议，并通过这些协议将游戏事件的监听和处理委托给外部对象，通常是ViewController。

代理协议的定义通常遵循这样的模式：首先在GameDelegate类中声明一个或多个协议，然后让需要响应游戏事件的类（如ViewController）遵循这些协议并实现相应的代理方法。这样，当特定事件发生时（例如游戏开始、结束或用户操作），GameDelegate可以调用相应的代理方法通知其他类进行处理。

protocol GameDelegateProtocol {
    func gameStarted()
    func gameEnded()
    func tileMoved(from: Int, to: Int)
    // 其他与游戏事件相关的代理方法
}

class GameDelegate {
    weak var delegate: GameDelegateProtocol?
    func startGame() {
        // 通知代理游戏开始
        delegate?.gameStarted()
    }
    // 其他游戏逻辑处理...
}

代理在游戏事件处理中的作用

代理模式的核心作用在于解耦。在Poker2048游戏中，ViewController并不需要直接与GameDelegate进行交互，而只是通过代理协议保持连接。当游戏事件发生时，GameDelegate作为中介，调用代理方法将事件传递给ViewController，然后由ViewController负责具体的事件响应逻辑。这种机制有助于维护代码的整洁性，使得ViewController的代码更加专注于用户界面和交互逻辑的实现。

此外，使用代理模式还可以方便地扩展游戏功能。当需要添加新的游戏事件监听者时，我们不需要修改GameDelegate的实现，只需确保新的监听者遵循相应的代理协议并实现必要的方法即可。

4.2 Constants的配置与优化

常量的分类与管理

Constants类负责管理游戏中使用到的所有常量。这些常量包括UI布局的尺寸、颜色代码、字体样式、动画时间、分数和等级系统等。将这些常量进行集中管理有助于维护代码的可读性和可维护性。

class Constants {
    static let cellSize: CGFloat = 100.0
    static let cellPadding: CGFloat = 20.0
    static let fontScoreTitle = UIFont.systemFont(ofSize: 24)
    // 其他UI、逻辑、资源等相关的常量
}

配置常量的版本控制与更新

在开发过程中，游戏的设计和需求可能会发生变化，从而导致某些常量值的变更。良好的版本控制实践对于管理这些常量非常关键。可以通过使用版本控制系统（如Git）来追踪这些变化，并在必要时进行回滚或合并更改。此外，使用常量还有一个优点，那就是当需要更新某个值时，只需在Constants类中修改一处即可，无需遍历整个项目代码。

// 假设在版本更新中，cellSize需要从100增加到110
class Constants {
    static let cellSize: CGFloat = 110.0 // 更新后的值
    // 其他常量保持不变...
}

在进行常量更新时，应该特别注意与版本控制相关的兼容性问题。如果旧版本的用户更新到新版本，需要确保旧数据与新常量之间的兼容性，避免出现数据错乱或界面布局问题。通常，需要在数据持久化和界面布局等方面添加适配代码，以确保新旧版本之间的平滑过渡。

通过以上两个小节的内容，我们可以看到代理模式和常量管理在iOS应用开发中的重要性。GameDelegate通过代理协议来协调不同组件间的交互，而Constants则通过集中管理配置信息来提高代码的可维护性。在下一章节中，我们将深入探讨Swift编程语言的特点和UIKit框架的应用，进一步提升开发效率和用户交互体验。

5. Swift编程语言特点及UIKit框架应用

5.1 Swift编程语言的特点与优势

5.1.1 Swift的语法特性

Swift语言自2014年首次发布以来，因其简洁、现代、安全的特性而迅速成为苹果开发者的新宠。与Objective-C相比，Swift摒弃了许多复杂的语言特性，如指针运算、宏定义等，取而代之的是更加直观、易读的语法。例如，Swift中的optionals用法，减少了空指针异常的风险；安全的类型转换，比如使用 as 、 is 关键字；以及元组（tuples）的引入，允许开发者在单个变量中存储多个值。

// Swift中使用optionals和安全的类型转换
func findPlayerInGame(playerName: String) -> Player? {
    for player in players {
        if player.name == playerName {
            return player // 返回一个可选值（optional）
        }
    }
    return nil // 明确地返回nil，安全地表示没有找到
}

// 使用元组来返回多个值
func calculateSizeOfImage(at url: URL) -> (width: Int, height: Int)? {
    guard let data = try? Data(contentsOf: url) else {
        return nil
    }
    let image = UIImage(data: data)
    guard let size = image?.size else {
        return nil
    }
    return (Int(size.width), Int(size.height)) // 返回一个包含宽度和高度的元组
}

在Swift中，类型推断让变量声明更加简洁，无需显式声明变量类型。在上例中， player 和 data 变量的类型被编译器自动推断，无需额外的类型标注。函数和方法的参数也支持默认参数、变参等特性，提高了代码的灵活性。

5.1.2 Swift的性能优化与安全特性

Swift不仅提供了高级语言的便利，还通过其编译时的优化机制提供了接近C语言的性能。Swift的编译器使用了优化技术，如LLVM，来提升代码的执行效率。同时，它加入了自动引用计数（ARC）来管理内存，减少了手动内存管理的错误。

// 自动引用计数示例
class Person {
    var name: String
    init(name: String) {
        self.name = name
        print("Person \(name) is being initialized")
    }
    deinit {
        print("Person \(name) is being deinitialized")
    }
}

var john: Person? = Person(name: "John")
john = nil // ARC将自动释放Person实例
// 输出: Person John is being initialized
// 输出: Person John is being deinitialized

安全特性方面，Swift通过强制可选值绑定、可选链和nil合并操作符等提供了一种处理nil值的安全方式，减少了程序因nil访问引发的崩溃。

5.2 UIKit框架的使用与动画效果实现

5.2.1 UIKit基础组件的应用

UIKit是iOS开发中用于构建用户界面的一个框架。它提供了一整套的界面元素，如 UIView 、 UIButton 、 UILabel 等，开发者可以利用这些组件来创建美观、交互性强的界面。

// 创建一个简单的UIView和UIButton
let view = UIView()
view.backgroundColor = .white
view.frame = CGRect(x: 0, y: 0, width: 200, height: 200)

let button = UIButton()
button.setTitle("Click Me", for: .normal)
button.backgroundColor = .blue
button.addTarget(self, action: #selector(buttonTapped), for: .touchUpInside)
button.frame = CGRect(x: 80, y: 80, width: 40, height: 40)

view.addSubview(button)

func buttonTapped(_ sender: UIButton) {
    print("Button was tapped")
}

在上述代码中，创建了一个简单的视图和一个按钮，按钮被添加到视图中。这个过程展示了UIKit中视图层级和事件处理的基础。

5.2.2 自定义动画效果与交互体验

UIKit为动画提供了强大的支持，开发者可以通过 UIView 的动画API来实现交互动画效果，使得用户界面流畅且吸引人。

// 动画示例：让按钮在屏幕上移动
func animateButton() {
    UIView.animate(withDuration: 2.0, animations: {
        button.center = CGPoint(x: view.bounds.midX, y: view.bounds.midY)
    })
}

// 调用函数启动动画
animateButton()

在上例中， animate(withDuration:animations:) 方法被用来创建一个简单的动画，使得按钮在两秒内从原位置移动到屏幕中央。通过这样的动画，不仅改善了用户的交互体验，也增强了应用的视觉吸引力。

UIKit框架通过这些基础组件和动画效果，使得开发者能够创建出既美观又实用的应用程序。通过深入学习UIKit的高级用法，开发者还可以创建出更为复杂的交互效果，进一步提升用户体验。

本章介绍了Swift编程语言的核心特点及UIKit框架在iOS开发中的应用。接下来的章节将探讨数据持久化技术的实现与测试调试过程。

6. 数据持久化实现与测试调试

6.1 数据持久化技术的实现

数据持久化是应用程序中不可或缺的一部分，它保证了应用即使在关闭后也能保持数据的完整性。在Poker2048游戏项目中，我们主要使用了文件存储与数据库存储两种方法来实现数据的持久化。

6.1.1 文件存储与数据序列化

iOS平台上的文件存储相对简单，主要利用NSKeyedArchiver和NSKeyedUnarchiver来进行对象的序列化和反序列化。下面是一个示例代码块，展示了如何将游戏的当前状态序列化存储到应用的文档目录：

// 将GameModel序列化并保存到文件
func saveGameModel(gameModel: GameModel) {
    let fileURL = try! FileManager.default.url(for: .documentDirectory, in: .userDomainMask, appropriateFor: nil, create: false).appendingPathComponent("gameModel.dat")
    do {
        try NSKeyedArchiver.archivedData(withRootObject: gameModel, requiringSecureCoding: false).write(to: fileURL)
    } catch {
        print("Error writing data: \(error)")
    }
}

// 从文件中读取GameModel
func loadGameModel() -> GameModel? {
    let fileURL = try! FileManager.default.url(for: .documentDirectory, in: .userDomainMask, appropriateFor: nil, create: false).appendingPathComponent("gameModel.dat")
    if fileURL.fileExists {
        do {
            let data = try Data(contentsOf: fileURL)
            return NSKeyedUnarchiver.unarchiveObject(with: data) as? GameModel
        } catch {
            print("Error reading data: \(error)")
        }
    }
    return nil
}

在此代码中，我们首先确定文件的URL路径，然后使用 NSKeyedArchiver 将 GameModel 对象序列化为 Data 类型，并将其写入到文件中。反之，使用 NSKeyedUnarchiver 从文件中读取数据，并反序列化为 GameModel 对象。

6.1.2 数据库存储与读写操作

对于结构化数据的存储，我们使用Core Data框架来管理数据库的存储和读写。下面是一个简单的示例，展示了如何使用Core Data进行对象的创建和查询操作：

// 获取托管对象上下文
lazy var persistentContainer: NSPersistentContainer = {
    let container = NSPersistentContainer(name: "Poker2048", managedObjectModel: model,协调器: nil)
    container.loadPersistentStores(completionHandler: { (storeDescription, error) in
        if let error = error as NSError? {
            fatalError("未能加载持久化存储: \(error), \(error.userInfo)")
        }
    })
    return container
}()

// 创建并保存新的Card对象到数据库
func createCard(atPosition position: CGPoint) {
    let entity = NSEntityDescription.entity(forEntityName: "Card", in: persistentContainer.viewContext)!
    let card = NSManagedObject(entity: entity, insertInto: persistentContainer.viewContext)
    card.setValue(position.x, forKey: "positionX")
    card.setValue(position.y, forKey: "positionY")
    do {
        try persistentContainer.viewContext.save()
    } catch {
        let nserror = error as NSError
        fatalError("无法保存. \(nserror), \(nserror.userInfo)")
    }
}

// 查询数据库中的所有Card对象
func fetchAllCards() -> [Card] {
    let fetchRequest: NSFetchRequest<Card> = Card.fetchRequest()
    do {
        return try persistentContainer.viewContext.fetch(fetchRequest)
    } catch {
        let nserror = error as NSError
        fatalError("无法获取数据. \(nserror), \(nserror.userInfo)")
    }
}

在此代码中，我们首先创建了一个 NSPersistentContainer 实例，它封装了Core Data的持久化存储协调器。然后，我们定义了如何创建 Card 实体，并将其保存到上下文中。最后，我们展示了如何查询数据库中所有的 Card 对象。

6.2 测试与调试过程

测试是确保软件质量的关键步骤。在Poker2048游戏项目中，我们采用单元测试和集成测试来确保代码的质量，并使用调试工具来帮助解决出现的问题。

6.2.* 单元测试与集成测试

单元测试是针对最小可测试单元进行检查和验证的工作。在Swift中，我们使用XCTest框架进行单元测试。这里我们创建一个简单的测试用例，来验证 GameModel 中的得分计算逻辑是否正确。

// 测试GameModel中的得分计算逻辑
func testScoreCalculation() {
    let model = GameModel()
    model.cells = [
        [Card(rank: .two, suit: .hearts, value: 2, position: CGPoint(x: 0, y: 0))],
        [Card(rank: .four, suit: .clubs, value: 4, position: CGPoint(x: 1, y: 0))],
        // 更多卡片数据...
    ]
    model.updateScore()
    XCTAssertEqual(model.score, 6, "当前得分应为6")
}

在此测试用例中，我们创建了一个 GameModel 实例，并手动设置了一些 Card 实例。然后，我们调用 updateScore 方法来计算得分，并用 XCTAssertEqual 来验证计算出的得分是否符合预期。