Swift实战之2048小游戏

上周在图书馆借了一本Swift语言实战入门，入个门玩一玩^_^正好这本书的后面有一个2048小游戏的实例，笔者跟着实战了一把。

差不多一周的时间，到今天，游戏的基本功能已基本实现，细节我已不打算继续完善，就这么整理一下过程中一些值得记录的点吧。

用的Swift版本是2.0，原书中的Swift版本会低一些，所以实践起来有些地方语法并不一样。

一、开始页面

在程序的第一张页面（Main.storyboard)上，只放了一个“开始游戏”按钮，点击按钮，弹出一个提示对话框，确认后，进入游戏页面。

1  @IBAction func startGame(sender: UIButton) {
2         let alerController = UIAlertController(title: "开始", message: "游戏就要开始，你准备好了吗？", preferredStyle: UIAlertControllerStyle.Alert)
3         alerController.addAction(UIAlertAction(title: "Ready Go!", style: UIAlertActionStyle.Default, handler: {
4             action in
5             self.presentViewController(MainTabViewController(), animated: true, completion: nil)
6         }))
7         self.presentViewController(alerController, animated: true, completion: nil)
8         
9     }

二、游戏页面

用一个TabViewController来实现，控制游戏页面（MainViewController）、设置页面(SettingViewController)和主题页面(KKColorListViewController)等三个页面的切换。

 1 import UIKit
 2 
 3 class MainTabViewController: UITabBarController,KKColorListViewControllerDelegate {
 4     var viewMain = MainViewController()
 5     var viewColor = KKColorListViewController(schemeType:KKColorsSchemeType.Crayola)
 6     override func viewDidLoad() {
 7         super.viewDidLoad()
 8 
 9         // Do any additional setup after loading the view.
10         
11         viewMain.title = "2048"
12         let user=UserModel.sharedInstance().user
13         if let red = user?.red{
14             let uicolor=UIColor(red: red, green: (user?.green)!, blue: (user?.blue)!, alpha: (user?.alpha)!)
15             viewMain.view.backgroundColor=uicolor
16         }
17         
18         let viewSetting = SettingViewController()
19         viewSetting.title = "设置"
20         
21         viewColor.title="颜色"
22         viewColor.headerTitle="选择背景色"
23         viewColor.delegate=self
24         
25         let main = UINavigationController(rootViewController: viewMain)
26         let setting = UINavigationController(rootViewController: viewSetting)
27         let color = UINavigationController(rootViewController: viewColor)
28         
29         self.viewControllers = [main, setting,color]
30         self.selectedIndex = 0
31     }
32 
33     override func didReceiveMemoryWarning() {
34         super.didReceiveMemoryWarning()
35         // Dispose of any resources that can be recreated.
36     }
37     
38     func colorListController(controller: KKColorListViewController!, didSelectColor color: KKColor!) {
39         viewMain.view.backgroundColor = color.uiColor()
40         
41         UserModel.sharedInstance().saveColor(color.uiColor())
42         self.selectedIndex=0
43     }
44     
45     func colorListPickerDidComplete(controller: KKColorListViewController!) {
46         self.selectedIndex=0
47     }
48 
49 }

（一）主题页面

其中，主题页面直接使用GitHub上的一个开源项目KKColorListViewController，选中颜色后，改变游戏页面的背景色。

这个项目可以从GitHub直接下载，但这个项目是用Objective-C写的，所以添加到Swift项目中后，需要新建一个Bridge头文件，这个头文件需要保存在项目文件夹的根目录下，而不是项目文件夹里面的源码文件夹（否则，可能需要自己配置头文件的目录）

1 #ifndef Bridging_Header_h
2 #define Bridging_Header_h
3 #import "KKColorListPicker.h"
4 
5 #endif /* Bridging_Header_h */

另外，添加到项目后，编译时还会有一些文件会报错，需要修改一些细节才能正常使用。

（1）KKColorsSchemeType.h中需添加

#import <Foundation/Foundation.h>

（2）KKColorListViewController中(void)collectionView:(UICollectionView *)collectionView didSelectItemAtIndexPath:(NSIndexPath *)indexPath方法，将最后一句注释掉。否则每次选完颜色，程序就会关闭当前的MainTabViewController而回到开始游戏页面。

1 - (void)collectionView:(UICollectionView *)collectionView didSelectItemAtIndexPath:(NSIndexPath *)indexPath
2 {
3     KKColor *color = self.colors[indexPath.row];
4     if (self.delegate) {
5         [self.delegate colorListController:self didSelectColor:color];
6     }
7 //    [self dismissViewControllerAnimated:YES completion:nil];
8 }

（二）游戏页面

1、ScoreView

游戏页面，上方有两个自定义的UIView，用于动态显示游戏分数。

 1 import UIKit
 2 
 3 enum ScoreType{
 4     case Common
 5     case Best
 6 }
 7 
 8 protocol ScoreViewProtocol{
 9     func changeScore(value s:Int)
10 }
11 
12 class ScoreView: UIView, ScoreViewProtocol {
13 
14     var label:UILabel!
15     let defaultFrame = CGRectMake(0, 0, 100, 30)
16     var stype:String!
17     
18     var score:Int = 0 {
19         didSet{
20             label.text = "(stype):(score)"
21         }
22     }
23     
24     init(stype: ScoreType){
25         super.init(frame: defaultFrame)
26         self.stype = (stype == ScoreType.Common ? "分数":"最高分")
27         
28         backgroundColor = UIColor.orangeColor()
29         label = UILabel(frame: defaultFrame)
30         label.textAlignment = NSTextAlignment.Center
31         label.font = UIFont(name: "微软雅黑", size: 16)
32         label.textColor = UIColor.whiteColor()
33         
34         self.addSubview(label)
35         
36         //布局约束
37         //必须将该属性值设置为false，否则自己设置的约束和AutoresizingMask生成的约束有冲突，运行时会产生异常
38         self.translatesAutoresizingMaskIntoConstraints = false
39         //宽度约束
40         self.widthAnchor.constraintEqualToConstant(100).active=true
41         //高度约束
42         self.heightAnchor.constraintEqualToConstant(30).active=true
43     }
44 
45     required init?(coder aDecoder: NSCoder) {
46         super.init(coder: aDecoder)
47     }
48     
49     func changeScore(value s: Int) {
50         self.score = s
51     }
52 
53 }

上面的ScoreView首先由一个ScoreType来选择显示“分数”还是“最高分”，然后有一个changeScore的方法，可以改变Score属性值，改变该值得时候同时改变Label显示的数字。

值得一提的是，在该UIView中，添加了布局约束，方便我们把该UIView添加到页面时控制它的布局。在iOS9.0中，多了一个NSLayoutAnchor类，用它来完成布局约束，比原来低版本用的NSLayoutConstraint要更方便一些。

2、按钮

游戏页面下方是两个按钮，重置清空本次游戏的数字，生成则产生一个数字，这两个按钮主要用于调试。

按钮是在一个ViewFactory的工厂类中生产的，同样生产时，添加了一些布局约束。

 1 class func createButton(title:String,action:Selector,sender:UIViewController) -> UIButton{
 2         let button = UIButton(frame: CGRectZero)
 3         button.backgroundColor=UIColor.orangeColor()
 4         button.setTitle(title, forState: .Normal)
 5         button.titleLabel!.textColor=UIColor.whiteColor()
 6         button.titleLabel!.font=UIFont.systemFontOfSize(14)
 7         
 8         //布局约束
 9         button.translatesAutoresizingMaskIntoConstraints = false
10         button.widthAnchor.constraintEqualToConstant(100).active=true
11         button.heightAnchor.constraintEqualToConstant(30).active=true
12         
13         button.addTarget(sender, action: action, forControlEvents: UIControlEvents.TouchUpInside)
14         return button
15     }

3、游戏区域（游戏地图）

