三消游戏四消道具知识点

//第一次点击交换时判断生成横着块和竖着块，调用此方法，传进来点击的两个块的下标
_checkFourArr:function(tar,old){
    var returnArr = [];
    for(var indexArr in this._fourCellShuArr){     //遍历4个相连竖着的数组
        var ob = this._fourCellShuArr[indexArr];
        if((ob.x == old.x&&ob.y == old.y)||(ob.x == tar.x&&ob.y == tar.y)){
            cc.log("生成消除横着一条的方块",ob.x,ob.y);
            this.shred_arr[ob.x][ob.y].setToSpecial(1);
            this._fourCellNum++;
            returnArr.push (ob);
        }
    }
    for(var indexArr2 in this._fourCellHengArr){   //遍历4个相连横着的数组
        var obj = this._fourCellHengArr[indexArr2];
        if((obj.x == old.x&&obj.y == old.y)||(obj.x == tar.x&&obj.y == tar.y)){
            cc.log("生成消除竖着一条的方块",obj.x,obj.y);
            this.shred_arr[obj.x][obj.y].setToSpecial(2);
            this._fourCellNum++;
            returnArr.push (obj);
        }
    }
    return returnArr;
},

_checkFourArr:function(tar,old){
    var returnArr = [];
    for(var indexArr in this._fourCellShuArr){     //遍历4个相连竖着的数组
        var ob = this._fourCellShuArr[indexArr];
        if((ob.x == old.x&&ob.y == old.y)||(ob.x == tar.x&&ob.y == tar.y)){
            cc.log("生成消除横着一条的方块",ob.x,ob.y);
            this.shred_arr[ob.x][ob.y].setToSpecial(1);
            this._fourCellNum++;
            returnArr.push (ob);
        }
    }
    for(var indexArr2 in this._fourCellHengArr){   //遍历4个相连横着的数组
        var obj = this._fourCellHengArr[indexArr2];
        if((obj.x == old.x&&obj.y == old.y)||(obj.x == tar.x&&obj.y == tar.y)){
            cc.log("生成消除竖着一条的方块",obj.x,obj.y);
            this.shred_arr[obj.x][obj.y].setToSpecial(2);
            this._fourCellNum++;
            returnArr.push (obj);
        }
    }
    return returnArr;
},

_checkFourArr:function(tar,old){
    var returnArr = [];
    for(var indexArr in this._fourCellShuArr){     //遍历4个相连竖着的数组
        var ob = this._fourCellShuArr[indexArr];
        if((ob.x == old.x&&ob.y == old.y)||(ob.x == tar.x&&ob.y == tar.y)){
            cc.log("生成消除横着一条的方块",ob.x,ob.y);
            this.shred_arr[ob.x][ob.y].setToSpecial(1);
            this._fourCellNum++;
            returnArr.push (ob);
        }
    }
    for(var indexArr2 in this._fourCellHengArr){   //遍历4个相连横着的数组
        var obj = this._fourCellHengArr[indexArr2];
        if((obj.x == old.x&&obj.y == old.y)||(obj.x == tar.x&&obj.y == tar.y)){
            cc.log("生成消除竖着一条的方块",obj.x,obj.y);
            this.shred_arr[obj.x][obj.y].setToSpecial(2);
            this._fourCellNum++;
            returnArr.push (obj);
        }
    }
    return returnArr;
},
//第一次点击消除后掉落补缺时产生4消道具块时调用此方法，传进来相连块第一个快的下标（我这里后面掉落生成的都是放在第一个块）
_checkIsState:function(arr){
    var returnArr = [];
    for(var indexArr in this._fourCellShuArr){
        var ob = this._fourCellShuArr[indexArr];
        if(ob.x == arr.x&&ob.y == arr.y) {
            cc.log("生成消除横着一条的方块", ob.x, ob.y);
            this.shred_arr[ob.x][ob.y].setToSpecial(1);
            this._fourCellNum++;
            returnArr.push (cc.p(ob.x,ob.y))
        }
    }

    for(var indexArr2 in this._fourCellHengArr){
        var obj = this._fourCellHengArr[indexArr2];
        if(obj.x == arr.x&&obj.y == arr.y){
            cc.log("生成消除竖着一条的方块",obj.x,obj.y);
            this.shred_arr[obj.x][obj.y].setToSpecial(2);
            this._fourCellNum++;
            returnArr.push (cc.p(obj.x,obj.y))
        }
    }
    return returnArr;
},
 //在点击两块交换后有消除情况时调用此方法，传进来消除块和点击两块的下标   
