Swift实战之2048小游戏

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

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

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

一、开始页面

 

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

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

二、游戏页面

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

import UIKit

class MainTabViewController: UITabBarController,KKColorListViewControllerDelegate {
    var viewMain = MainViewController()
    var viewColor = KKColorListViewController(schemeType:KKColorsSchemeType.Crayola)
    override func viewDidLoad() {
        super.viewDidLoad()

        // Do any additional setup after loading the view.
        
        viewMain.title = "2048"
        let user=UserModel.sharedInstance().user
        if let red = user?.red{
            let uicolor=UIColor(red: red, green: (user?.green)!, blue: (user?.blue)!, alpha: (user?.alpha)!)
            viewMain.view.backgroundColor=uicolor
        }
        
        let viewSetting = SettingViewController()
        viewSetting.title = "设置"
        
        viewColor.title="颜色"
        viewColor.headerTitle="选择背景色"
        viewColor.delegate=self
        
        let main = UINavigationController(rootViewController: viewMain)
        let setting = UINavigationController(rootViewController: viewSetting)
        let color = UINavigationController(rootViewController: viewColor)
        
        self.viewControllers = [main, setting,color]
        self.selectedIndex = 0
    }

    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
        // Dispose of any resources that can be recreated.
    }
    
    func colorListController(controller: KKColorListViewController!, didSelectColor color: KKColor!) {
        viewMain.view.backgroundColor = color.uiColor()
        
        UserModel.sharedInstance().saveColor(color.uiColor())
        self.selectedIndex=0
    }
    
    func colorListPickerDidComplete(controller: KKColorListViewController!) {
        self.selectedIndex=0
    }

}

（一）主题页面

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

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

#ifndef Bridging_Header_h
#define Bridging_Header_h
#import "KKColorListPicker.h"

#endif /* Bridging_Header_h */

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

（1）KKColorsSchemeType.h中需添加

#import <Foundation/Foundation.h>

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

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

（二）游戏页面

 

1、ScoreView

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

  

import UIKit

enum ScoreType{
    case Common
    case Best
}

protocol ScoreViewProtocol{
    func changeScore(value s:Int)
}

class ScoreView: UIView, ScoreViewProtocol {

    var label:UILabel!
    let defaultFrame = CGRectMake(0, 0, 100, 30)
    var stype:String!
    
    var score:Int = 0 {
        didSet{
            label.text = "(stype):(score)"
        }
    }
    
    init(stype: ScoreType){
        super.init(frame: defaultFrame)
        self.stype = (stype == ScoreType.Common ? "分数":"最高分")
        
        backgroundColor = UIColor.orangeColor()
        label = UILabel(frame: defaultFrame)
        label.textAlignment = NSTextAlignment.Center
        label.font = UIFont(name: "微软雅黑", size: 16)
        label.textColor = UIColor.whiteColor()
        
        self.addSubview(label)
        
        //布局约束
        //必须将该属性值设置为false，否则自己设置的约束和AutoresizingMask生成的约束有冲突，运行时会产生异常
        self.translatesAutoresizingMaskIntoConstraints = false
        //宽度约束
        self.widthAnchor.constraintEqualToConstant(100).active=true
        //高度约束
        self.heightAnchor.constraintEqualToConstant(30).active=true
    }

    required init?(coder aDecoder: NSCoder) {
        super.init(coder: aDecoder)
    }
    
    func changeScore(value s: Int) {
        self.score = s
    }

}

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

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

2、按钮

 

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

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

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

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

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

var backgrounds:Array<UIView>! //所有方块的背景
   func setupGameMap(){
        let margins = self.view.layoutMarginsGuide
        
        for row in 0..<self.dimension {
            for col in 0..<self.dimension {
                //放置灰色的方块在对应的矩阵位置上
                let background = UIView(frame: CGRectMake(0, 0, self.width, self.width))
                background.backgroundColor = UIColor.darkGrayColor()
                background.translatesAutoresizingMaskIntoConstraints = false
                background.widthAnchor.constraintEqualToConstant(self.width).active = true
                background.heightAnchor.constraintEqualToConstant(self.width).active = true
                self.view.addSubview(background)
                self.backgrounds.append(background)
                
                //布局约束
                background.translatesAutoresizingMaskIntoConstraints=false
                background.widthAnchor.constraintEqualToConstant(self.width).active=true
                background.heightAnchor.constraintEqualToConstant(self.width).active=true
                
                //用代码进行布局约束
                var centerXConstant:CGFloat
                var centerYConstant:CGFloat
                if self.dimension%2 == 1 {
                    centerXConstant = (self.padding+self.width) * CGFloat(col-self.dimension/2)
                    centerYConstant = (self.padding+self.width) * CGFloat(row-self.dimension/2)
                }else{
                    centerXConstant = (self.padding+self.width) * CGFloat(Double(col-self.dimension/2)+0.5)
                    centerYConstant = (self.padding+self.width) * CGFloat(Double(row-self.dimension/2)+0.5)
                }
                
                background.centerXAnchor.constraintEqualToAnchor(margins.centerXAnchor, constant: centerXConstant).active=true
                background.centerYAnchor.constraintEqualToAnchor(margins.centerYAnchor, constant: centerYConstant).active=true

            }
        }
    }

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

var tiles = [NSIndexPath:TileView]() //存储当前的有数字的方块