一个5X5的矩阵，首先在所有位置上放置灰色的方块UIView。

 1 var backgrounds:Array<UIView>! //所有方块的背景
 2    func setupGameMap(){
 3         let margins = self.view.layoutMarginsGuide
 4         
 5         for row in 0..<self.dimension {
 6             for col in 0..<self.dimension {
 7                 //放置灰色的方块在对应的矩阵位置上
 8                 let background = UIView(frame: CGRectMake(0, 0, self.width, self.width))
 9                 background.backgroundColor = UIColor.darkGrayColor()
10                 background.translatesAutoresizingMaskIntoConstraints = false
11                 background.widthAnchor.constraintEqualToConstant(self.width).active = true
12                 background.heightAnchor.constraintEqualToConstant(self.width).active = true
13                 self.view.addSubview(background)
14                 self.backgrounds.append(background)
15                 
16                 //布局约束
17                 background.translatesAutoresizingMaskIntoConstraints=false
18                 background.widthAnchor.constraintEqualToConstant(self.width).active=true
19                 background.heightAnchor.constraintEqualToConstant(self.width).active=true
20                 
21                 //用代码进行布局约束
22                 var centerXConstant:CGFloat
23                 var centerYConstant:CGFloat
24                 if self.dimension%2 == 1 {
25                     centerXConstant = (self.padding+self.width) * CGFloat(col-self.dimension/2)
26                     centerYConstant = (self.padding+self.width) * CGFloat(row-self.dimension/2)
27                 }else{
28                     centerXConstant = (self.padding+self.width) * CGFloat(Double(col-self.dimension/2)+0.5)
29                     centerYConstant = (self.padding+self.width) * CGFloat(Double(row-self.dimension/2)+0.5)
30                 }
31                 
32                 background.centerXAnchor.constraintEqualToAnchor(margins.centerXAnchor, constant: centerXConstant).active=true
33                 background.centerYAnchor.constraintEqualToAnchor(margins.centerYAnchor, constant: centerYConstant).active=true
34 
35             }
36         }
37     }

然后，添加数字时，再在相应位置上放置数字方块TileView。

 1 var tiles = [NSIndexPath:TileView]() //存储当前的有数字的方块
 2 
 3 //插入一个数字方块
 4     func insertTile(pos:(Int,Int),value:Int){
 5         let (row,col)=pos
 6         
 7         let x=50 + CGFloat(col) * (self.width+self.padding)
 8         let y=150 + CGFloat(row) * (self.width+self.padding)
 9         
10         let tile=TileView(pos:CGPointMake(x,y),self.width,value:value)
11       
12         self.view.addSubview(tile)
13         self.view.bringSubviewToFront(tile)
14         
15         let index = NSIndexPath(forRow: row, inSection: col)
16         
17         tiles[index] = tile
18         
19         //布局约束
20         var centerXConstant:CGFloat
21         var centerYConstant:CGFloat
22         if self.dimension%2 == 1 {
23             centerXConstant = (self.padding+self.width) * CGFloat(col-self.dimension/2)
24             centerYConstant = (self.padding+self.width) * CGFloat(row-self.dimension/2)
25         }else{
26             centerXConstant = (self.padding+self.width) * CGFloat(Double(col-self.dimension/2)+0.5)
27             centerYConstant = (self.padding+self.width) * CGFloat(Double(row-self.dimension/2)+0.5)
28         }
29         let margins=self.view.layoutMarginsGuide
30         tile.centerXAnchor.constraintEqualToAnchor(margins.centerXAnchor, constant: centerXConstant).active=true
31         tile.centerYAnchor.constraintEqualToAnchor(margins.centerYAnchor, constant: centerYConstant).active=true
32     }

上面用了一个数字tiles来保存插入的TileView，以便清除数字时，可以把对应的TileView从界面中移除。

1     //移除一个数字方块
2     func clearTile(row:Int,col:Int){
3         
4         let index=NSIndexPath(forRow: row, inSection: col)
5         let tile=tiles[index]!
6         tile.removeFromSuperview()
7         tiles.removeValueForKey(index)
8         
9     }

TileView的实现代码如下：

 1 import Foundation
 2 import UIKit
 3 
 4 
 5 class TileView : UIView {
 6     let colorMap=[
 7         2:UIColor.redColor(),
 8         4:UIColor.orangeColor(),
 9         8:UIColor.lightTextColor(),
10         16:UIColor.greenColor(),
11         32:UIColor.brownColor(),
12         64:UIColor.blackColor(),
13         128:UIColor.purpleColor(),
14         256:UIColor.lightGrayColor(),
15         512:UIColor.cyanColor(),
16         1024:UIColor.magentaColor(),
17         2048:UIColor.blackColor()
18     ]
19     
20     var value:Int{
21         didSet{
22             backgroundColor=colorMap[value]
23             numberLabel.text="(value)"
24         }
25     }
26     
27     var numberLabel:UILabel!
28     
29     init(pos:CGPoint,CGFloat,value:Int){
30         self.value=value
31         
32         numberLabel=UILabel(frame: CGRectMake(0, 0, width, width))
33         numberLabel.textColor=UIColor.whiteColor()
34         numberLabel.textAlignment=NSTextAlignment.Center
35         numberLabel.minimumScaleFactor=0.5
36         numberLabel.font=UIFont(name: "微软雅黑", size: 20)
37         numberLabel.text="(value)"
38         
39         super.init(frame: CGRectMake(pos.x, pos.y,width , width))
40         addSubview(numberLabel)
41         backgroundColor=colorMap[value]
42         
43         //代码约束
44         self.translatesAutoresizingMaskIntoConstraints = false
45         self.widthAnchor.constraintEqualToConstant(width).active=true
46         self.heightAnchor.constraintEqualToConstant(width).active=true
47         
48     }
49 
50     required init?(coder aDecoder: NSCoder) {
51         self.value = 2
52         super.init(coder: aDecoder)
53     }
54     
55     
56 }

View Code

4、游戏模型

（1）游戏数据存储

采用一个自定义的矩阵数据结构，存储游戏数据。

//自定义矩阵，对应2048的游戏面板
struct Matrix {
    let rows:Int,columns:Int
    var grid:[Int]
    init(rows:Int,columns:Int){
        self.rows=rows
        self.columns=columns
        grid = Array<Int>(count: rows * columns, repeatedValue: 0)
    }
    
    func indexIsValidForRow(row:Int,column:Int)->Bool{
        return (row >= 0) && (row < rows) && (column >= 0) && (column < columns)
    }
    
    subscript(row:Int,column:Int)->Int{
        get{
            assert(indexIsValidForRow(row, column: column),"超出范围")
            return grid[(row * columns)+column]
        }
        set{
            assert(indexIsValidForRow(row, column: column),"超出范围")
            grid[(row * columns)+column]=newValue
        }
    }
    
//    相等函数，判断两个Matrix是否相等
    func isEqualTo(matrix:Matrix)->Bool{
        if rows != matrix.rows{
            return false
        }
        if columns != matrix.columns{
            return false
        }
        for i in 0..<rows{
            for j in 0..<columns{
                if self[i,j] != matrix[i,j]{
                    return false
                }
            }
        }
        return true
    }
}

