swift一周小结（2）

上一篇，我们把连连看的布局给显示出来，这一篇主要来连连的逻辑

1 按钮的点击事件

 // MARK: 点击事件    func chessBtnClicked(sender: ChessBtn?){        if sender == nil {            if self._selectChess != nil {             //判断是否第二次点击了按钮               self.normalChess(self._selectChess!)               //动画回复正常方法               self._selectChess = nil            }               return        }        if self._selectChess == nil{            // 第一次点击棋子            self._selectChess = sender            //动画把按钮变大方法            self.bigChess(self._selectChess!)        } else {            let lastChess = sender!            let nowChess = self._selectChess! /第一次点击的按钮        //点击第二个棋子            let canEat = self.canChessEat(nowChess, chess2: lastChess)//判断是否可以消除方法            if canEat {//如果可以的话                self.chessEat(nowChess, chessBtn2: lastChess)//消除方法                if self.checkExistPath() == nil{//没有选择按钮                  self.resum(nil)//重新开始            }            self.checkWin()//赢了            return            }            self.normalChess(self._selectChess!)            self._selectChess = sender            self.bigChess(self._selectChess!)         }    }

2 按钮变大变小的动画

 // MARK: - 棋子动画    // 让棋子变大    func bigChess(sender: UIButton){        UIView.animateWithDuration(0.25) { () -> Void in            sender.transform = CGAffineTransformMakeScale(kBigScale, kBigScale)        }        self.chessView.bringSubviewToFront(sender)    }    // 让棋子恢复正常大小    func normalChess(sender: UIButton){        UIView.animateWithDuration(0.25) { () -> Void in            sender.transform = CGAffineTransformIdentity        }    }

3 检查是否存在可消去的棋子

    func checkExistPath()->(chess1:ChessBtn, chess2:ChessBtn)?{        var lifingChesses = self._lifingChesses        while lifingChesses.count>0 {            let c1 = lifingChesses[0]            for c2 in lifingChesses{                if (c1.tag==c2.tag) && (c1 != c2){                    if self.canChessEat(c1, chess2: c2){                        return (c1,c2)                    }else{                        lifingChesses.removeAtIndex(lifingChesses.indexOf(c1)!)                        lifingChesses.removeAtIndex(lifingChesses.indexOf(c2)!)                        break                    }                }            }        }        return nil    }