//插入一个数字方块
    func insertTile(pos:(Int,Int),value:Int){
        let (row,col)=pos
        
        let x=50 + CGFloat(col) * (self.width+self.padding)
        let y=150 + CGFloat(row) * (self.width+self.padding)
        
        let tile=TileView(pos:CGPointMake(x,y),self.width,value:value)
      
        self.view.addSubview(tile)
        self.view.bringSubviewToFront(tile)
        
        let index = NSIndexPath(forRow: row, inSection: col)
        
        tiles[index] = tile
        
        //布局约束
        var centerXConstant:CGFloat
        var centerYConstant:CGFloat
        if self.dimension%2 == 1 {
            centerXConstant = (self.padding+self.width) * CGFloat(col-self.dimension/2)
            centerYConstant = (self.padding+self.width) * CGFloat(row-self.dimension/2)
        }else{
            centerXConstant = (self.padding+self.width) * CGFloat(Double(col-self.dimension/2)+0.5)
            centerYConstant = (self.padding+self.width) * CGFloat(Double(row-self.dimension/2)+0.5)
        }
        let margins=self.view.layoutMarginsGuide
        tile.centerXAnchor.constraintEqualToAnchor(margins.centerXAnchor, constant: centerXConstant).active=true
        tile.centerYAnchor.constraintEqualToAnchor(margins.centerYAnchor, constant: centerYConstant).active=true
    }

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

    //移除一个数字方块
    func clearTile(row:Int,col:Int){
        
        let index=NSIndexPath(forRow: row, inSection: col)
        let tile=tiles[index]!
        tile.removeFromSuperview()
        tiles.removeValueForKey(index)
        
    }

TileView的实现代码如下：

import Foundation
import UIKit


class TileView : UIView {
    let colorMap=[
        2:UIColor.redColor(),
        4:UIColor.orangeColor(),
        8:UIColor.lightTextColor(),
        16:UIColor.greenColor(),
        32:UIColor.brownColor(),
        64:UIColor.blackColor(),
        128:UIColor.purpleColor(),
        256:UIColor.lightGrayColor(),
        512:UIColor.cyanColor(),
        1024:UIColor.magentaColor(),
        2048:UIColor.blackColor()
    ]
    
    var value:Int{
        didSet{
            backgroundColor=colorMap[value]
            numberLabel.text="(value)"
        }
    }
    
    var numberLabel:UILabel!
    
    init(pos:CGPoint,CGFloat,value:Int){
        self.value=value
        
        numberLabel=UILabel(frame: CGRectMake(0, 0, width, width))
        numberLabel.textColor=UIColor.whiteColor()
        numberLabel.textAlignment=NSTextAlignment.Center
        numberLabel.minimumScaleFactor=0.5
        numberLabel.font=UIFont(name: "微软雅黑", size: 20)
        numberLabel.text="(value)"
        
        super.init(frame: CGRectMake(pos.x, pos.y,width , width))
        addSubview(numberLabel)
        backgroundColor=colorMap[value]
        
        //代码约束
        self.translatesAutoresizingMaskIntoConstraints = false
        self.widthAnchor.constraintEqualToConstant(width).active=true
        self.heightAnchor.constraintEqualToConstant(width).active=true
        
    }

    required init?(coder aDecoder: NSCoder) {
        self.value = 2
        super.init(coder: aDecoder)
    }
    
    
}

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进行初始化，同时，提供一些方法。

class GameModel{
    var dimension:Int = 0{
        didSet{
            self.tiles = Matrix(rows: self.dimension, columns: self.dimension)
        }
    }
    var tiles:Matrix    
    init(dimension:Int){
        self.dimension=dimension
        self.tiles = Matrix(rows: self.dimension, columns: self.dimension)
    }
    
    func emptyPosition()->[Int]{
        var emptytiles=Array<Int>()
        for row in 0..<self.dimension{
            for col in 0..<self.dimension{
                let val=tiles[row,col]
                if val==0 {
                    emptytiles.append(tiles[row,col])
                }
            }
            
        }
        return emptytiles
    }
    
    func isFull()->Bool{
        if emptyPosition().count==0 {
            return true
        }
        return false
    }
//    打印矩阵，调试时使用
    func printTiles(){
        for i in 0..<self.dimension{
            print(tiles.grid[(i*self.dimension)...((i+1)*self.dimension-1)])
        }
    }
    
// 设置某个位置的值
    func setPosition(row:Int,col:Int,value:Int)->Bool{
        assert(row>=0 && row<dimension)
        assert(col>=0 && col<dimension)
        
        print("值更新之前：")
        printTiles()
        
        tiles[row,col]=value
        
        print("值更新之后：tiles[(row),(col)]=(tiles[row,col])")
        printTiles()
        return true
    }
// 清除数据
    func clearAll(){
        tiles=Matrix(rows: self.dimension, columns: self.dimension)
    }
    
}

（2）游戏数据变更

 产生一个数字：

    //生成新的数字，生成按钮的响应方法
    func genNumber(){
////        随机产生数字2和4，几率为1：4
//        let randv=Int(arc4random_uniform(5))
//        var seed:Int = 2
//        if randv==1 {
//            seed = 4
//        }

        let col=Int(arc4random_uniform(UInt32(dimension)))
        let row=Int(arc4random_uniform(UInt32(dimension)))
        
        if gameModel.isFull(){
            print("位置已经满了")
            return
        }
        
        if gameModel.tiles[row, col]>0 {
            genNumber()
            return
        }
        
        let seed=2 //原书的程序，按照一定的几率比来生成2或4。此处改成一直生成2.
        gameModel.setPosition(row, col: col, value: seed)
        insertTile((row,col), value: seed)
        
        // 生成数字后，判断一下游戏是否结束
        checkGameOver()
    }

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

    //检查游戏是否结束
    func checkGameOver(){
        if self.gameModel.isFull(){
            for row in 0..<self.dimension{
                for col in 0..<self.dimension{
                    let val = gameModel.tiles[row,col]
                    let left:Int? = (col-1)>=0 ? gameModel.tiles[row,col-1] : nil
                    let right:Int? = (col+1)<self.dimension ? gameModel.tiles[row,col+1] : nil
                    let up:Int? = (row-1)>=0 ? gameModel.tiles[row-1,col] : nil
                    let down:Int? = (row+1)<self.dimension ? gameModel.tiles[row+1,col] : nil
                    if (val==left) || (val==right) || (val==up) || (val==down){
                        return
                    }
                    
                }
            }
            
            let alerController = UIAlertController(title: "游戏结束", message: "本轮游戏结束，重新开始吧！", preferredStyle: UIAlertControllerStyle.Alert)
            alerController.addAction(UIAlertAction(title: "Ready Go!", style: UIAlertActionStyle.Default, handler: {
                action in
                self.resetGameMap()
            }))
            self.presentViewController(alerController, animated: true, completion: nil)
            return
        }
    }