游戏模型中，包含tiles和维度两个属性，用维度来对tiles这个Matrix进行初始化，同时，提供一些方法。

 1 class GameModel{
 2     var dimension:Int = 0{
 3         didSet{
 4             self.tiles = Matrix(rows: self.dimension, columns: self.dimension)
 5         }
 6     }
 7     var tiles:Matrix    
 8     init(dimension:Int){
 9         self.dimension=dimension
10         self.tiles = Matrix(rows: self.dimension, columns: self.dimension)
11     }
12     
13     func emptyPosition()->[Int]{
14         var emptytiles=Array<Int>()
15         for row in 0..<self.dimension{
16             for col in 0..<self.dimension{
17                 let val=tiles[row,col]
18                 if val==0 {
19                     emptytiles.append(tiles[row,col])
20                 }
21             }
22             
23         }
24         return emptytiles
25     }
26     
27     func isFull()->Bool{
28         if emptyPosition().count==0 {
29             return true
30         }
31         return false
32     }
33 //    打印矩阵，调试时使用
34     func printTiles(){
35         for i in 0..<self.dimension{
36             print(tiles.grid[(i*self.dimension)...((i+1)*self.dimension-1)])
37         }
38     }
39     
40 // 设置某个位置的值
41     func setPosition(row:Int,col:Int,value:Int)->Bool{
42         assert(row>=0 && row<dimension)
43         assert(col>=0 && col<dimension)
44         
45         print("值更新之前：")
46         printTiles()
47         
48         tiles[row,col]=value
49         
50         print("值更新之后：tiles[(row),(col)]=(tiles[row,col])")
51         printTiles()
52         return true
53     }
54 // 清除数据
55     func clearAll(){
56         tiles=Matrix(rows: self.dimension, columns: self.dimension)
57     }
58     
59 }

（2）游戏数据变更

产生一个数字：

 1     //生成新的数字，生成按钮的响应方法
 2     func genNumber(){
 3 ////        随机产生数字2和4，几率为1：4
 4 //        let randv=Int(arc4random_uniform(5))
 5 //        var seed:Int = 2
 6 //        if randv==1 {
 7 //            seed = 4
 8 //        }
 9 
10         let col=Int(arc4random_uniform(UInt32(dimension)))
11         let row=Int(arc4random_uniform(UInt32(dimension)))
12         
13         if gameModel.isFull(){
14             print("位置已经满了")
15             return
16         }
17         
18         if gameModel.tiles[row, col]>0 {
19             genNumber()
20             return
21         }
22         
23         let seed=2 //原书的程序，按照一定的几率比来生成2或4。此处改成一直生成2.
24         gameModel.setPosition(row, col: col, value: seed)
25         insertTile((row,col), value: seed)
26         
27         // 生成数字后，判断一下游戏是否结束
28         checkGameOver()
29     }

每次生成一个数字后，判断一下游戏是否结束。如果矩阵的所有位置都有数字，并且相邻位置的数字都不相同，则本轮游戏结束，弹出一个提示框，重新开始游戏。

 1     //检查游戏是否结束
 2     func checkGameOver(){
 3         if self.gameModel.isFull(){
 4             for row in 0..<self.dimension{
 5                 for col in 0..<self.dimension{
 6                     let val = gameModel.tiles[row,col]
 7                     let left:Int? = (col-1)>=0 ? gameModel.tiles[row,col-1] : nil
 8                     let right:Int? = (col+1)<self.dimension ? gameModel.tiles[row,col+1] : nil
 9                     let up:Int? = (row-1)>=0 ? gameModel.tiles[row-1,col] : nil
10                     let down:Int? = (row+1)<self.dimension ? gameModel.tiles[row+1,col] : nil
11                     if (val==left) || (val==right) || (val==up) || (val==down){
12                         return
13                     }
14                     
15                 }
16             }
17             
18             let alerController = UIAlertController(title: "游戏结束", message: "本轮游戏结束，重新开始吧！", preferredStyle: UIAlertControllerStyle.Alert)
19             alerController.addAction(UIAlertAction(title: "Ready Go!", style: UIAlertActionStyle.Default, handler: {
20                 action in
21                 self.resetGameMap()
22             }))
23             self.presentViewController(alerController, animated: true, completion: nil)
24             return
25         }
26     }

5、游戏效果实现

首先，是添加手势识别器，相当于对手势处理方法进行注册。

 1     //添加滑动的手势识别处理
 2     func setupSwipeGestures(){
 3         let upSwipe=UISwipeGestureRecognizer(target: self, action: Selector("swipeUp"))
 4         upSwipe.numberOfTouchesRequired=1
 5         upSwipe.direction=UISwipeGestureRecognizerDirection.Up
 6         self.view.addGestureRecognizer(upSwipe)
 7         
 8         let downSwipe=UISwipeGestureRecognizer(target: self, action: Selector("swipeDown"))
 9         downSwipe.numberOfTouchesRequired=1
10         downSwipe.direction=UISwipeGestureRecognizerDirection.Down
11         self.view.addGestureRecognizer(downSwipe)
12         
13         let leftSwipe=UISwipeGestureRecognizer(target: self, action: Selector("swipeLeft"))
14         leftSwipe.numberOfTouchesRequired=1
15         leftSwipe.direction=UISwipeGestureRecognizerDirection.Left
16         self.view.addGestureRecognizer(leftSwipe)
17         
18         let rightSwipe=UISwipeGestureRecognizer(target: self, action: Selector("swipeRight"))
19         rightSwipe.numberOfTouchesRequired=1
20         rightSwipe.direction=UISwipeGestureRecognizerDirection.Right
21         self.view.addGestureRecognizer(rightSwipe)
22         
23     }

然后，就是具体的处理方法，上下左右四个方向的滑动，会引起对应的方向上的数字重排和合并。原书中的处理是先将数字重排，然后进行合并。这里采用自己的逻辑方法，用递归的方式，对于值为0的位置，向后检索不为0的数字放入其中，并考虑是否要和相邻位置进行合并。

 1 var tileVals:Matrix //合并数字时所用的游戏数据复本
 2 
 3     //向上滑动
 4     func swipeUp(){
 5         tileVals = gameModel.tiles
 6         
 7         func merge(row row:Int,col:Int){
 8             if row == self.dimension-1{
 9                 return
10             }
11             
12             for i in (row+1)..<self.dimension {
13                 let valNew = tileVals[i,col]
14                 if valNew>0 {
15                     let val = tileVals[row, col]
16                     
17                     if val == 0 {
18                         tileVals[row, col] = valNew
19                         tileVals[i, col] = 0
20                         merge(row: row, col: col)
21                     }else if val == valNew{
22                         tileVals[row, col] = valNew<<1
23                         tileVals[i, col] = 0
24                         if row==0 {
25                             merge(row: row, col: col)
26                         }else{
27                             merge(row: row-1, col: col)
28                         }
29 //                        若产生合并，则加分
30                         changeScore(valNew)
31                     }else{
32                         merge(row: row+1, col: col)
33                     }
34                     
35                     break
36                 }
37             }
38         }
39         
40         for col in 0..<self.dimension{
41             merge(row: 0, col: col)
42         }
43         
44 //        如果合并后的结果与原来相同，则不做任何操作
45         if tileVals.isEqualTo(gameModel.tiles){
46             return
47         }
48 //        显示合并后的结果，并产生新的数字
49         refresh()
50         genNumber()
51     }

如果过程中产生合并，则进行加分。

1     //加分
2     func changeScore(baseNum:Int){
3         self.scoreView.score += baseNum * 2
4         
5     }

处理时，用了一个临时的Matrix变量tileVals来作处理，以便与未处理的数据进行比较，决定是否要进行后续的操作。如果处理后的数据与处理前不一致，则需要刷新页面中的游戏数据。

 1     //刷新页面
 2     func refresh(){
 3         for i in 0..<self.dimension{
 4             for j in 0..<self.dimension{
 5                 let val = gameModel.tiles[i,j]
 6                 let valNew = tileVals[i,j]
 7                 if valNew != val{
 8                     gameModel.setPosition(i, col: j, value: valNew)
 9                     if valNew>0{
10                         if val>0{
11                             clearTile(i, col: j)
12                         }
13                         insertTile((i,j) , value: valNew)
14                         
15                     }else{
16                         clearTile(i, col: j)
17                     }
18                 }
19                 
20             }
21         }
22     }

