您的位置: 首页  >  文章  >  学习连连看 连接线之谜+道具的使用

学习连连看 连接线之谜+道具的使用

分类: 文章 • 2025-03-10 08:43:46

  下面讲解今天的重头戏，就是如何吧两个符合规则的图片链接起来。这个杂眼看起来很简单，不过BOY 也是费了很大的周折。

       其实我发现连连第二个重要的算法就是这个了。不过BOY 想到了一个很简单的解决办法。

       下面就讲解一下。

      学习连连看 连接线之谜+道具的使用

          大家看到这个连接的红线了，或许刚开始 可能看不出来这有什么规律，我也是研究和一下，看看希望怎么把这个算法告诉大家。
大家看到这个红线的时候 主要看那两个拐角的地方。其实在做的时候BOY 发现所有的线都是指向拐角处的。我画个图大家就明白了。
学习连连看 连接线之谜+道具的使用

通过上一章的算法讲解我们很容易知道 那个拐角处的点是什么，如果对着一点不明白的先看看上一章连连看的算法。
这里有的朋友要问了，那没有拐角的怎么办呢，其实很好办，我之所以非要知道这个拐角是因为，这个拐角就是这个链接的结束。对已没有拐角的我就假设一个拐角，让其中的一条线指向他就可以了。简答一点说就是连连看中所有的连接线都是一条线段或者多条线段组成的，只是在游戏中我们看到只会是一气呵成的线。既然有线段 那么大家在初中的时候就知道线段有开始点和结束点。
然后我们在程序中就是想法求出这些线段的开始点和结束点就可以了。

有这个思想以后 我们就开始我们程序之旅 我上部分代码

[cpp] view plain copy
  1. void LLKAlgorithm::lineWay(cocos2d::CCArray* array,cocos2d::CCArray* htiarray,bool orishen){  
  2.         CustomSprite* hit1=(CustomSprite*)htiarray->objectAtIndex(0);// 取出第一个  
  3.         CustomSprite* hit2=(CustomSprite*)htiarray->objectAtIndex(1);// 取出第二个  
  4.   
  5.         CustomSprite* pEnd=NULL; // 结束点  
  6.         CustomSprite* pStar=NULL;// 开始点  
  7.         // 看看这两个点 有没有开始点 如果没有 就把hit1 设置成 结束点 hit2 设置成 开始点   
  8.         if (hit1->getOriginal()==1){  
  9.                 pEnd=hit1;  
  10.                 pStar=hit2;  
  11.         }          
  12.         if (hit2->getOriginal()==1){  
  13.                 pEnd=hit2;  
  14.                 pStar=hit1;  
  15.         }          
  16.         if (pEnd==NULL){  
  17.                 pEnd=hit1;  
  18.                 pStar=hit2;  
  19.         }  
  20.         pEnd->setPath(0);  
  21.         if (orishen){                  
  22.                 int temppath=1;// 设置当前 直线的方向      
  23.                 if(pStar->getX()>pEnd->getX()){  
  24.                         temppath=3;  
  25.                 }                  
  26.           
  27.                 for (int i=0;i<array->count();i++){  
  28.                         CustomSprite* hitteim=(CustomSprite*) array->objectAtIndex(i);  
  29.                         if (hitteim!=pEnd){  
  30.                                 hitteim->setPath(temppath);  
  31.                         }  
  32.                 }  
  33.         }else {                  
  34.                 int temppath=2;// 设置当前 直线的方向  
  35.   
  36.                 if(pStar->getY()<pEnd->getY()){  
  37.                         temppath=4;  
  38.                 }  
  39.                 for (int i=0;i<array->count();i++){  
  40.                         CustomSprite* hitteim=(CustomSprite*) array->objectAtIndex(i);  
  41.                         if (hitteim!=pEnd){  
  42.                                 hitteim->setPath(temppath);  
  43.                         }  
  44.                 }  
  45.         }  
  46.   
  47. }  

通过上面的这个只是没有拐角的连点连通的直线如何去画，不过看过BOY 的算法的人都知道，BOY 最后的步骤都是吧这些拐角都转化成了 两点直线连接的。所以来说就这个就可以了。

下面就说下道具的使用
连连看中最常用的道具， 查找道具  炸弹 道具 重新排序道具。这三种最重要和最常用的道具，下面我就说下这三个道具的是如何通过算法实现的，
第一个查找道具
实现代码如下

[cpp] view plain copy
  1. void LLKGameLayer::seachCallBack(cocos2d::CCObject* psend){  
  2.         LLKmapLayer* lLKmapLayer=(LLKmapLayer*) this->getChildByTag(1);  
  3.         CCArray* llkarry= lLKmapLayer->getllkArray();  
  4.         CCArray* searcharr=CCArray::create();  
  5.         for(int i=0;i<llkarry->count();i++){  
  6.                 CustomSprite* custom=(CustomSprite*)llkarry->objectAtIndex(i);  
  7.                 if (custom->getIsEliminate()==false){  
  8.                         searcharr->addObject(custom);  
  9.                         for(int j=0;j<llkarry->count();j++){  
  10.                                 CustomSprite* custom2=(CustomSprite*)llkarry->objectAtIndex(j);  
  11.                                 if (custom2->getIsEliminate()==false){  
  12.                                         if (custom2!=custom){          
  13.                                                 if (custom->getIndex()==custom2->getIndex()){  
  14.                                                         searcharr->addObject(custom2);  
  15.                                                         break;  
  16.                                                 }  
  17.                                         }  
  18.                                 }  
  19.   
  20.   
  21.                         }  
  22.   
  23.                         if(searcharr->count()==2){  
  24.                                 CCArray* temp=LLKAlgorithm::algorithm(lLKmapLayer->gettotalArray(),searcharr);  
  25.                                 if (temp->count()>0){  
  26.                                         break;  
  27.                                 }else{  
  28.                                         LLKAlgorithm::removeAllArray(searcharr,false);  
  29.                                 }  
  30.   
  31.                         }  
  32.                 }  
  33.         }  
  34.   
  35.         if (searcharr->count()==2){  
  36.                 for(int i=0;i<searcharr->count();i++){  
  37.                         CustomSprite* temp=(CustomSprite*)searcharr->objectAtIndex(i);  
  38.                         temp->displayHitPic(1);  
  39.                 }  
  40.                 LLKAlgorithm::removeAllArray(searcharr,false);  
  41.         }  
  42.   
  43.   
  44. }  