5、游戏效果实现

 

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

    //添加滑动的手势识别处理
    func setupSwipeGestures(){
        let upSwipe=UISwipeGestureRecognizer(target: self, action: Selector("swipeUp"))
        upSwipe.numberOfTouchesRequired=1
        upSwipe.direction=UISwipeGestureRecognizerDirection.Up
        self.view.addGestureRecognizer(upSwipe)
        
        let downSwipe=UISwipeGestureRecognizer(target: self, action: Selector("swipeDown"))
        downSwipe.numberOfTouchesRequired=1
        downSwipe.direction=UISwipeGestureRecognizerDirection.Down
        self.view.addGestureRecognizer(downSwipe)
        
        let leftSwipe=UISwipeGestureRecognizer(target: self, action: Selector("swipeLeft"))
        leftSwipe.numberOfTouchesRequired=1
        leftSwipe.direction=UISwipeGestureRecognizerDirection.Left
        self.view.addGestureRecognizer(leftSwipe)
        
        let rightSwipe=UISwipeGestureRecognizer(target: self, action: Selector("swipeRight"))
        rightSwipe.numberOfTouchesRequired=1
        rightSwipe.direction=UISwipeGestureRecognizerDirection.Right
        self.view.addGestureRecognizer(rightSwipe)
        
    }

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

var tileVals:Matrix //合并数字时所用的游戏数据复本

    //向上滑动
    func swipeUp(){
        tileVals = gameModel.tiles
        
        func merge(row row:Int,col:Int){
            if row == self.dimension-1{
                return
            }
            
            for i in (row+1)..<self.dimension {
                let valNew = tileVals[i,col]
                if valNew>0 {
                    let val = tileVals[row, col]
                    
                    if val == 0 {
                        tileVals[row, col] = valNew
                        tileVals[i, col] = 0
                        merge(row: row, col: col)
                    }else if val == valNew{
                        tileVals[row, col] = valNew<<1
                        tileVals[i, col] = 0
                        if row==0 {
                            merge(row: row, col: col)
                        }else{
                            merge(row: row-1, col: col)
                        }
//                        若产生合并，则加分
                        changeScore(valNew)
                    }else{
                        merge(row: row+1, col: col)
                    }
                    
                    break
                }
            }
        }
        
        for col in 0..<self.dimension{
            merge(row: 0, col: col)
        }
        
//        如果合并后的结果与原来相同，则不做任何操作
        if tileVals.isEqualTo(gameModel.tiles){
            return
        }
//        显示合并后的结果，并产生新的数字
        refresh()
        genNumber()
    }

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

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

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

    //刷新页面
    func refresh(){
        for i in 0..<self.dimension{
            for j in 0..<self.dimension{
                let val = gameModel.tiles[i,j]
                let valNew = tileVals[i,j]
                if valNew != val{
                    gameModel.setPosition(i, col: j, value: valNew)
                    if valNew>0{
                        if val>0{
                            clearTile(i, col: j)
                        }
                        insertTile((i,j) , value: valNew)
                        
                    }else{
                        clearTile(i, col: j)
                    }
                }
                
            }
        }
    }

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

    //向下滑动
    
    func swipeDown(){
        tileVals = gameModel.tiles
        
        func merge(row row:Int,col:Int){
            if row == 0{
                return
            }
            
            for var i=row-1;i>=0;i-- {
                let valNew=tileVals[i,col]
                if valNew>0 {
                    let val=tileVals[row,col]
                    
                    if val == 0 {
                        tileVals[row, col] = valNew
                        tileVals[i, col] = 0
                        merge(row: row, col: col)
                    }else if val == valNew{
                        tileVals[row, col] = valNew<<1
                        tileVals[i, col] = 0

                        if row==self.dimension-1 {
                            merge(row: row, col: col)
                        }else{
                            merge(row: row+1, col: col)
                        }
//                        若产生合并，则加分
                        changeScore(valNew)
                    }else{
                        merge(row: row-1, col: col)
                    }
                    
                    break
                }
            }
        }
        
        for col in 0..<self.dimension{
            merge(row: self.dimension-1, col: col)
        }
//        如果合并后的结果与原来相同，则不做任何操作
        if tileVals.isEqualTo(gameModel.tiles){
            return
        }
        
        refresh()
        genNumber()
    }
    
    //向左滑动
    func swipeLeft(){
        tileVals = gameModel.tiles
        func merge(row row:Int,col:Int){
            if col == self.dimension-1{
                return
            }
            
            for i in (col+1)..<self.dimension {
                let valNew=tileVals[row,i]
                if valNew>0 {
                    let val=tileVals[row,col]
                    
                    if val == 0 {
                        tileVals[row, col] = valNew
                        tileVals[row, i] = 0
                        merge(row: row, col: col)
                    }else if val == valNew{
                        tileVals[row, col] = valNew<<1
                        tileVals[row, i] = 0
                        if col==0 {
                            merge(row: row, col: col)
                        }else{
                            merge(row: row, col: col-1)
                        }
//                        若产生合并，则加分
                        changeScore(valNew)
                    }else{
                        merge(row: row, col: col+1)
                    }
                    
                    break
                }
            }
        }
        
        for row in 0..<self.dimension{
            merge(row: row, col: 0)
        }
        
//        如果合并后的结果与原来相同，则不做任何操作
        if tileVals.isEqualTo(gameModel.tiles){
            return
        }
        refresh()
        genNumber()
    }
    
    //向右滑动
    func swipeRight(){
        tileVals = gameModel.tiles
        func merge(row row:Int,col:Int){
            if col == 0{
                return
            }
            
            for var i=col-1;i>=0;i-- {
                let valNew=tileVals[row, i]
                if valNew>0 {
                    let val=tileVals[row, col]
                    
                    if val == 0 {
                        tileVals[row, col] = valNew
                        tileVals[row, i] = 0
                        merge(row: row, col: col)
                    }else if val == valNew{
                        tileVals[row, col] = valNew<<1
                        tileVals[row, i] = 0
                        if col==self.dimension-1 {
                            merge(row: row, col: col)
                        }else{
                            merge(row: row, col: col+1)
                        }
//                        若产生合并，则加分
                        changeScore(valNew)
                    }else{
                        merge(row: row, col: col-1)
                    }
                    
                    break
                }
            }
        }
        
        for row in 0..<self.dimension{
            merge(row: row, col: self.dimension-1)
        }
        
//        如果合并后的结果与原来相同，则不做任何操作
        if tileVals.isEqualTo(gameModel.tiles){
            return
        }
        refresh()
        genNumber()
        
    }