其他三个方向上的处理方法类似：

  1     //向下滑动
  2     
  3     func swipeDown(){
  4         tileVals = gameModel.tiles
  5         
  6         func merge(row row:Int,col:Int){
  7             if row == 0{
  8                 return
  9             }
 10             
 11             for var i=row-1;i>=0;i-- {
 12                 let valNew=tileVals[i,col]
 13                 if valNew>0 {
 14                     let val=tileVals[row,col]
 15                     
 16                     if val == 0 {
 17                         tileVals[row, col] = valNew
 18                         tileVals[i, col] = 0
 19                         merge(row: row, col: col)
 20                     }else if val == valNew{
 21                         tileVals[row, col] = valNew<<1
 22                         tileVals[i, col] = 0
 23 
 24                         if row==self.dimension-1 {
 25                             merge(row: row, col: col)
 26                         }else{
 27                             merge(row: row+1, col: col)
 28                         }
 29 //                        若产生合并，则加分
 30                         changeScore(valNew)
 31                     }else{
 32                         merge(row: row-1, col: col)
 33                     }
 34                     
 35                     break
 36                 }
 37             }
 38         }
 39         
 40         for col in 0..<self.dimension{
 41             merge(row: self.dimension-1, col: col)
 42         }
 43 //        如果合并后的结果与原来相同，则不做任何操作
 44         if tileVals.isEqualTo(gameModel.tiles){
 45             return
 46         }
 47         
 48         refresh()
 49         genNumber()
 50     }
 51     
 52     //向左滑动
 53     func swipeLeft(){
 54         tileVals = gameModel.tiles
 55         func merge(row row:Int,col:Int){
 56             if col == self.dimension-1{
 57                 return
 58             }
 59             
 60             for i in (col+1)..<self.dimension {
 61                 let valNew=tileVals[row,i]
 62                 if valNew>0 {
 63                     let val=tileVals[row,col]
 64                     
 65                     if val == 0 {
 66                         tileVals[row, col] = valNew
 67                         tileVals[row, i] = 0
 68                         merge(row: row, col: col)
 69                     }else if val == valNew{
 70                         tileVals[row, col] = valNew<<1
 71                         tileVals[row, i] = 0
 72                         if col==0 {
 73                             merge(row: row, col: col)
 74                         }else{
 75                             merge(row: row, col: col-1)
 76                         }
 77 //                        若产生合并，则加分
 78                         changeScore(valNew)
 79                     }else{
 80                         merge(row: row, col: col+1)
 81                     }
 82                     
 83                     break
 84                 }
 85             }
 86         }
 87         
 88         for row in 0..<self.dimension{
 89             merge(row: row, col: 0)
 90         }
 91         
 92 //        如果合并后的结果与原来相同，则不做任何操作
 93         if tileVals.isEqualTo(gameModel.tiles){
 94             return
 95         }
 96         refresh()
 97         genNumber()
 98     }
 99     
100     //向右滑动
101     func swipeRight(){
102         tileVals = gameModel.tiles
103         func merge(row row:Int,col:Int){
104             if col == 0{
105                 return
106             }
107             
108             for var i=col-1;i>=0;i-- {
109                 let valNew=tileVals[row, i]
110                 if valNew>0 {
111                     let val=tileVals[row, col]
112                     
113                     if val == 0 {
114                         tileVals[row, col] = valNew
115                         tileVals[row, i] = 0
116                         merge(row: row, col: col)
117                     }else if val == valNew{
118                         tileVals[row, col] = valNew<<1
119                         tileVals[row, i] = 0
120                         if col==self.dimension-1 {
121                             merge(row: row, col: col)
122                         }else{
123                             merge(row: row, col: col+1)
124                         }
125 //                        若产生合并，则加分
126                         changeScore(valNew)
127                     }else{
128                         merge(row: row, col: col-1)
129                     }
130                     
131                     break
132                 }
133             }
134         }
135         
136         for row in 0..<self.dimension{
137             merge(row: row, col: self.dimension-1)
138         }
139         
140 //        如果合并后的结果与原来相同，则不做任何操作
141         if tileVals.isEqualTo(gameModel.tiles){
142             return
143         }
144         refresh()
145         genNumber()
146         
147     }

View Code

（三）设置页面

设置页面可以设置游戏矩阵的维度。上面的阈值，游戏中数字超过该阈值可以视作通关，不过这个功能并没有实现，因为到后面对这个功能无甚兴趣~(≧▽≦)/~。

上面的几个控件都是在ViewFactory生产的，大多是一些常用控件，UISegmentedControl我倒是第一次用到，功能上有点像RadioButton，只是外观不一样。

ViewFactory的代码如下：

 1 import UIKit
 2 
 3 class ViewFactory {
 4     class func getDefaultFrame() -> CGRect {
 5         let defaultFrame = CGRectMake(0, 0, 100, 30)
 6         return defaultFrame
 7     }
 8     
 9     class func createControl(type:String, title:[String],action:Selector,sender:AnyObject)->UIView{
10         switch(type){
11             case "label": return ViewFactory.createLabel(title[0])
12             case "button": return ViewFactory.createButton(title[0], action: action, sender: sender as! UIViewController)
13             case "text":return ViewFactory.createTextField(title[0], action: action, sender: sender as! UITextFieldDelegate)
14             case "segment":return ViewFactory.createSegment(title, action: action, sender: sender as! UIViewController)
15         default: return ViewFactory.createLabel(title[0])
16         }
17     }
18     
19     class func createLabel(title:String) -> UILabel{
20         let label = UILabel()
21         label.textColor = UIColor.blackColor()
22         label.backgroundColor = UIColor.whiteColor()
23         label.text = title
24         label.frame = CGRectZero
25         label.font = UIFont(name: "HelveticaNeue-Bold", size: 16)
26         label.translatesAutoresizingMaskIntoConstraints = false
27         
28         return label
29     }
30     
31     class func createButton(title:String,action:Selector,sender:UIViewController) -> UIButton{
32         let button = UIButton(frame: CGRectZero)
33         button.backgroundColor=UIColor.orangeColor()
34         button.setTitle(title, forState: .Normal)
35         button.titleLabel!.textColor=UIColor.whiteColor()
36         button.titleLabel!.font=UIFont.systemFontOfSize(14)
37         
38         //布局约束
39         button.translatesAutoresizingMaskIntoConstraints = false
40         button.widthAnchor.constraintEqualToConstant(100).active=true
41         button.heightAnchor.constraintEqualToConstant(30).active=true
42         
43         button.addTarget(sender, action: action, forControlEvents: UIControlEvents.TouchUpInside)
44         return button
45     }
46     
47     class func createTextField(value:String,action:Selector,sender:UITextFieldDelegate) -> UITextField{
48         let textField=UITextField(frame: ViewFactory.getDefaultFrame())
49         textField.backgroundColor=UIColor.clearColor()
50         textField.textColor=UIColor.blackColor()
51         textField.text=value
52         textField.borderStyle=UITextBorderStyle.RoundedRect
53         textField.adjustsFontSizeToFitWidth=true
54         textField.delegate=sender
55         
56         textField.translatesAutoresizingMaskIntoConstraints = false
57         return textField
58     }
59     
60     class func createSegment(items:[String],action:Selector,sender:UIViewController)->UISegmentedControl {
61         let segment=UISegmentedControl(items: items)
62         segment.frame=ViewFactory.getDefaultFrame()
63         segment.momentary=false
64         segment.addTarget(sender, action: action, forControlEvents: UIControlEvents.ValueChanged)
65         
66         segment.translatesAutoresizingMaskIntoConstraints = false
67         return segment
68         
69     }
70 }

View Code