_checkIsDown:function(arr,tar,old){
    this._haveFourCell = false;
    var temp;
    if(this._isFirstClear){            //判断是第一次点击还是后续掉落状态
        for(var arrIndex in arr){      //遍历消除数组，判断点击的两个块哪个块在消除的数组中，用temp存起来
            var ob = arr[arrIndex];
            if(ob.x == tar.x&&ob.y == tar.y){
                temp = tar;
            }else if(ob.x == old.x&&ob.y == old.y){
                temp = old;
            }
        }
        //如果当前交换的块是特效块，并且又要在此处生成特效块，_isTouchSpcial赋值true （处理特殊情况）                                
        if(arr.length >=4 &&this.shred_arr[temp.x][temp.y].isSpecial){   
            if(this._fourCellShuArr.length>0||this._fourCellHengArr.length>0) {
                this._isTouchSpcial = true;
            }
        }else{       //遍历消除数组，当满足生成四消条件时调用上面的方法，传入点击的两个块（这里不用temp而是传入两个值，是因为有可能交换后，在这两个位置同时生成四消块，所以需要传入两个值） 
            for(var arrIn in arr){
                var obj = arr[arrIn];
                if((obj.x == tar.x&&obj.y == tar.y&&(this._fourCellHengArr.length>0||this._fourCellShuArr.length>0))||
                    (obj.x == old.x)&&(obj.y==old.y)&&(this._fourCellHengArr.length>0||this._fourCellShuArr.length>0)){
                    var spSpecialArr = this._checkFourArr(tar,old);
                }
            }
            if(spSpecialArr){   //把标记的四消块存在一个数组中，调用下面的删除方法，把消除数组中的四消块删除掉（因为我的逻辑是四消块生成时不进行消除，而是标记）
                arr = this._filterDeleteSame(arr,spSpecialArr);
                this._checkFirstFourArr.push(spSpecialArr);  //这里用一个全局的空数组存起来这个刚刚生成的四消块，因为我要在后面对删除数组进行递归检查，有可能会在添加一行一列时把这个刚刚生成的四消块添加进去，导致第一次生成就删除掉了）
            }
        }
    }else{       //在后续掉落补缺时进行生成四消块的逻辑（横着）
        if (this._fourCellHengArr.length > 0) {
            var arrFo = this._filtCreatFourHeng(this._fourCellHengArr); //调用下面的方法，判断有几个四个以上相连，好在每一个四个以上相连处生成一个四消块
            for(var i = 0;i< arrFo.length;i++) {
                for(var j = 0;j<arrFo[i].length;j++){
                    if(!this.shred_arr[arrFo[i][j].x][arrFo[i][j].y].isSpecial){
                        var spSpecialArr2 = this._checkIsState(arrFo[i][j]);
                        if(spSpecialArr2){
                            arr = this._filterDeleteSame(arr,spSpecialArr2);
                            this._checkFirstFourArr.push(spSpecialArr2);
                        }
                        break;
                    }
                }
            }
                   
        } if (this._fourCellShuArr.length > 0) {          //在后续掉落补缺时进行生成四消块的逻辑（横着）
            var arrFord = this._filtCreatFourShu(this._fourCellShuArr);
            for(var k = 0;k< arrFord.length;k++) {
                for(var l = 0;l<arrFord[k].length;l++){
                    if(!this.shred_arr[arrFord[k][l].x][arrFord[k][l].y].isSpecial){
                        var SpecialArr = this._checkIsState(arrFord[k][l]);
                        if(SpecialArr){
                            arr = this._filterDeleteSame(arr,SpecialArr);
                            this._checkFirstFourArr.push(SpecialArr);
                        }
                        break;
                    }
                }
            }
        }
    }
    arr = this._isCheckFourClear(arr); //对消除的数组进行递归检查，把所有满足条件的块添加进来，进行统一消除处理
    if(this._isTouchSpcial){           //如果当前交换的块是特效块，并且又要在此处生成特效块，就在消除数组检查完之后，再把这个特效块从消除数组中删除掉（就只需要把四消特效需要消除的一行或一列添加进去，但是在此处任然不能消除这个特效块，所以进行这个处理）
        arr = this._filterDeleteSame(arr,temp);
        if(this._fourCellShuArr.length>0){
            this.shred_arr[tar.x][tar.y].setToSpecial(1);//由于没有经过那个生成四消块方法，所以需要在这里给它进行标记，这个方法是封装在方块类里面的
            this._fourCellNum++;
        }else{
            this.shred_arr[tar.x][tar.y].setToSpecial(2);
            this._fourCellNum++;
        }
    }
    this._clearCell(arr);          //最后调用消除方法，传消除数组进去进行消除
},
//递归检查（有可能消除块时一行一列上有其他特效块，所以这里用递归处理）
_isCheckFourClear:function(arr){
    this._boo = false;
    this._bo = false;
    var clearOnceArr = [];
    for(var arrIndex in arr) {
        var obj = arr[arrIndex];        
        if (this._checkFirstFourArr.length>0) {      //这个遍历就是把刚刚生成的四消块进行处理，不要在此次就消除掉了
            for (var firstArrIndex in this._checkFirstFourArr) {
                var checkFirst = this._checkFirstFourArr[firstArrIndex];
                if (obj.x == checkFirst[0].x && obj.y == checkFirst[0].y) {
                    this._boo = true;
                    this._booFirstArr = obj
                }
            }
        }
    }
    if(this._boo){
        arr = this._filterDeleteSame(arr, this._booFirstArr);
        this._booFirstArr = [];
    }
 //遍历消除块，如果有特效块，判断是消除一行还是一列，然后把满足的块添加到一个空数组中
    for(var arrIndex2 in arr) {                         var ob = arr[arrIndex2];        if(this.shred_arr[ob.x][ob.y].isSpecial){  //判断是不是特效块            this._bo = true;            this.shred_arr[ob.x][ob.y].resetSpecal();            if(this.shred_arr[ob.x][ob.y].isCreatType ==1){                cc.log("有四消,消除横着一条",(ob.x,ob.y));                this._haveFourCell = true;                for(var k = 0;k<GAME_CONFIG.SHRED_NUM_W;k++){                    clearOnceArr.push(cc.p(k,ob.y))                }            }else{                cc.log("有四消,消除竖着一条",(ob.x,ob.y));                this._haveFourCell = true;                for(var l = 0;l<GAME_CONFIG.SHRED_NUM_W;l++){                    clearOnceArr.push(cc.p(ob.x,l))                }            }        }    }    if(clearOnceArr) arr = this._filterDelSame(clearOnceArr,arr); //调用此方法，把刚刚添加一行或一列的数组和消除数组进行处理重复块的操作，以免有重复块消除导致报错    if(this._bo){        this._isCheckFourClear(arr);    }    else {        this._returnClearArr = arr.slice()    }    return  this._returnClearArr;     //在递归中，返回值时需要使用全局变量存取值后返回，不然返回的值时undifind（很坑，我就被坑了半天）},
/*
 * 删除相同的元素
 * */
_filterDeleteSame:function(arr1,arr2){
    var returnArr = arr1.concat(arr2);
    for(var i = 0; i < returnArr.length; i++){
        var nowPo = returnArr[i];
        for(var j = i + 1; j < returnArr.length; j++){
            if(cc.pSameAs(returnArr[j], nowPo)){
                returnArr.splice(j , 1);
                returnArr.splice(i , 1);
                j--
            }
        }
    }
    return returnArr
},

/*
 * 对重复的块进行处理
 * */
_filterDelSame: function(arr1,arr2){
    var returnArr = arr1.concat(arr2);
    for(var i = 0; i < returnArr.length; i++){
        var nowPo = returnArr[i];
        for(var j = i + 1; j < returnArr.length; j++){
            if(cc.pSameAs(returnArr[j], nowPo)){
                returnArr.splice(j , 1);
                j--
            }
        }
    }
    return returnArr
},
//判断后续掉落时有几个四个以上相同块相连的情况（横着），（不进行这个处理的就会导致只会生成一个四消块）
_filtCreatFourHeng:function(arr){ 
    var a =[];   
    var returnArr = [];
    for(var i = 0;i< GAME_CONFIG.SHRED_NUM_W;i++){
        for(var j = 0;j< arr.length;j++){
            if(arr[j].y == i){
                a.push(arr[j])            
        }        
    }
        if(a.length>0) returnArr.push(a);
        a = [];
    }
    return returnArr;
},
//判断后续掉落时有几个四个以上相同块相连的情况（横着）
_filtCreatFourShu:function(arr){
    var a =[];
    var returnArr = [];
    for(var i = 0;i< GAME_CONFIG.SHRED_NUM_W;i++){
        for(var j = 0;j< arr.length;j++){
            if(arr[j].x == i){
                a.push(arr[j])
            }
        }
        if(a.length>0) returnArr.push(a);
        a = [];
    }
    return returnArr;
},
//消除逻辑，消除后加分，变量初始化进行下次消除
_clearCell:function(arr){
    //只负责消除逻辑
    for (var index in arr) {
        var ob = arr[index];
        cc.eventManager.dispatchCustomEvent(GAME_EVENT.ANIMAL_BOMB,this.shred_arr[ob.x][ob.y].getPosition());
        this.shred_arr[ob.x][ob.y].removeFromParent(true);
        this.shred_arr[ob.x][ob.y] = null;
    }
    this._count += 1;
    this._setSore += (arr.length+this._fourCellNum)*this._count*10;//this._fourCellNum这个变量是在每次产生四消块时加1，因为我的四消块是没有消除的，分数上四消就和三消一样了，所以要进行处理
    this.Score.setString(this._setSore);        

    this._fourCellNum = 0;
    this._fourCellShuArr = [];
    this._fourCellHengArr = [];
    this._isFirstClear = false;
    this._returnClearArr = [];
    this._isTouchSpcial = false;
    this._checkFirstFourArr = [];

    if(this._haveFourCell) this._createHunShou();

    this.rootNode.scheduleOnce(this._shredDown.bind(this),0.51);
},


这个逻辑总体上来说确实写的比较乱，可能对我难度也挺高吧，还是要多多加油，努力提高自己，如果有写过的并且写的很简单的朋友欢迎来与我讨论
//第一次点击消除后掉落补缺时产生4消道具块时调用此方法，传进来相连块第一个快的下标（我这里后面掉落生成的都是放在第一个块）