（三）设置页面

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

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

ViewFactory的代码如下：

import UIKit

class ViewFactory {
    class func getDefaultFrame() -> CGRect {
        let defaultFrame = CGRectMake(0, 0, 100, 30)
        return defaultFrame
    }
    
    class func createControl(type:String, title:[String],action:Selector,sender:AnyObject)->UIView{
        switch(type){
            case "label": return ViewFactory.createLabel(title[0])
            case "button": return ViewFactory.createButton(title[0], action: action, sender: sender as! UIViewController)
            case "text":return ViewFactory.createTextField(title[0], action: action, sender: sender as! UITextFieldDelegate)
            case "segment":return ViewFactory.createSegment(title, action: action, sender: sender as! UIViewController)
        default: return ViewFactory.createLabel(title[0])
        }
    }
    
    class func createLabel(title:String) -> UILabel{
        let label = UILabel()
        label.textColor = UIColor.blackColor()
        label.backgroundColor = UIColor.whiteColor()
        label.text = title
        label.frame = CGRectZero
        label.font = UIFont(name: "HelveticaNeue-Bold", size: 16)
        label.translatesAutoresizingMaskIntoConstraints = false
        
        return label
    }
    
    class func createButton(title:String,action:Selector,sender:UIViewController) -> UIButton{
        let button = UIButton(frame: CGRectZero)
        button.backgroundColor=UIColor.orangeColor()
        button.setTitle(title, forState: .Normal)
        button.titleLabel!.textColor=UIColor.whiteColor()
        button.titleLabel!.font=UIFont.systemFontOfSize(14)
        
        //布局约束
        button.translatesAutoresizingMaskIntoConstraints = false
        button.widthAnchor.constraintEqualToConstant(100).active=true
        button.heightAnchor.constraintEqualToConstant(30).active=true
        
        button.addTarget(sender, action: action, forControlEvents: UIControlEvents.TouchUpInside)
        return button
    }
    
    class func createTextField(value:String,action:Selector,sender:UITextFieldDelegate) -> UITextField{
        let textField=UITextField(frame: ViewFactory.getDefaultFrame())
        textField.backgroundColor=UIColor.clearColor()
        textField.textColor=UIColor.blackColor()
        textField.text=value
        textField.borderStyle=UITextBorderStyle.RoundedRect
        textField.adjustsFontSizeToFitWidth=true
        textField.delegate=sender
        
        textField.translatesAutoresizingMaskIntoConstraints = false
        return textField
    }
    
    class func createSegment(items:[String],action:Selector,sender:UIViewController)->UISegmentedControl {
        let segment=UISegmentedControl(items: items)
        segment.frame=ViewFactory.getDefaultFrame()
        segment.momentary=false
        segment.addTarget(sender, action: action, forControlEvents: UIControlEvents.ValueChanged)
        
        segment.translatesAutoresizingMaskIntoConstraints = false
        return segment
        
    }
}

SettingViewController的实现：

import UIKit

class SettingViewController: UIViewController,UITextFieldDelegate {
    init(){
        super.init(nibName: nil, bundle: nil)
    }

    required init?(coder aDecoder: NSCoder) {
        super.init(coder: aDecoder)
    }
    
    var main:MainViewController?
    override func viewDidLoad() {
        super.viewDidLoad()
        self.view.backgroundColor=UIColor.whiteColor()
        
        let views = (self.parentViewController?.parentViewController as! MainTabViewController).viewControllers
        main = ((views?[0] as? UINavigationController)?.childViewControllers)?[0] as? MainViewController
        setupControls()
        // Do any additional setup after loading the view.
    }

    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
        // Dispose of any resources that can be recreated.
    }
    
    var segDimension:UISegmentedControl?
    func setupControls(){
        let segVals = [3,4,5]
        let textNum = ViewFactory.createTextField("", action: Selector("numChanged:"), sender: self)
        textNum.returnKeyType=UIReturnKeyType.Done
        
        self.view.addSubview(textNum)
        
        let labelNum = ViewFactory.createLabel("阈值:")
        self.view.addSubview(labelNum)
        
        segDimension = ViewFactory.createSegment(["3X3","4X4","5X5"], action: "dimensionChanged:", sender: self)
        self.view.addSubview(segDimension!)
        segDimension!.selectedSegmentIndex=segVals.indexOf((main?.dimension)!)!
        
        let labelDm=ViewFactory.createLabel("维度：")
        self.view.addSubview(labelDm)
        
        //布局约束
        let margins=self.view.layoutMarginsGuide
        labelNum.widthAnchor.constraintEqualToConstant(60).active=true
        labelNum.heightAnchor.constraintEqualToConstant(30).active=true
        labelNum.leadingAnchor.constraintEqualToAnchor(margins.leadingAnchor, constant: 20).active=true
        labelNum.topAnchor.constraintEqualToAnchor(margins.topAnchor, constant: 100).active=true
        
        textNum.widthAnchor.constraintEqualToConstant(200).active=true
        textNum.heightAnchor.constraintEqualToConstant(30).active=true
        textNum.leadingAnchor.constraintEqualToAnchor(labelNum.trailingAnchor).active=true
        textNum.topAnchor.constraintEqualToAnchor(labelNum.topAnchor).active=true
        
        labelDm.widthAnchor.constraintEqualToConstant(60).active=true
        labelDm.heightAnchor.constraintEqualToConstant(30).active=true
        labelDm.leadingAnchor.constraintEqualToAnchor(labelNum.leadingAnchor).active=true
        labelDm.topAnchor.constraintEqualToAnchor(textNum.topAnchor, constant: 100).active=true
        
        segDimension?.widthAnchor.constraintEqualToConstant(200).active=true
        segDimension?.heightAnchor.constraintEqualToConstant(30).active=true
        segDimension?.leadingAnchor.constraintEqualToAnchor(labelDm.trailingAnchor).active=true
        segDimension?.topAnchor.constraintEqualToAnchor(labelDm.topAnchor).active=true
        
        
    }
    
    //
    func numChanged(textField:UITextField)->Bool{
        textField.resignFirstResponder()
        //改变游戏页面
        if (textField.text != "(main?.maxnumber)"){
            let num = Int(textField.text!)
            main?.maxnumber = num!
            
        }
        //存储到本地数据库
        UserModel.sharedInstance().saveMaxnum((main?.maxnumber)!)
        return true
    }
    
    func dimensionChanged(sender:SettingViewController){
        let segVals = [3,4,5]
        //改变游戏页面
        main?.dimension = segVals[segDimension!.selectedSegmentIndex]
        main?.resetGameMap()
        //存储到本地数据库
        UserModel.sharedInstance().saveDimesion((main?.dimension)!)
    }

}

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