SettingViewController的实现：

 1 import UIKit
 2 
 3 class SettingViewController: UIViewController,UITextFieldDelegate {
 4     init(){
 5         super.init(nibName: nil, bundle: nil)
 6     }
 7 
 8     required init?(coder aDecoder: NSCoder) {
 9         super.init(coder: aDecoder)
10     }
11     
12     var main:MainViewController?
13     override func viewDidLoad() {
14         super.viewDidLoad()
15         self.view.backgroundColor=UIColor.whiteColor()
16         
17         let views = (self.parentViewController?.parentViewController as! MainTabViewController).viewControllers
18         main = ((views?[0] as? UINavigationController)?.childViewControllers)?[0] as? MainViewController
19         setupControls()
20         // Do any additional setup after loading the view.
21     }
22 
23     override func didReceiveMemoryWarning() {
24         super.didReceiveMemoryWarning()
25         // Dispose of any resources that can be recreated.
26     }
27     
28     var segDimension:UISegmentedControl?
29     func setupControls(){
30         let segVals = [3,4,5]
31         let textNum = ViewFactory.createTextField("", action: Selector("numChanged:"), sender: self)
32         textNum.returnKeyType=UIReturnKeyType.Done
33         
34         self.view.addSubview(textNum)
35         
36         let labelNum = ViewFactory.createLabel("阈值:")
37         self.view.addSubview(labelNum)
38         
39         segDimension = ViewFactory.createSegment(["3X3","4X4","5X5"], action: "dimensionChanged:", sender: self)
40         self.view.addSubview(segDimension!)
41         segDimension!.selectedSegmentIndex=segVals.indexOf((main?.dimension)!)!
42         
43         let labelDm=ViewFactory.createLabel("维度：")
44         self.view.addSubview(labelDm)
45         
46         //布局约束
47         let margins=self.view.layoutMarginsGuide
48         labelNum.widthAnchor.constraintEqualToConstant(60).active=true
49         labelNum.heightAnchor.constraintEqualToConstant(30).active=true
50         labelNum.leadingAnchor.constraintEqualToAnchor(margins.leadingAnchor, constant: 20).active=true
51         labelNum.topAnchor.constraintEqualToAnchor(margins.topAnchor, constant: 100).active=true
52         
53         textNum.widthAnchor.constraintEqualToConstant(200).active=true
54         textNum.heightAnchor.constraintEqualToConstant(30).active=true
55         textNum.leadingAnchor.constraintEqualToAnchor(labelNum.trailingAnchor).active=true
56         textNum.topAnchor.constraintEqualToAnchor(labelNum.topAnchor).active=true
57         
58         labelDm.widthAnchor.constraintEqualToConstant(60).active=true
59         labelDm.heightAnchor.constraintEqualToConstant(30).active=true
60         labelDm.leadingAnchor.constraintEqualToAnchor(labelNum.leadingAnchor).active=true
61         labelDm.topAnchor.constraintEqualToAnchor(textNum.topAnchor, constant: 100).active=true
62         
63         segDimension?.widthAnchor.constraintEqualToConstant(200).active=true
64         segDimension?.heightAnchor.constraintEqualToConstant(30).active=true
65         segDimension?.leadingAnchor.constraintEqualToAnchor(labelDm.trailingAnchor).active=true
66         segDimension?.topAnchor.constraintEqualToAnchor(labelDm.topAnchor).active=true
67         
68         
69     }
70     
71     //
72     func numChanged(textField:UITextField)->Bool{
73         textField.resignFirstResponder()
74         //改变游戏页面
75         if (textField.text != "(main?.maxnumber)"){
76             let num = Int(textField.text!)
77             main?.maxnumber = num!
78             
79         }
80         //存储到本地数据库
81         UserModel.sharedInstance().saveMaxnum((main?.maxnumber)!)
82         return true
83     }
84     
85     func dimensionChanged(sender:SettingViewController){
86         let segVals = [3,4,5]
87         //改变游戏页面
88         main?.dimension = segVals[segDimension!.selectedSegmentIndex]
89         main?.resetGameMap()
90         //存储到本地数据库
91         UserModel.sharedInstance().saveDimesion((main?.dimension)!)
92     }
93 
94 }

设置页面不仅要对游戏页面的刷新，同时也对本地数据库的游戏参数进行变更。

1、游戏界面刷新

 1     //游戏面板重绘
 2     func resetGameMap(){
 3         UserModel.sharedInstance().saveBestScore(self.scoreView.score)
 4         for view in self.view.subviews{
 5             view.removeFromSuperview()
 6         }
 7         backgrounds.removeAll()
 8         tiles.removeAll()
 9         gameModel.clearAll()
10         gameModel.dimension=self.dimension
11         setupScoreLables()
12         setupGameMap()
13         setupButton()
14         genNumber()
15         
16     }

刷新界面时，先保存当前分数，然后再对界面进行重绘。

2、游戏参数保存

原书使用SQLite作为本地数据库，笔者个人觉得SQLite的使用挺麻烦的（偶是个没有用过SQLite的菜鸟O(∩_∩)O~），无意间找到了一个相对使用更为方便的数据库Realm。

官网地址：https://realm.io，在首页上就可以下载Objective-C、Swift或Android等三个版本的Realm。首页下方有Realm的介绍，标题就是这么一句：

Realm is a replacement for SQLite & Core Data

Realm的中文资料不是很多，但因为其使用方便，现有资料也已经足够。这里有一篇关于Realm的教程：Realm数据库基础教程，具体配置可以参考，不过由于版本差异可能会有些不一样的地方。

笔者下载的版本是realm-swift-0.95.2，下载后自动解压。

（1）在iOS/swift-2.0中找到Realm.framework和RealmSwift.framework，把它们拖到项目中，一定要确保勾选了 Copy Items if needed 选项。

（2）将链接库配置如下：