上面的代码主要实现思路就是 把剩下的还没消除的图片 循环取出 两张相同的图片，然后通过我们上一章讲解的算法来判断这两章图片是否相连。如果找到那么就把这两张图片标示出来。  是不是很简单 哈哈。


第二个算法 
炸弹 这个我感觉是最简单的了 
代码如下

[cpp] view plain copy
  1. void LLKGameLayer::boomCallBack(cocos2d::CCObject* psend){  
  2.         LLKmapLayer* lLKmapLayer=(LLKmapLayer*) this->getChildByTag(1);  
  3.         CCArray* llkarry= lLKmapLayer->getllkArray();  
  4.         CCArray* temparry=CCArray::create();  
  5.         for(int i=0;i<llkarry->count();i++){  
  6.                 CustomSprite* custom=(CustomSprite*)llkarry->objectAtIndex(i);  
  7.                 if (custom->getIsEliminate()==false){  
  8.                         temparry->addObject(custom);          
  9.                 }          
  10.         }  
  11.         if(temparry->count()>=2){  
  12.                 CustomSprite* custom=(CustomSprite*)temparry->randomObject();  
  13.                 CustomSprite* temp=NULL;  
  14.                 for(int i=0;i<temparry->count();i++){  
  15.                  temp=(CustomSprite*)temparry->objectAtIndex(i);  
  16.                   if(custom!=temp){  
  17.                           if(custom->getIndex()==temp->getIndex()){  
  18.                  break;  
  19.                           }  
  20.                   }  
  21.                 }  
  22.                 if(temp!=NULL){  
  23.                         temp->displayHitPic(3);  
  24.                 }  
  25.                 custom->displayHitPic(3);  
  26.         }  
  27.           
  28.   
  29.   
  30. }  

就是找到两张一样的图片然后让他们呢消失， 哈哈是不是很简单。

第三个也就是重新排序 
这个算法稍微复杂一点不过经过BOY 的手 哪里还有那么的难 废话不多说上代码

[cpp] view plain copy
  1. void LLKGameLayer::restCallBack(cocos2d::CCObject* psed){  
  2.         // 处理方式 取出现在所有的 没有被消除的 元素  
  3.         LLKmapLayer* lLKmapLayer=(LLKmapLayer*) this->getChildByTag(1);  
  4.         CCArray* llkarry= lLKmapLayer->getllkArray();  
  5.         CCArray* temparry=CCArray::create();  
  6.         for(int i=0;i<llkarry->count();i++){  
  7.                 CustomSprite* custom=(CustomSprite*)llkarry->objectAtIndex(i);  
  8.                 if (custom->getIsEliminate()==false){  
  9.                         custom->displayHitPic(2);  
  10.                         temparry->addObject(custom);          
  11.                 }          
  12.         }  
  13.         // 把剩下的元素 取出前半部分 然后随机抽取出来一个 和 后半部分的元素呼唤位置   这样就达到了重排的效果  
  14.         if (temparry->count()>=2){  
  15.          int ban=temparry->count()/2;  
  16.          CCArray* banarr=CCArray::create();  
  17.          for(int i=0;i<ban;i++){  
  18.                  banarr->addObject(temparry->objectAtIndex(i));  
  19.          }  
  20.          int temnum=0;  
  21.          for(int j=0;j<banarr->count();j++){           
  22.          CustomSprite* custom=(CustomSprite*)banarr->randomObject();  
  23.          banarr->removeObject(custom,false);  
  24.          j--;  
  25.          CustomSprite* custom2=(CustomSprite*) temparry->objectAtIndex(temnum+ban);  
  26.          CCPoint ccptem=custom->getPosition();  
  27.          int x=custom->getX();  
  28.          int y=custom->getY();  
  29.          custom->setPosition(custom2->getPosition());  
  30.          custom->setX(custom2->getX());  
  31.          custom->setY(custom2->getY());  
  32.          custom2->setPosition(ccptem);  
  33.          custom2->setX(x);  
  34.          custom2->setY(y);  
  35.          temnum++;  
  36.          }  
  37.   
  38.           
  39.         }  
  40.   
  41.   
  42.   
  43. }  

这个算法的思路是这样 把剩下的图片 分成两分，然后拿着第一份随机抽取里面的图片和后面的元素兑换剩下的那半分兑换，坐标 这样就实现了重新刷新，哈哈是不是很简单，其实做了连连看的这个算法的东西BOY 我深深的迷恋上算法，以后我的教程中会对游戏中常用的算法进行讲解。 以最通俗明了的办法给大家讲解关于算法的东西。

    以上到此我们连连看的大部分就整理完了，大家可以把这个稍微改一下就可以做个自己的APP了。大家有疑问的可以加下面的这个群，或者在我的博客给我留言。我会给大家讲解的。

相关推荐