1、游戏界面刷新

    //游戏面板重绘
    func resetGameMap(){
        UserModel.sharedInstance().saveBestScore(self.scoreView.score)
        for view in self.view.subviews{
            view.removeFromSuperview()
        }
        backgrounds.removeAll()
        tiles.removeAll()
        gameModel.clearAll()
        gameModel.dimension=self.dimension
        setupScoreLables()
        setupGameMap()
        setupButton()
        genNumber()
        
    }

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

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的属性值进行改写。

import Foundation
import UIKit
import RealmSwift
import Realm

// 继承Object的用户数据模型
// 属性包括用户id、游戏维度、通过数值、背景颜色参数、不同维度对应的最高分数
class UserObject:Object{
    // 所有属性必须明确数据类型并且初始化
    dynamic var userid:String = ""
    dynamic var dimension:Int = 0
    dynamic var maxnum:Int = 0
    
    dynamic var red:CGFloat = 0.0
    dynamic var green:CGFloat = 0.0
    dynamic var blue:CGFloat = 0.0
    dynamic var alpha:CGFloat = 0.0
    
    dynamic var bestScoreForD3:Int = 0
    dynamic var bestScoreForD4:Int = 0
    dynamic var bestScoreForD5:Int = 0

    // 自定义的初始化方法
    init(userid:String,dimension:Int,maxnum:Int,backgroundColor:UIColor){
        
        let cicolor = CIColor(color:backgroundColor)
        red = cicolor.red
        green = cicolor.green
        blue = cicolor.blue
        alpha = cicolor.alpha
        
        self.dimension = dimension
        self.maxnum = maxnum
        self.userid = userid
        
        super.init()
    }

    required init() {
        super.init()
    }
    
    override init(realm: RLMRealm, schema: RLMObjectSchema) {
        super.init(realm: realm, schema: schema)
    }
    
    // 将userid作为primaryKey，这个功能不是必要的，因为userid都是同一个。
    // 只是看了Realm的文档后，试着添加进来而已
    override static func primaryKey() -> String?{
        return "userid"
    }
}

                 
class UserModel
{
    // 产生userid
    class func get_uuid()->String{
        let userid = NSUserDefaults.standardUserDefaults().stringForKey("swift2048user")
        if userid == nil {
            let uuid_ref=CFUUIDCreate(nil)
            let uuid_string_ref=CFUUIDCreateString(nil, uuid_ref)
            let uuid:String = uuid_string_ref as String
            NSUserDefaults.standardUserDefaults().setObject(uuid, forKey: "swift2048user")
            return uuid
        }
        return userid!
    }
    
    var realm:Realm!
    let userid:String
    var user:UserObject?
    required init(){
        //------ Realm 配置 --------------
        // 这里涉及到Realm的Migrations。
        // 因为我对UserObject的架构进行更改过，必须配置，才能使数据库中的旧的UserObject更新。
        var config = Realm.Configuration()
        
        // schemaVersion,这可以看做UserObject的版本
        // 原始值为0，这是第二次更改，所以要赋值为2
        config.schemaVersion = 2
        config.migrationBlock = {
            migration,oldSchemaVersion in
            if oldSchemaVersion < 2{
                
            }
        }
        Realm.Configuration.defaultConfiguration = config
        //------ Realm 配置 Over --------------
        
        
        realm = try! Realm()
        userid = UserModel.get_uuid()
        let objects = realm.objects(UserObject).filter("userid == '(userid)'") //检索对象
        //如果用户不存在
        if objects.count == 0 {
            realm.beginWrite()
            //根据默认的数据创建游戏
            user = UserObject(userid: userid, dimension: 3, maxnum: 0, backgroundColor: UIColor.darkGrayColor())
            realm.add(user!)
            realm.commitWrite()
        }else{
            user = objects.first
        }
    }
    
//    单例模式
    struct Static {
        static var instance:UserModel? = nil
        static var token: dispatch_once_t = 0
    }
    class func sharedInstance()->UserModel {
        dispatch_once(&Static.token){
            print("UserModel - Dispatch once")
            Static.instance = self.init()
        }
        return Static.instance!
    }
    
//    返回属性值，调试可用
    func getUserdata()->[String:String]{
        let dic:[String:String] = ["maxnum":"(self.user?.maxnum)",
            "dimension":"(self.user?.dimension)",
            "red":"(self.user?.red)",
            "green":"(self.user?.green)",
            "blue":"(self.user?.blue)",
            "alpha":"(self.user?.alpha)"]
        return dic
        
    }
    
//    更改属性值
    func saveDimesion(dimension:Int){
        realm.write({
            self.user?.dimension = dimension
        })
        
    }
    
    func saveMaxnum(maxnum:Int){
        realm.write({
            self.user?.maxnum = maxnum
        })
    }
    
    func saveColor(backgroundColor:UIColor){
        realm.write({
            let cicolor = CIColor(color: backgroundColor)
            self.user?.red = cicolor.red
            self.user?.green = cicolor.green
            self.user?.blue = cicolor.alpha
        })
    }
    