下面是基于Realm的数据模型。UserMode使用单例模式保证数据库的唯一性，并提供方法来对Realm数据库中的user的属性值进行改写。

  1 import Foundation
  2 import UIKit
  3 import RealmSwift
  4 import Realm
  5 
  6 // 继承Object的用户数据模型
  7 // 属性包括用户id、游戏维度、通过数值、背景颜色参数、不同维度对应的最高分数
  8 class UserObject:Object{
  9     // 所有属性必须明确数据类型并且初始化
 10     dynamic var userid:String = ""
 11     dynamic var dimension:Int = 0
 12     dynamic var maxnum:Int = 0
 13     
 14     dynamic var red:CGFloat = 0.0
 15     dynamic var green:CGFloat = 0.0
 16     dynamic var blue:CGFloat = 0.0
 17     dynamic var alpha:CGFloat = 0.0
 18     
 19     dynamic var bestScoreForD3:Int = 0
 20     dynamic var bestScoreForD4:Int = 0
 21     dynamic var bestScoreForD5:Int = 0
 22 
 23     // 自定义的初始化方法
 24     init(userid:String,dimension:Int,maxnum:Int,backgroundColor:UIColor){
 25         
 26         let cicolor = CIColor(color:backgroundColor)
 27         red = cicolor.red
 28         green = cicolor.green
 29         blue = cicolor.blue
 30         alpha = cicolor.alpha
 31         
 32         self.dimension = dimension
 33         self.maxnum = maxnum
 34         self.userid = userid
 35         
 36         super.init()
 37     }
 38 
 39     required init() {
 40         super.init()
 41     }
 42     
 43     override init(realm: RLMRealm, schema: RLMObjectSchema) {
 44         super.init(realm: realm, schema: schema)
 45     }
 46     
 47     // 将userid作为primaryKey，这个功能不是必要的，因为userid都是同一个。
 48     // 只是看了Realm的文档后，试着添加进来而已
 49     override static func primaryKey() -> String?{
 50         return "userid"
 51     }
 52 }
 53 
 54                  
 55 class UserModel
 56 {
 57     // 产生userid
 58     class func get_uuid()->String{
 59         let userid = NSUserDefaults.standardUserDefaults().stringForKey("swift2048user")
 60         if userid == nil {
 61             let uuid_ref=CFUUIDCreate(nil)
 62             let uuid_string_ref=CFUUIDCreateString(nil, uuid_ref)
 63             let uuid:String = uuid_string_ref as String
 64             NSUserDefaults.standardUserDefaults().setObject(uuid, forKey: "swift2048user")
 65             return uuid
 66         }
 67         return userid!
 68     }
 69     
 70     var realm:Realm!
 71     let userid:String
 72     var user:UserObject?
 73     required init(){
 74         //------ Realm 配置 --------------
 75         // 这里涉及到Realm的Migrations。
 76         // 因为我对UserObject的架构进行更改过，必须配置，才能使数据库中的旧的UserObject更新。
 77         var config = Realm.Configuration()
 78         
 79         // schemaVersion,这可以看做UserObject的版本
 80         // 原始值为0，这是第二次更改，所以要赋值为2
 81         config.schemaVersion = 2
 82         config.migrationBlock = {
 83             migration,oldSchemaVersion in
 84             if oldSchemaVersion < 2{
 85                 
 86             }
 87         }
 88         Realm.Configuration.defaultConfiguration = config
 89         //------ Realm 配置 Over --------------
 90         
 91         
 92         realm = try! Realm()
 93         userid = UserModel.get_uuid()
 94         let objects = realm.objects(UserObject).filter("userid == '(userid)'") //检索对象
 95         //如果用户不存在
 96         if objects.count == 0 {
 97             realm.beginWrite()
 98             //根据默认的数据创建游戏
 99             user = UserObject(userid: userid, dimension: 3, maxnum: 0, backgroundColor: UIColor.darkGrayColor())
100             realm.add(user!)
101             realm.commitWrite()
102         }else{
103             user = objects.first
104         }
105     }
106     
107 //    单例模式
108     struct Static {
109         static var instance:UserModel? = nil
110         static var token: dispatch_once_t = 0
111     }
112     class func sharedInstance()->UserModel {
113         dispatch_once(&Static.token){
114             print("UserModel - Dispatch once")
115             Static.instance = self.init()
116         }
117         return Static.instance!
118     }
119     
120 //    返回属性值，调试可用
121     func getUserdata()->[String:String]{
122         let dic:[String:String] = ["maxnum":"(self.user?.maxnum)",
123             "dimension":"(self.user?.dimension)",
124             "red":"(self.user?.red)",
125             "green":"(self.user?.green)",
126             "blue":"(self.user?.blue)",
127             "alpha":"(self.user?.alpha)"]
128         return dic
129         
130     }
131     
132 //    更改属性值
133     func saveDimesion(dimension:Int){
134         realm.write({
135             self.user?.dimension = dimension
136         })
137         
138     }
139     
140     func saveMaxnum(maxnum:Int){
141         realm.write({
142             self.user?.maxnum = maxnum
143         })
144     }
145     
146     func saveColor(backgroundColor:UIColor){
147         realm.write({
148             let cicolor = CIColor(color: backgroundColor)
149             self.user?.red = cicolor.red
150             self.user?.green = cicolor.green
151             self.user?.blue = cicolor.alpha
152         })
153     }
154     
155     func saveBestScore(score:Int){
156         realm.write({
157             if (self.user?.dimension==3) && (score>self.user?.bestScoreForD3){
158                 self.user?.bestScoreForD3 = score
159                 return
160             }
161             
162             if (self.user?.dimension==4) && (score>self.user?.bestScoreForD4){
163                 self.user?.bestScoreForD4 = score
164                 return
165             }
166             
167             if (self.user?.dimension==5) && (score>self.user?.bestScoreForD5){
168                 self.user?.bestScoreForD5 = score
169                 return
170             }
171         })
172     }
173 }

至此，整个项目的完成过程介绍完毕。

关于游戏成品：功能不算丰富，细节不算完美，个别地方只是在原书的基础上做了更改，如有兴趣，可以自行完善。