4.判断棋子是否能消去

    func canChessEat(chess1:ChessBtn , chess2:ChessBtn) -> Bool{        if chess1.isEqual(chess2) {return false}    // 判断是否同一个按钮，是的话不做处理        if chess1.tag != chess2.tag {return false}  // 图片是否同一样，如果不是就是图片不一样的图片，不做处理        var canEat:Bool = false        let chess1Path = self.pathCanGo(chess1)        let chess2Path = self.pathCanGo(chess2)        canEat = self.oneLine(chess1.center, point2: chess2.center)//判断直线上是否可以消除        if !canEat {            canEat = self.twoLine(chess1Path, chess2Path: chess2Path)//直角线是否可以消除            if !canEat {                canEat = self.threeLine(chess1Path, chess2Path: chess2Path)            }        }        return canEat}5 返回chess在x，y轴上能走的路径,路径不包含chess所      func pathCanGo(chessBtn:ChessBtn) ->(ChessPath){        if self._lifingChesses.count < 0 { return ([],[])}        let minX = self._beginX - self._normalWidth        let minY = self._beginY - self._normalHeight        let maxX = minX + CGFloat(kCount_colum)*self._normalWidth + self._normalWidth        let maxY = minY + CGFloat(kCount_row)*self._normalHeight + self._normalHeight        let originX = chessBtn.center.x        let originY = chessBtn.center.y        var x1Arr:Array<CGPoint> = []        var x1 = originX - self._normalWidth        while x1 + kMinOffset >= minX{         let point = CGPointMake(x1, originY)         if isIdlePoint(point){            x1Arr.append(point)         }else{            break         }          x1 -= self._normalWidth        }        var x2Arr:Array<CGPoint> = []        var x2 = originX + self._normalWidth        while x2 - kMinOffset <= maxX{        let point = CGPointMake(x2, originY)        if isIdlePoint(point){            x2Arr.append(point)        }else{            break        }            x2 += self._normalWidth        }        var y1Arr:Array<CGPoint> = []        var y1 = originY - self._normalHeight        while y1 + kMinOffset >= minY {            let point = CGPointMake(originX, y1)            if isIdlePoint(point){                y1Arr.append(point)            }else{                break            }            y1 -= self._normalHeight        }        var y2Arr:Array<CGPoint> = []        var y2 = originY + self._normalHeight        while y2 - kMinOffset <= maxY {            let point = CGPointMake(originX, y2)            if isIdlePoint(point){                y2Arr.append(point)            }else{                break            }            y2 += self._normalHeight        }        let chessPath = ChessPath(x1Arr+x2Arr,y1Arr+y2Arr)        return chessPath    }

6 判断是否可以通过线消除

// 判断能否通过 1 条线吃掉func oneLine(point1:CGPoint, point2:CGPoint)->Bool{    if abs(point1.x - point2.x)<kMinOffset {        // 判断y轴上能否连在一起        let count:Int = Int(abs((point2.y-point1.y)/self._normalHeight)+0.5)        let padding = point2.y > point1.y ? self._normalHeight : -self._normalHeight        var isLine = true        if count == 0 {return false}        for i in 1...count {            let y = point1.y + padding*CGFloat(i)            let point = CGPoint(x: point1.x, y: y)            if i == 1 {                // 1.距离为1表示相连                if pointEqualToPoint(point, point2: point2){                    isLine = true                    break                }            }            if i == count {                // 2.距离为count不用判断                break            }            // 3.判断中间是否都是空闲的            if self.isIdlePoint(point) == false {                //  无法直连                isLine = false                break            }        }        return isLine    }    if abs(point1.y - point2.y)<kMinOffset {        // 判断x轴上能否连在一起        let count:Int = Int(abs((point2.x-point1.x)/self._normalWidth)+0.5)        let padding = point2.x > point1.x ? self._normalWidth : -self._normalWidth        var isLine = true        for i in 1...count {            let x = point1.x + padding*CGFloat(i)            let point = CGPoint(x: x, y: point1.y)            if i == 1 {                // 1.相连                if pointEqualToPoint(point, point2: point2){                    isLine = true                    break                }            }            if i == count {                // 2.距离为count不用判断                break            }            // 3.判断中间是否都是空闲的            if self.isIdlePoint(point) == false {                //  无法直连                isLine = false                break            }        }        return isLine    }    return false} // 判断能否通过 2 条线吃掉func twoLine(chess1Path:ChessPath, chess2Path:ChessPath)->Bool{    // chess1的x轴路线交与chesss2的y轴路线    for i in 0 ..< chess1Path.xArr.count {        let xPoint = chess1Path.xArr[i]        for j in 0 ..< chess2Path.yArr.count {            let yPoint = chess2Path.yArr[j]            if pointEqualToPoint(xPoint, point2: yPoint) {return true}        }    }    // chess1的y轴路线交与chesss2的x轴路线    for i in 0 ..< chess1Path.yArr.count {        let yPoint = chess1Path.yArr[i]        for j in 0 ..< chess2Path.xArr.count {            let xPoint = chess2Path.xArr[j]            if pointEqualToPoint(yPoint, point2: xPoint) {return true}        }    }    return false}// 判断能否通过 3 条线吃掉func threeLine(chess1Path:ChessPath, chess2Path:ChessPath)->Bool{    // chess1的x轴路径与chess2的x轴路径有直连线存在    for i in 0 ..< chess1Path.xArr.count {        let chess1Point:CGPoint = chess1Path.xArr[i]        for j in 0 ..< chess2Path.xArr.count {            let chess2Point:CGPoint = chess2Path.xArr[j]            let xOffset = abs(chess1Point.x - chess2Point.x)            if xOffset < kMinOffset {                // x坐标相同的2点,判断此2点能否直连                if self.oneLine(chess1Point, point2: chess2Point) {                    return true                }            }        }    }    // chess1的y轴路径与chess2的y轴路径有直连线存在    for i in 0 ..< chess1Path.yArr.count {        let chess1Point:CGPoint = chess1Path.yArr[i]        for j in 0 ..< chess2Path.yArr.count {            let chess2Point:CGPoint = chess2Path.yArr[j]            let yOffset = abs(chess1Point.y - chess2Point.y)            if yOffset < kMinOffset {                // y坐标相同的2点，判读此2点能否直连                if self.oneLine(chess1Point, point2: chess2Point) {                    return true                }            }        }    }    return false}

7  判断两点是否相等  func pointEqualToPoint(point1:CGPoint, point2:CGPoint)->Bool{        let xSet = point2.x - point1.x        let ySet = point2.y - point1.y        var isEqual:Bool = false        if abs(xSet)<kMinOffset && abs(ySet)<kMinOffset {            isEqual = true        }        return isEqual    }

8 消去相同的棋子

    func chessEat(chessBtn:ChessBtn,chessBtn2:ChessBtn){        if chessBtn.isEqual(chessBtn2) {return}        if chessBtn.tag != chessBtn2.tag {return}        self._selectChess = nil        let index1 = self._lifingChesses.indexOf(chessBtn2)        self._lifingChesses.removeAtIndex(index1!)        let index2 = self._lifingChesses.indexOf(chessBtn)        self._lifingChesses.removeAtIndex(index2!)        self._deadChesses.append(chessBtn2)        self._deadChesses.append(chessBtn)        self.normalChess(chessBtn)        self.normalChess(chessBtn2)        chessBtn2.frame = CGRectZero        chessBtn.frame = CGRectZero        chessBtn.enabled = false        chessBtn.enabled = false}

// 9 判断两点是否相等

    func pointEqualToPoint(point1:CGPoint, point2:CGPoint)->Bool{        let xSet = point2.x - point1.x        let ySet = point2.y - point1.y        var isEqual:Bool = false        if abs(xSet)<kMinOffset && abs(ySet)<kMinOffset {            isEqual = true        }        return isEqual    }

10  判断point上是否有其他棋子

    func isIdlePoint(point:CGPoint)->Bool{        var isIdle = true        for chessbtn in self._lifingChesses{            let chessPoint = chessbtn.center            isIdle = !pointEqualToPoint(point, point2: chessPoint)            if isIdle == false {break}        }        return isIdle    }

11  赢了

    func checkWin(){        if self._lifingChesses.count == 0{            self._timer?.invalidate()            self._timer = nil            self._isOnGame = false            // 提示            if #available(iOS 8.0, *) {                let winAlert = UIAlertController(title: "连连看", message: "恭喜通过！", preferredStyle: UIAlertControllerStyle.Alert)                winAlert.addAction(UIAlertAction(title: "确定", style: UIAlertActionStyle.Cancel, handler: { (action:UIAlertAction) -> Void in                    self.resetChess()                }))                self.presentViewController(winAlert, animated: true, completion: nil)            } else {                let winAlert = UIAlertView(title: "连连看", message: "恭喜通过!", delegate: self, cancelButtonTitle: "确定")                winAlert.show()            }        }    }

12 输了

      func gameFail(){        self.darkLifingChess()        self.start.enabled = true        self._selectChess = nil        self._timer?.invalidate()        self._timer = nil        self._isOnGame = false        // 提示        if #available(iOS 8.0, *) {            let failAlert = UIAlertController(title: "连连看", message: "没有时间啦！", preferredStyle: UIAlertControllerStyle.Alert)            failAlert.addAction(UIAlertAction(title: "确定", style: UIAlertActionStyle.Cancel, handler: { (action:UIAlertAction) -> Void in            }))            self.presentViewController(failAlert, animated: true, completion: nil)        } else {            let failAlert = UIAlertView(title: "连连看", message: "没有时间啦!", delegate: nil, cancelButtonTitle: "确定")            failAlert.show()        }    }

13 重置棋盘
func resetChess(){
self.timerProgress.setProgress(1.0, animated: true)
self._timer?.invalidate()
self._timer = nil

    self.start.enabled = true    self._lifingChesses = self._lifingChesses + self._deadChesses    self._deadChesses = []    self.darkLifingChess()    self.setUpPosition(random: true)}

14 定时器的任务

    func timerTask(timer:NSTimer){        if self.timerProgress.progress <= 0 {            // 游戏结束了            self.gameFail()            return        }        var progress = self.timerProgress.progress - 1/Float(kTimeSecond)        progress = progress>=0 ? progress : 0        self.timerProgress.setProgress(progress, animated: true)        if self.timerProgress.progress <= 0 {            // 游戏结束了            self.gameFail()            return        }    }

开始

 @IBAction func start(sender: UIButton!) {        self._lifingChesses = self._lifingChesses + self._deadChesses        self._deadChesses = []        self.lightLifingChess()        self.resum(nil)        sender.enabled = false        self._isOnGame = true        self.timerProgress.setProgress(1.0, animated: true)        self._timer?.invalidate()        self._timer = nil        self._timer = NSTimer.scheduledTimerWithTimeInterval(1, target: self, selector: Selector("timerTask:"), userInfo: nil, repeats: true)    }

//暂停

@IBAction func pasue(sender: UIButton!) {        if self._isOnGame == false {return}        let title = sender.titleForState(UIControlState.Normal)!        if title == "暂停" {            // 暂停游戏，用来调试            self._timer?.invalidate()            self._timer = nil            self.darkLifingChess()            self.pasue.setTitle("继续", forState: UIControlState.Normal)        }else if title == "继续" {            // 继续游戏            self._timer?.invalidate()            self._timer = nil            self.lightLifingChess()            self._timer = NSTimer.scheduledTimerWithTimeInterval(1, target: self, selector: Selector("timerTask:"), userInfo: nil, repeats: true)            self.pasue.setTitle("暂停", forState: UIControlState.Normal)        }    }

重新开始

    @IBAction func resum(sender:UIButton!) {        self.chessBtnClicked(nil)        UIView .animateWithDuration(0.5, animations: { () -> Void in            self.setUpPosition(random: true)            }) { (stop) -> Void in                // 检查是否有可消路径                if self.checkExistPath() == nil{                    self.resum(nil)                }        }    }

代码基本上都就这，我会把代码放在github上，之后会把连接发上来