    func saveBestScore(score:Int){
        realm.write({
            if (self.user?.dimension==3) && (score>self.user?.bestScoreForD3){
                self.user?.bestScoreForD3 = score
                return
            }
            
            if (self.user?.dimension==4) && (score>self.user?.bestScoreForD4){
                self.user?.bestScoreForD4 = score
                return
            }
            
            if (self.user?.dimension==5) && (score>self.user?.bestScoreForD5){
                self.user?.bestScoreForD5 = score
                return
            }
        })
    }
}

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

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

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

import UIKit
import RealmSwift

class MainViewController: UIViewController {

  
    var dimension:Int = 4  //矩阵的维度，即游戏面板的大小
    var maxnumber:Int = 2048  //游戏通关阈值，该功能没有实现
    var gameModel:GameModel  //游戏数据模型
    
    var CGFloat = 50  //方块的宽度，用于布局
    var padding:CGFloat = 6 //方块之间的间隔宽度，用于布局
    
    var backgrounds:Array<UIView>! //所有方块的背景
    
    var tiles = [NSIndexPath:TileView]() //存储当前的有数字的方块
    var tileVals:Matrix //合并数字时所用的游戏数据复本
    
    
    init(){
        self.dimension = (UserModel.sharedInstance().user?.dimension)!  //从数据库中取出维度
        self.backgrounds = Array<UIView> ()
        self.gameModel = GameModel(dimension: self.dimension)
        self.tileVals = Matrix(rows: self.dimension, columns: self.dimension)
        
        print("dimension:(self.dimension)")
        super.init(nibName: nil, bundle: nil)
    }

    required init?(coder aDecoder: NSCoder) {
        self.gameModel = GameModel(dimension: dimension)
        self.tileVals = Matrix(rows: dimension, columns: dimension)
        super.init(coder: aDecoder)
    }
    
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Do any additional setup after loading the view.
        self.view.backgroundColor = UIColor.whiteColor()
        setupScoreLables()
        setupGameMap()
        setupButton()
        setupSwipeGestures()
        
        genNumber()
        
    }
    
    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
        // Dispose of any resources that can be recreated.
    }
    
//---------------------------初始化游戏页面-------------------------
    func setupGameMap(){
        let margins = self.view.layoutMarginsGuide
        
        for row in 0..<self.dimension {
            for col in 0..<self.dimension {
                //放置灰色的方块在对应的矩阵位置上
                let background = UIView(frame: CGRectMake(0, 0, self.width, self.width))
                background.backgroundColor = UIColor.darkGrayColor()
                background.translatesAutoresizingMaskIntoConstraints = false
                background.widthAnchor.constraintEqualToConstant(self.width).active = true
                background.heightAnchor.constraintEqualToConstant(self.width).active = true
                self.view.addSubview(background)
                self.backgrounds.append(background)
                
                //布局约束
                background.translatesAutoresizingMaskIntoConstraints=false
                background.widthAnchor.constraintEqualToConstant(self.width).active=true
                background.heightAnchor.constraintEqualToConstant(self.width).active=true
                
                //用代码进行布局约束
                var centerXConstant:CGFloat
                var centerYConstant:CGFloat
                if self.dimension%2 == 1 {
                    centerXConstant = (self.padding+self.width) * CGFloat(col-self.dimension/2)
                    centerYConstant = (self.padding+self.width) * CGFloat(row-self.dimension/2)
                }else{
                    centerXConstant = (self.padding+self.width) * CGFloat(Double(col-self.dimension/2)+0.5)
                    centerYConstant = (self.padding+self.width) * CGFloat(Double(row-self.dimension/2)+0.5)
                }
                
                background.centerXAnchor.constraintEqualToAnchor(margins.centerXAnchor, constant: centerXConstant).active=true
                background.centerYAnchor.constraintEqualToAnchor(margins.centerYAnchor, constant: centerYConstant).active=true

            }
        }
    }
    
    let scoreView = ScoreView(stype:ScoreType.Common)
    let bestScoreView = ScoreView(stype: ScoreType.Best)
    func setupScoreLables(){
        
        scoreView.changeScore(value: 0)
        self.view.addSubview(scoreView)
        
        let val=(self.dimension==3) ? (UserModel.sharedInstance().user?.bestScoreForD3)! : ((self.dimension==4) ? (UserModel.sharedInstance().user?.bestScoreForD4)! : (UserModel.sharedInstance().user?.bestScoreForD5)!)
        bestScoreView.changeScore(value: val)
        self.view.addSubview(bestScoreView)
        
        //布局约束
        let margins = self.view.layoutMarginsGuide
        scoreView.trailingAnchor.constraintEqualToAnchor(margins.centerXAnchor, constant: -30).active=true
        scoreView.topAnchor.constraintEqualToAnchor(margins.topAnchor, constant: 100).active=true
        //
        bestScoreView.leadingAnchor.constraintEqualToAnchor(margins.centerXAnchor, constant: 30).active=true
        bestScoreView.topAnchor.constraintEqualToAnchor(scoreView.topAnchor).active=true
        
    }
    
    func setupButton(){
        let clrBtn=ViewFactory.createButton("重置", action: Selector("clearNumber"), sender: self)
        self.view.addSubview(clrBtn)
        
        let genBtn=ViewFactory.createButton("生成", action: Selector("genNumber"), sender: self)
        self.view.addSubview(genBtn)
        
        
        //布局约束
        let margins = self.view.layoutMarginsGuide
        //
        clrBtn.trailingAnchor.constraintEqualToAnchor(margins.centerXAnchor, constant: -30).active = true
        clrBtn.bottomAnchor.constraintEqualToAnchor(margins.bottomAnchor, constant:-100).active=true
        //
        genBtn.leadingAnchor.constraintEqualToAnchor(margins.centerXAnchor, constant: 30).active = true
        genBtn.bottomAnchor.constraintEqualToAnchor(margins.bottomAnchor, constant:-100).active=true
        //
    }
    