最后，附上MainViewController的完整代码。

  1 import UIKit
  2 import RealmSwift
  3 
  4 class MainViewController: UIViewController {
  5 
  6   
  7     var dimension:Int = 4  //矩阵的维度，即游戏面板的大小
  8     var maxnumber:Int = 2048  //游戏通关阈值，该功能没有实现
  9     var gameModel:GameModel  //游戏数据模型
 10     
 11     var CGFloat = 50  //方块的宽度，用于布局
 12     var padding:CGFloat = 6 //方块之间的间隔宽度，用于布局
 13     
 14     var backgrounds:Array<UIView>! //所有方块的背景
 15     
 16     var tiles = [NSIndexPath:TileView]() //存储当前的有数字的方块
 17     var tileVals:Matrix //合并数字时所用的游戏数据复本
 18     
 19     
 20     init(){
 21         self.dimension = (UserModel.sharedInstance().user?.dimension)!  //从数据库中取出维度
 22         self.backgrounds = Array<UIView> ()
 23         self.gameModel = GameModel(dimension: self.dimension)
 24         self.tileVals = Matrix(rows: self.dimension, columns: self.dimension)
 25         
 26         print("dimension:(self.dimension)")
 27         super.init(nibName: nil, bundle: nil)
 28     }
 29 
 30     required init?(coder aDecoder: NSCoder) {
 31         self.gameModel = GameModel(dimension: dimension)
 32         self.tileVals = Matrix(rows: dimension, columns: dimension)
 33         super.init(coder: aDecoder)
 34     }
 35     
 36     
 37     override func viewDidLoad() {
 38         super.viewDidLoad()
 39         
 40         // Do any additional setup after loading the view.
 41         self.view.backgroundColor = UIColor.whiteColor()
 42         setupScoreLables()
 43         setupGameMap()
 44         setupButton()
 45         setupSwipeGestures()
 46         
 47         genNumber()
 48         
 49     }
 50     
 51     override func didReceiveMemoryWarning() {
 52         super.didReceiveMemoryWarning()
 53         // Dispose of any resources that can be recreated.
 54     }
 55     
 56 //---------------------------初始化游戏页面-------------------------
 57     func setupGameMap(){
 58         let margins = self.view.layoutMarginsGuide
 59         
 60         for row in 0..<self.dimension {
 61             for col in 0..<self.dimension {
 62                 //放置灰色的方块在对应的矩阵位置上
 63                 let background = UIView(frame: CGRectMake(0, 0, self.width, self.width))
 64                 background.backgroundColor = UIColor.darkGrayColor()
 65                 background.translatesAutoresizingMaskIntoConstraints = false
 66                 background.widthAnchor.constraintEqualToConstant(self.width).active = true
 67                 background.heightAnchor.constraintEqualToConstant(self.width).active = true
 68                 self.view.addSubview(background)
 69                 self.backgrounds.append(background)
 70                 
 71                 //布局约束
 72                 background.translatesAutoresizingMaskIntoConstraints=false
 73                 background.widthAnchor.constraintEqualToConstant(self.width).active=true
 74                 background.heightAnchor.constraintEqualToConstant(self.width).active=true
 75                 
 76                 //用代码进行布局约束
 77                 var centerXConstant:CGFloat
 78                 var centerYConstant:CGFloat
 79                 if self.dimension%2 == 1 {
 80                     centerXConstant = (self.padding+self.width) * CGFloat(col-self.dimension/2)
 81                     centerYConstant = (self.padding+self.width) * CGFloat(row-self.dimension/2)
 82                 }else{
 83                     centerXConstant = (self.padding+self.width) * CGFloat(Double(col-self.dimension/2)+0.5)
 84                     centerYConstant = (self.padding+self.width) * CGFloat(Double(row-self.dimension/2)+0.5)
 85                 }
 86                 
 87                 background.centerXAnchor.constraintEqualToAnchor(margins.centerXAnchor, constant: centerXConstant).active=true
 88                 background.centerYAnchor.constraintEqualToAnchor(margins.centerYAnchor, constant: centerYConstant).active=true
 89 
 90             }
 91         }
 92     }
 93     
 94     let scoreView = ScoreView(stype:ScoreType.Common)
 95     let bestScoreView = ScoreView(stype: ScoreType.Best)
 96     func setupScoreLables(){
 97         
 98         scoreView.changeScore(value: 0)
 99         self.view.addSubview(scoreView)
100         
101         let val=(self.dimension==3) ? (UserModel.sharedInstance().user?.bestScoreForD3)! : ((self.dimension==4) ? (UserModel.sharedInstance().user?.bestScoreForD4)! : (UserModel.sharedInstance().user?.bestScoreForD5)!)
102         bestScoreView.changeScore(value: val)
103         self.view.addSubview(bestScoreView)
104         
105         //布局约束
106         let margins = self.view.layoutMarginsGuide
107         scoreView.trailingAnchor.constraintEqualToAnchor(margins.centerXAnchor, constant: -30).active=true
108         scoreView.topAnchor.constraintEqualToAnchor(margins.topAnchor, constant: 100).active=true
109         //
110         bestScoreView.leadingAnchor.constraintEqualToAnchor(margins.centerXAnchor, constant: 30).active=true
111         bestScoreView.topAnchor.constraintEqualToAnchor(scoreView.topAnchor).active=true
112         
113     }
114     
115     func setupButton(){
116         let clrBtn=ViewFactory.createButton("重置", action: Selector("clearNumber"), sender: self)
117         self.view.addSubview(clrBtn)
118         
119         let genBtn=ViewFactory.createButton("生成", action: Selector("genNumber"), sender: self)
120         self.view.addSubview(genBtn)
121         
122         
123         //布局约束
124         let margins = self.view.layoutMarginsGuide
125         //
126         clrBtn.trailingAnchor.constraintEqualToAnchor(margins.centerXAnchor, constant: -30).active = true
127         clrBtn.bottomAnchor.constraintEqualToAnchor(margins.bottomAnchor, constant:-100).active=true
128         //
129         genBtn.leadingAnchor.constraintEqualToAnchor(margins.centerXAnchor, constant: 30).active = true
130         genBtn.bottomAnchor.constraintEqualToAnchor(margins.bottomAnchor, constant:-100).active=true
131         //
132     }
133     
134 //---------------------------游戏逻辑实现-------------------------
135     
136     //游戏面板重绘
137     func resetGameMap(){
138         UserModel.sharedInstance().saveBestScore(self.scoreView.score)
139         for view in self.view.subviews{
140             view.removeFromSuperview()
141         }
142         backgrounds.removeAll()
143         tiles.removeAll()
144         gameModel.clearAll()
145         gameModel.dimension=self.dimension
146         setupScoreLables()
147         setupGameMap()
148         setupButton()
149         genNumber()
150         
151     }
152     
153     // 清除所有数字，重置按钮的响应方法
154     func clearNumber(){
155         gameModel.clearAll()
156         for (_,tile) in tiles{
157             tile.removeFromSuperview()
158         }
159         tiles.removeAll()
160         
161     }
162     
163     //生成新的数字，生成按钮的响应方法
164     func genNumber(){
165 ////        随机产生数字2和4，几率为1：4
166 //        let randv=Int(arc4random_uniform(5))
167 //        var seed:Int = 2
168 //        if randv==1 {
169 //            seed = 4
170 //        }
171 
172         let col=Int(arc4random_uniform(UInt32(dimension)))
173         let row=Int(arc4random_uniform(UInt32(dimension)))
174         
175         if gameModel.isFull(){
176             print("位置已经满了")
177             return
178         }
179         
180         if gameModel.tiles[row, col]>0 {
181             genNumber()
182             return
183         }
184         
185         let seed=2 //原书的程序，按照一定的几率比来生成2或4。此处改成一直生成2.
186         gameModel.setPosition(row, col: col, value: seed)
187         insertTile((row,col), value: seed)
188         
189         // 生成数字后，判断一下游戏是否结束
190         checkGameOver()
191     }
192     
193     //插入一个数字方块
194     func insertTile(pos:(Int,Int),value:Int){
195         let (row,col)=pos
196         
197         let x=50 + CGFloat(col) * (self.width+self.padding)
198         let y=150 + CGFloat(row) * (self.width+self.padding)
199         
200         let tile=TileView(pos:CGPointMake(x,y),self.width,value:value)
201       
202         self.view.addSubview(tile)
203         self.view.bringSubviewToFront(tile)
204         
205         let index = NSIndexPath(forRow: row, inSection: col)
206         
207         tiles[index] = tile
208         
209         //布局约束
210         var centerXConstant:CGFloat
211         var centerYConstant:CGFloat
212         if self.dimension%2 == 1 {
213             centerXConstant = (self.padding+self.width) * CGFloat(col-self.dimension/2)
214             centerYConstant = (self.padding+self.width) * CGFloat(row-self.dimension/2)
215         }else{
216             centerXConstant = (self.padding+self.width) * CGFloat(Double(col-self.dimension/2)+0.5)
217             centerYConstant = (self.padding+self.width) * CGFloat(Double(row-self.dimension/2)+0.5)
218         }
219         let margins=self.view.layoutMarginsGuide
220         tile.centerXAnchor.constraintEqualToAnchor(margins.centerXAnchor, constant: centerXConstant).active=true
221         tile.centerYAnchor.constraintEqualToAnchor(margins.centerYAnchor, constant: centerYConstant).active=true
222         //原书中的动画效果
223 //        tile.layer.setAffineTransform(CGAffineTransformMakeScale(0.1, 0.1))
224         
225 //        UIView.animateWithDuration(0.5, delay: 0.1, options: UIViewAnimationOptions.TransitionNone, animations: { () -> Void in
226 //            tile.layer.setAffineTransform(CGAffineTransformMakeRotation(90))
227 //            }, completion: { (Bool) -> Void in
228 //                UIView.animateWithDuration(0.5, animations: { () -> Void in
229 //                    tile.layer.setAffineTransform(CGAffineTransformIdentity)
230 //                })
231 //        })
232         
233 //        tile.alpha=0
234 //        UIView.animateWithDuration(0.5, delay: 0.01, options: UIViewAnimationOptions.CurveEaseInOut, animations: { () -> Void in
235 //            }) { (Bool) -> Void in
236 //                UIView.animateWithDuration(1, animations: { () -> Void in
237 //                    tile.alpha = 1
238 //                })
239 //        }
240         
241 //        UIView.beginAnimations("animation", context: nil)
242 //        UIView.setAnimationDuration(2)
243 //        UIView.setAnimationCurve(UIViewAnimationCurve.EaseInOut)
244 //        UIView.setAnimationTransition(UIViewAnimationTransition.FlipFromLeft, forView: self.view, cache: false)
245 //        UIView.commitAnimations()
246     }
247     
248     //移除一个数字方块
249     func clearTile(row:Int,col:Int){
250         
251         let index=NSIndexPath(forRow: row, inSection: col)
252         let tile=tiles[index]!
253         tile.removeFromSuperview()
254         tiles.removeValueForKey(index)
255         
256     }
257     
258     //添加滑动的手势识别处理
259     func setupSwipeGestures(){
260         let upSwipe=UISwipeGestureRecognizer(target: self, action: Selector("swipeUp"))
261         upSwipe.numberOfTouchesRequired=1
262         upSwipe.direction=UISwipeGestureRecognizerDirection.Up
263         self.view.addGestureRecognizer(upSwipe)
264         
265         let downSwipe=UISwipeGestureRecognizer(target: self, action: Selector("swipeDown"))
266         downSwipe.numberOfTouchesRequired=1
267         downSwipe.direction=UISwipeGestureRecognizerDirection.Down
268         self.view.addGestureRecognizer(downSwipe)
269         
270         let leftSwipe=UISwipeGestureRecognizer(target: self, action: Selector("swipeLeft"))
271         leftSwipe.numberOfTouchesRequired=1
272         leftSwipe.direction=UISwipeGestureRecognizerDirection.Left
273         self.view.addGestureRecognizer(leftSwipe)
274         
275         let rightSwipe=UISwipeGestureRecognizer(target: self, action: Selector("swipeRight"))
276         rightSwipe.numberOfTouchesRequired=1
277         rightSwipe.direction=UISwipeGestureRecognizerDirection.Right
278         self.view.addGestureRecognizer(rightSwipe)
279         
280     }
281     
282     //向上滑动
283     func swipeUp(){
284         tileVals = gameModel.tiles
285         
286         func merge(row row:Int,col:Int){
287             if row == self.dimension-1{
288                 return
289             }
290             
291             for i in (row+1)..<self.dimension {
292                 let valNew = tileVals[i,col]
293                 if valNew>0 {
294                     let val = tileVals[row, col]
295                     
296                     if val == 0 {
297                         tileVals[row, col] = valNew
298                         tileVals[i, col] = 0
299                         merge(row: row, col: col)
300                     }else if val == valNew{
301                         tileVals[row, col] = valNew<<1
302                         tileVals[i, col] = 0
303                         if row==0 {
304                             merge(row: row, col: col)
305                         }else{
306                             merge(row: row-1, col: col)
307                         }
308 //                        若产生合并，则加分
309                         changeScore(valNew)
310                     }else{
311                         merge(row: row+1, col: col)
312                     }
313                     
314                     break
315                 }
316             }
317         }
318         
319         for col in 0..<self.dimension{
320             merge(row: 0, col: col)
321         }
322         
323 //        如果合并后的结果与原来相同，则不做任何操作
324         if tileVals.isEqualTo(gameModel.tiles){
325             return
326         }
327 //        显示合并后的结果，并产生新的数字
328         refresh()
329         genNumber()
330     }
331     
332     //向下滑动
333     
334     func swipeDown(){
335         tileVals = gameModel.tiles
336         
337         func merge(row row:Int,col:Int){
338             if row == 0{
339                 return
340             }
341             
342             for var i=row-1;i>=0;i-- {
343                 let valNew=tileVals[i,col]
344                 if valNew>0 {
345                     let val=tileVals[row,col]
346                     
347                     if val == 0 {
348                         tileVals[row, col] = valNew
349                         tileVals[i, col] = 0
350                         merge(row: row, col: col)
351                     }else if val == valNew{
352                         tileVals[row, col] = valNew<<1
353                         tileVals[i, col] = 0
354 
355                         if row==self.dimension-1 {
356                             merge(row: row, col: col)
357                         }else{
358                             merge(row: row+1, col: col)
359                         }
360 //                        若产生合并，则加分
361                         changeScore(valNew)
362                     }else{
363                         merge(row: row-1, col: col)
364                     }
365                     
366                     break
367                 }
368             }
369         }
370         
371         for col in 0..<self.dimension{
372             merge(row: self.dimension-1, col: col)
373         }
374 //        如果合并后的结果与原来相同，则不做任何操作
375         if tileVals.isEqualTo(gameModel.tiles){
376             return
377         }
378         
379         refresh()
380         genNumber()
381     }
382     
383     //向左滑动
384     func swipeLeft(){
385         tileVals = gameModel.tiles
386         func merge(row row:Int,col:Int){
387             if col == self.dimension-1{
388                 return
389             }
390             
391             for i in (col+1)..<self.dimension {
392                 let valNew=tileVals[row,i]
393                 if valNew>0 {
394                     let val=tileVals[row,col]
395                     
396                     if val == 0 {
397                         tileVals[row, col] = valNew
398                         tileVals[row, i] = 0
399                         merge(row: row, col: col)
400                     }else if val == valNew{
401                         tileVals[row, col] = valNew<<1
402                         tileVals[row, i] = 0
403                         if col==0 {
404                             merge(row: row, col: col)
405                         }else{
406                             merge(row: row, col: col-1)
407                         }
408 //                        若产生合并，则加分
409                         changeScore(valNew)
410                     }else{
411                         merge(row: row, col: col+1)
412                     }
413                     
414                     break
415                 }
416             }
417         }
418         
419         for row in 0..<self.dimension{
420             merge(row: row, col: 0)
421         }
422         
423 //        如果合并后的结果与原来相同，则不做任何操作
424         if tileVals.isEqualTo(gameModel.tiles){
425             return
426         }
427         refresh()
428         genNumber()
429     }
430     
431     //向右滑动
432     func swipeRight(){
433         tileVals = gameModel.tiles
434         func merge(row row:Int,col:Int){
435             if col == 0{
436                 return
437             }
438             
439             for var i=col-1;i>=0;i-- {
440                 let valNew=tileVals[row, i]
441                 if valNew>0 {
442                     let val=tileVals[row, col]
443                     
444                     if val == 0 {
445                         tileVals[row, col] = valNew
446                         tileVals[row, i] = 0
447                         merge(row: row, col: col)
448                     }else if val == valNew{
449                         tileVals[row, col] = valNew<<1
450                         tileVals[row, i] = 0
451                         if col==self.dimension-1 {
452                             merge(row: row, col: col)
453                         }else{
454                             merge(row: row, col: col+1)
455                         }
456 //                        若产生合并，则加分
457                         changeScore(valNew)
458                     }else{
459                         merge(row: row, col: col-1)
460                     }
461                     
462                     break
463                 }
464             }
465         }
466         
467         for row in 0..<self.dimension{
468             merge(row: row, col: self.dimension-1)
469         }
470         
471 //        如果合并后的结果与原来相同，则不做任何操作
472         if tileVals.isEqualTo(gameModel.tiles){
473             return
474         }
475         refresh()
476         genNumber()
477         
478     }
479     
480     //刷新页面
481     func refresh(){
482         for i in 0..<self.dimension{
483             for j in 0..<self.dimension{
484                 let val = gameModel.tiles[i,j]
485                 let valNew = tileVals[i,j]
486                 if valNew != val{
487                     gameModel.setPosition(i, col: j, value: valNew)
488                     if valNew>0{
489                         if val>0{
490                             clearTile(i, col: j)
491                         }
492                         insertTile((i,j) , value: valNew)
493                         
494                     }else{
495                         clearTile(i, col: j)
496                     }
497                 }
498                 
499             }
500         }
501     }
502     
503     //加分
504     func changeScore(baseNum:Int){
505         self.scoreView.score += baseNum * 2
506         
507     }
508     
509     //检查游戏是否结束
510     func checkGameOver(){
511         if self.gameModel.isFull(){
512             for row in 0..<self.dimension{
513                 for col in 0..<self.dimension{
514                     let val = gameModel.tiles[row,col]
515                     let left:Int? = (col-1)>=0 ? gameModel.tiles[row,col-1] : nil
516                     let right:Int? = (col+1)<self.dimension ? gameModel.tiles[row,col+1] : nil
517                     let up:Int? = (row-1)>=0 ? gameModel.tiles[row-1,col] : nil
518                     let down:Int? = (row+1)<self.dimension ? gameModel.tiles[row+1,col] : nil
519                     if (val==left) || (val==right) || (val==up) || (val==down){
520                         return
521                     }
522                     
523                 }
524             }
525             
526             let alerController = UIAlertController(title: "游戏结束", message: "本轮游戏结束，重新开始吧！", preferredStyle: UIAlertControllerStyle.Alert)
527             alerController.addAction(UIAlertAction(title: "Ready Go!", style: UIAlertActionStyle.Default, handler: {
528                 action in
529                 self.resetGameMap()
530             }))
531             self.presentViewController(alerController, animated: true, completion: nil)
532             return
533         }
534     }
535     
536 }

View Code