//---------------------------游戏逻辑实现-------------------------
    
    //游戏面板重绘
    func resetGameMap(){
        UserModel.sharedInstance().saveBestScore(self.scoreView.score)
        for view in self.view.subviews{
            view.removeFromSuperview()
        }
        backgrounds.removeAll()
        tiles.removeAll()
        gameModel.clearAll()
        gameModel.dimension=self.dimension
        setupScoreLables()
        setupGameMap()
        setupButton()
        genNumber()
        
    }
    
    // 清除所有数字，重置按钮的响应方法
    func clearNumber(){
        gameModel.clearAll()
        for (_,tile) in tiles{
            tile.removeFromSuperview()
        }
        tiles.removeAll()
        
    }
    
    //生成新的数字，生成按钮的响应方法
    func genNumber(){
////        随机产生数字2和4，几率为1：4
//        let randv=Int(arc4random_uniform(5))
//        var seed:Int = 2
//        if randv==1 {
//            seed = 4
//        }

        let col=Int(arc4random_uniform(UInt32(dimension)))
        let row=Int(arc4random_uniform(UInt32(dimension)))
        
        if gameModel.isFull(){
            print("位置已经满了")
            return
        }
        
        if gameModel.tiles[row, col]>0 {
            genNumber()
            return
        }
        
        let seed=2 //原书的程序，按照一定的几率比来生成2或4。此处改成一直生成2.
        gameModel.setPosition(row, col: col, value: seed)
        insertTile((row,col), value: seed)
        
        // 生成数字后，判断一下游戏是否结束
        checkGameOver()
    }
    
    //插入一个数字方块
    func insertTile(pos:(Int,Int),value:Int){
        let (row,col)=pos
        
        let x=50 + CGFloat(col) * (self.width+self.padding)
        let y=150 + CGFloat(row) * (self.width+self.padding)
        
        let tile=TileView(pos:CGPointMake(x,y),self.width,value:value)
      
        self.view.addSubview(tile)
        self.view.bringSubviewToFront(tile)
        
        let index = NSIndexPath(forRow: row, inSection: col)
        
        tiles[index] = tile
        
        //布局约束
        var centerXConstant:CGFloat
        var centerYConstant:CGFloat
        if self.dimension%2 == 1 {
            centerXConstant = (self.padding+self.width) * CGFloat(col-self.dimension/2)
            centerYConstant = (self.padding+self.width) * CGFloat(row-self.dimension/2)
        }else{
            centerXConstant = (self.padding+self.width) * CGFloat(Double(col-self.dimension/2)+0.5)
            centerYConstant = (self.padding+self.width) * CGFloat(Double(row-self.dimension/2)+0.5)
        }
        let margins=self.view.layoutMarginsGuide
        tile.centerXAnchor.constraintEqualToAnchor(margins.centerXAnchor, constant: centerXConstant).active=true
        tile.centerYAnchor.constraintEqualToAnchor(margins.centerYAnchor, constant: centerYConstant).active=true
        //原书中的动画效果
//        tile.layer.setAffineTransform(CGAffineTransformMakeScale(0.1, 0.1))
        
//        UIView.animateWithDuration(0.5, delay: 0.1, options: UIViewAnimationOptions.TransitionNone, animations: { () -> Void in
//            tile.layer.setAffineTransform(CGAffineTransformMakeRotation(90))
//            }, completion: { (Bool) -> Void in
//                UIView.animateWithDuration(0.5, animations: { () -> Void in
//                    tile.layer.setAffineTransform(CGAffineTransformIdentity)
//                })
//        })
        
//        tile.alpha=0
//        UIView.animateWithDuration(0.5, delay: 0.01, options: UIViewAnimationOptions.CurveEaseInOut, animations: { () -> Void in
//            }) { (Bool) -> Void in
//                UIView.animateWithDuration(1, animations: { () -> Void in
//                    tile.alpha = 1
//                })
//        }
        
//        UIView.beginAnimations("animation", context: nil)
//        UIView.setAnimationDuration(2)
//        UIView.setAnimationCurve(UIViewAnimationCurve.EaseInOut)
//        UIView.setAnimationTransition(UIViewAnimationTransition.FlipFromLeft, forView: self.view, cache: false)
//        UIView.commitAnimations()
    }
    
    //移除一个数字方块
    func clearTile(row:Int,col:Int){
        
        let index=NSIndexPath(forRow: row, inSection: col)
        let tile=tiles[index]!
        tile.removeFromSuperview()
        tiles.removeValueForKey(index)
        
    }
    
    //添加滑动的手势识别处理
    func setupSwipeGestures(){
        let upSwipe=UISwipeGestureRecognizer(target: self, action: Selector("swipeUp"))
        upSwipe.numberOfTouchesRequired=1
        upSwipe.direction=UISwipeGestureRecognizerDirection.Up
        self.view.addGestureRecognizer(upSwipe)
        
        let downSwipe=UISwipeGestureRecognizer(target: self, action: Selector("swipeDown"))
        downSwipe.numberOfTouchesRequired=1
        downSwipe.direction=UISwipeGestureRecognizerDirection.Down
        self.view.addGestureRecognizer(downSwipe)
        
        let leftSwipe=UISwipeGestureRecognizer(target: self, action: Selector("swipeLeft"))
        leftSwipe.numberOfTouchesRequired=1
        leftSwipe.direction=UISwipeGestureRecognizerDirection.Left
        self.view.addGestureRecognizer(leftSwipe)
        
        let rightSwipe=UISwipeGestureRecognizer(target: self, action: Selector("swipeRight"))
        rightSwipe.numberOfTouchesRequired=1
        rightSwipe.direction=UISwipeGestureRecognizerDirection.Right
        self.view.addGestureRecognizer(rightSwipe)
        
    }
    
    //向上滑动
    func swipeUp(){
        tileVals = gameModel.tiles
        
        func merge(row row:Int,col:Int){
            if row == self.dimension-1{
                return
            }
            
            for i in (row+1)..<self.dimension {
                let valNew = tileVals[i,col]
                if valNew>0 {
                    let val = tileVals[row, col]
                    
                    if val == 0 {
                        tileVals[row, col] = valNew
                        tileVals[i, col] = 0
                        merge(row: row, col: col)
                    }else if val == valNew{
                        tileVals[row, col] = valNew<<1
                        tileVals[i, col] = 0
                        if row==0 {
                            merge(row: row, col: col)
                        }else{
                            merge(row: row-1, col: col)
                        }
//                        若产生合并，则加分
                        changeScore(valNew)
                    }else{
                        merge(row: row+1, col: col)
                    }
                    
                    break
                }
            }
        }
        
        for col in 0..<self.dimension{
            merge(row: 0, col: col)
        }
        
//        如果合并后的结果与原来相同，则不做任何操作
        if tileVals.isEqualTo(gameModel.tiles){
            return
        }
//        显示合并后的结果，并产生新的数字
        refresh()
        genNumber()
    }
    
    //向下滑动
    
    func swipeDown(){
        tileVals = gameModel.tiles
        
        func merge(row row:Int,col:Int){
            if row == 0{
                return
            }
            
            for var i=row-1;i>=0;i-- {
                let valNew=tileVals[i,col]
                if valNew>0 {
                    let val=tileVals[row,col]
                    
                    if val == 0 {
                        tileVals[row, col] = valNew
                        tileVals[i, col] = 0
                        merge(row: row, col: col)
                    }else if val == valNew{
                        tileVals[row, col] = valNew<<1
                        tileVals[i, col] = 0

                        if row==self.dimension-1 {
                            merge(row: row, col: col)
                        }else{
                            merge(row: row+1, col: col)
                        }
//                        若产生合并，则加分
                        changeScore(valNew)
                    }else{
                        merge(row: row-1, col: col)
                    }
                    
                    break
                }
            }
        }
        
        for col in 0..<self.dimension{
            merge(row: self.dimension-1, col: col)
        }
//        如果合并后的结果与原来相同，则不做任何操作
        if tileVals.isEqualTo(gameModel.tiles){
            return
        }
        
        refresh()
        genNumber()
    }
    
    //向左滑动
    func swipeLeft(){
        tileVals = gameModel.tiles
        func merge(row row:Int,col:Int){
            if col == self.dimension-1{
                return
            }
            
            for i in (col+1)..<self.dimension {
                let valNew=tileVals[row,i]
                if valNew>0 {
                    let val=tileVals[row,col]
                    
                    if val == 0 {
                        tileVals[row, col] = valNew
                        tileVals[row, i] = 0
                        merge(row: row, col: col)
                    }else if val == valNew{
                        tileVals[row, col] = valNew<<1
                        tileVals[row, i] = 0
                        if col==0 {
                            merge(row: row, col: col)
                        }else{
                            merge(row: row, col: col-1)
                        }
//                        若产生合并，则加分
                        changeScore(valNew)
                    }else{
                        merge(row: row, col: col+1)
                    }
                    
                    break
                }
            }
        }
        
        for row in 0..<self.dimension{
            merge(row: row, col: 0)
        }
        
//        如果合并后的结果与原来相同，则不做任何操作
        if tileVals.isEqualTo(gameModel.tiles){
            return
        }
        refresh()
        genNumber()
    }
    
    //向右滑动
    func swipeRight(){
        tileVals = gameModel.tiles
        func merge(row row:Int,col:Int){
            if col == 0{
                return
            }
            
            for var i=col-1;i>=0;i-- {
                let valNew=tileVals[row, i]
                if valNew>0 {
                    let val=tileVals[row, col]
                    
                    if val == 0 {
                        tileVals[row, col] = valNew
                        tileVals[row, i] = 0
                        merge(row: row, col: col)
                    }else if val == valNew{
                        tileVals[row, col] = valNew<<1
                        tileVals[row, i] = 0
                        if col==self.dimension-1 {
                            merge(row: row, col: col)
                        }else{
                            merge(row: row, col: col+1)
                        }
//                        若产生合并，则加分
                        changeScore(valNew)
                    }else{
                        merge(row: row, col: col-1)
                    }
                    
                    break
                }
            }
        }
        
        for row in 0..<self.dimension{
            merge(row: row, col: self.dimension-1)
        }
        
//        如果合并后的结果与原来相同，则不做任何操作
        if tileVals.isEqualTo(gameModel.tiles){
            return
        }
        refresh()
        genNumber()
        
    }
    
    //刷新页面
    func refresh(){
        for i in 0..<self.dimension{
            for j in 0..<self.dimension{
                let val = gameModel.tiles[i,j]
                let valNew = tileVals[i,j]
                if valNew != val{
                    gameModel.setPosition(i, col: j, value: valNew)
                    if valNew>0{
                        if val>0{
                            clearTile(i, col: j)
                        }
                        insertTile((i,j) , value: valNew)
                        
                    }else{
                        clearTile(i, col: j)
                    }
                }
                
            }
        }
    }
    
    //加分
    func changeScore(baseNum:Int){
        self.scoreView.score += baseNum * 2
        
    }
    
    //检查游戏是否结束
    func checkGameOver(){
        if self.gameModel.isFull(){
            for row in 0..<self.dimension{
                for col in 0..<self.dimension{
                    let val = gameModel.tiles[row,col]
                    let left:Int? = (col-1)>=0 ? gameModel.tiles[row,col-1] : nil
                    let right:Int? = (col+1)<self.dimension ? gameModel.tiles[row,col+1] : nil
                    let up:Int? = (row-1)>=0 ? gameModel.tiles[row-1,col] : nil
                    let down:Int? = (row+1)<self.dimension ? gameModel.tiles[row+1,col] : nil
                    if (val==left) || (val==right) || (val==up) || (val==down){
                        return
                    }
                    
                }
            }
            
            let alerController = UIAlertController(title: "游戏结束", message: "本轮游戏结束，重新开始吧！", preferredStyle: UIAlertControllerStyle.Alert)
            alerController.addAction(UIAlertAction(title: "Ready Go!", style: UIAlertActionStyle.Default, handler: {
                action in
                self.resetGameMap()
            }))
            self.presentViewController(alerController, animated: true, completion: nil)
            return
        }
    }
    
}