Stage.h

  1. #ifdef WIN32
  2. #pragma execution_character_set("utf-8")
  3. #ifndef __STAGE_SCENE_H__
  4. #define __STAGE_SCENE_H__
  6. #include "ui\CocosGUI.h"
  7. #include "cocos2d.h"
  8. #include "cocos-ext.h"
  9. #include "SimpleAudioEngine.h"
  10. #include <iostream>
  11. #include <algorithm>
  12. #include "Block.h"
  13. using namespace std;
  14. using namespace CocosDenshion;
  15. USING_NS_CC_EXT;
  16. USING_NS_CC;
  18. class Stage : public cocos2d::Layer
  19. {
  21. public:
  22.     int m = 7, n = 8;//七行八列
  23.     //typedef struct Sits
  24.     //{
  25.     //    int value;
  26.     //    int x;
  27.     //    int y;
  28.     //}Sits;
  29.     int offSet = 70;
  30.     int swapx1, swapx2, swapy1, swapy2;
  31.     virtual bool init();
  32.     static int tag[9][20]; //辅助标记每一个方块的tag
  33.     Block* blocks[9][20]; //保存有对应的方块
  34.     bool ifReSwap = true; //是否要再换回来
  35.     bool isSwapping = false; //是否正在发生交换动画
  36.     bool ifSelected = false; //是否已经选中
  37.     Block* firstSelectedBlock; //第一个选中的方块
  38.     Block* secondSelectedBlock; //第二个选中的方块
  39.     int x1, y1;    //用于判断第一个触摸的点
  40.     int x2, y2; //用于判断第二个触摸的点
  41.     //得分情况
  42.     static int score;
  43.     //时间限制
  44.     static int Bartime;
  47.     void initBlocks();  //初始化所有方块
  48.     bool initJudge(int index, int i, int j);//初始化判断，存在三连是返回true，不存在时返回false
  49.     bool blockMarks(int blockClasses, int i, int j); //用于判断该方块周围有没有三连，并标记，有返回true，没有返回false
  50.     bool blocksEraseJudge();//对整张图进行判断，是否存在能被消除的方块，存在标记并返回true，不存在返回false
  51.     void selectFirst(int i, int j);
  52.     void setSelectedBlock(Block* block,int index, bool flag); //设置第几个方块是否被选中
  53.     void removeSelectFirst(int i, int j);
  54.     //void swap(int x1, int y1, int x2, int y2);
  55.     bool swapBlocks(int x1, int y1, int x2, int y2);  //返回值为，交换后有可以消除的，返回true，没有可以消除的返回false
  56.     bool moveDownBlocks(); //将现有的方块落下补充空白
  57.     void initNewBlocks(); //补充新的方块
  58.     void initBlockFromPoint(int x, int y);//随机在某一个点生成一个方块
  59.     void updateInfo(int cnt); //更新游戏分数以及时间，传入参数为一次消除的方块数
  60.     bool removeBlocks(); //移除方块，返回值为true，若没有任何可以移除的方块，返回false
  64.     CREATE_FUNC(Stage);
  65. };
  67. #endif // __STAGE_SCENE_H__
  68. #endif

Stage.cpp

  1. #pragma once
  2. #if defined(_MSC_VER) && (_MSC_VER>=1900)
  3. #pragma execution_character_set("utf-8")
  6. #include "Stage.h"
  8. using namespace std;
  9. USING_NS_CC;
  11. int Stage::tag[9][20] = { 0 };//初始化
  12. int Stage::score = 0;
  13. int Stage::Bartime = 1800;
  15. static void problemLoading(const char* filename)
  16. {
  17.     printf("Error while loading: %s\n", filename);
  18.     printf("Depending on how you compiled you might have to add 'Resources/' in front of filenames in HardLevel.cpp\n");
  19. }
  21. bool Stage::init(){
  22.     if (!Layer::init()){
  23.         return false;
  24.     }
  25.     srand(unsigned int(time(0)));//利用时间做种子，让随机数更多，每次开始的场景不同；
  27.     auto visibleSize = Director::getInstance()->getVisibleSize();
  28.     Vec2 origin = Director::getInstance()->getVisibleOrigin();
  30.     initBlocks();
  32.     return true;
  33. }
  36. void Stage::updateInfo(int cnt) {
  37.     int scoreMultiple = 1;
  38.     int score = 10;
  39.     switch (cnt) {
  40.     case 3:
  41.         scoreMultiple = 1; score = 10; break;
  42.     case 4:
  43.     case 5:
  44.     case 6:
  45.         scoreMultiple = 2; score = 15; break;
  46.     default:
  47.         scoreMultiple = 3; score = 30; break;
  48.     }
  49.     this->score += score * scoreMultiple * cnt;
  50.     if(this->Bartime + cnt * scoreMultiple * 5 <= 1800)
  51.         this->Bartime += cnt*scoreMultiple * 5;
  52. }
  54. void Stage::selectFirst(int i, int j) {
  55.     blocks[i][j]->setOpacity(80);
  56. }
  57. void Stage::removeSelectFirst(int i, int j) {
  58.     blocks[i][j]->setOpacity(255);
  59. }
  61. bool Stage::swapBlocks(int x1, int y1, int x2, int y2) {
  62.     isSwapping = true; //表示正在发生交换
  63.     if (tag[x1][y1] < 0 || tag[x2][y2] < 0)
  64.         return true;
  65.     //支持任意两点的交换，可以方便后期补充各种用户自定义的道具
  66.     //log("准备交换（%d,%d）<->（%d,%d）", x1, y1, x2, y2);
  68.     //释放选中状态
  69.     blocks[x1][y1]->setSelected(false);
  70.     blocks[x2][y2]->setSelected(false);
  71.     blocks[x1][y1]->moveByOffset(x2,y2);
  72.     blocks[x2][y2]->moveByOffset(x1, y1);
  73.     std::swap(blocks[x1][y1], blocks[x2][y2]);
  74.     std::swap(tag[x1][y1], tag[x2][y2]);
  76.     //交换后判断是否可以消除
  77.     if (blocksEraseJudge()) {
  78.         return true;
  79.     }
  80.     else {
  81.         this->x1 = x1;
  82.         this->y1 = y1;
  83.         this->x2 = x2;
  84.         this->y2 = y2;
  85.         return false;
  86.     }
  87. }
  91. //创建默认的方块布局
  92. void Stage::initBlocks() {
  93.     int index = 0;
  94.     for (int i = 1; i <= n; i++) {
  95.         for (int j = 1; j <= m; j++) {
  96.             if (tag[i][j] == -1) //-1表示此处不能布置方块，包括边界或可以用于自己设置的固定空洞
  97.                 continue;
  98.             tag[i][j] = rand() % 5 + 1;
  99.             if (initJudge(tag[i][j], i, j)) { //判断当前的tag放入后，能否满足不会自动消去，不满足的话，回退，重新随机
  100.                 j--;
  101.                 continue;
  102.             }
  103.             switch (tag[i][j]){
  104.             case 1:
  105.                 blocks[i][j] = Block::create("item1.png", tag[i][j], i, j); break;
  106.             case 2:
  107.                 blocks[i][j] = Block::create("item2.png", tag[i][j], i, j); break;
  108.             case 3:
  109.                 blocks[i][j] = Block::create("item3.png", tag[i][j], i, j); break;
  110.             case 4:
  111.                 blocks[i][j] = Block::create("item4.png", tag[i][j], i, j); break;
  112.             case 5:
  113.                 blocks[i][j] = Block::create("item5.png", tag[i][j], i, j); break;
  114.             default:
  115.                 break;
  116.             }
  117.             //排列各个方块
  118.             blocks[i][j]->setPosition(offSet*i, offSet*j);
  119.             //blocks[i][j]->setPosition(offSet*i - 40, offSet*j + 150);
  120.             this->addChild(blocks[i][j], 1);
  121.         }
  122.     }
  123. }
  124. //防止创建就是三连的
  125. bool Stage::initJudge(int index, int i, int j) {
  126.     int ux1 = i - 1, uy1 = j, ux2 = i - 2, uy2 = j;
  127.     int dx1 = i + 1, dy1 = j, dx2 = i + 2, dy2 = j;
  128.     int lx1 = i, ly1 = j - 1, lx2 = i, ly2 = j - 2;
  129.     int rx1 = i, ry1 = j + 1, rx2 = i, ry2 = j + 2;
  130.     if (ux2 > 0 && (tag[i][j] == tag[ux1][uy1]) && (tag[i][j] == tag[ux2][uy2]))
  131.         return true;
  132.     if (dx2 <= m && (tag[i][j] == tag[dx1][dy1]) && (tag[i][j] == tag[dx2][dy2]))
  133.         return true;
  134.     if (lx2 >0 && (tag[i][j] == tag[lx1][ly1]) && (tag[i][j] == tag[lx2][ly2]))
  135.         return true;
  136.     if (rx2 <= n && (tag[i][j] == tag[rx1][ry1]) && (tag[i][j] == tag[rx2][ry2]))
  137.         return true;
  138.     return false;
  139. }
  141. //三连判断，只要保证都不满足三连情况，那么不满足四连也可以保证，所以不需要遍历整个图
  142. bool Stage::blockMarks(int blockClasses, int i, int j) {
  143.     bool flag = false;
  144.     int upX = i, upY = j + 1; //上方第一个点
  145.     int downX = i, downY = j - 1; //下方第一个点
  146.     int leftX = i - 1, leftY = j; //左边第一个点
  147.     int rightX = i + 1, rightY = j; //右边第一个点
  148.     //首先判断一横行有无三个
  149.     if (leftX > 0 && rightX <= n && (blockClasses == tag[leftX][leftY]) && (blockClasses == tag[rightX][rightY])) {
  150.         blocks[leftX][leftY]->setDoesErase(true);
  151.         blocks[i][j]->setDoesErase(true);
  152.         blocks[rightX][rightY]->setDoesErase(true);
  153.         log("当前被打上表示的为（%d,%d)", leftX, leftY);
  154.         log("当前被打上表示的为（%d,%d)", i, j);
  155.         log("当前被打上表示的为（%d,%d)", rightX, rightY);
  156.         flag = true;
  157.     }
  158.     //再判断一竖列的三个
  159.     if (downY > 0 && upY <= m && (blockClasses == tag[upX][upY]) && (blockClasses == tag[downX][downY])) {
  160.         blocks[upX][upY]->setDoesErase(true);
  161.         blocks[i][j]->setDoesErase(true);
  162.         blocks[downX][downY]->setDoesErase(true);
  163.         log("当前被打上表示的为（%d,%d)", upX, upY);
  164.         log("当前被打上表示的为（%d,%d)", i, j);
  165.         log("当前被打上表示的为（%d,%d)", downX, downY);
  166.         flag = true;
  167.     }
  168.     return flag;
  169. }
  171. //用于判断当前是否有能消除的方块，有则打上标记并返回true，否则返回false
  172. bool Stage::blocksEraseJudge() {
  173.     bool flag = false;
  174.     for (int i = 1; i <= n; i++) 
  175.         for (int j = 1; j <= m; j++) 
  176.             if (blockMarks(blocks[i][j]->getClasses(), i, j)) {
  177.                 //log("当前被打上表示的为（%d,%d)", i, j);
  178.                 flag = true;
  179.             }
  180.     return flag;
  181. }
  183. bool Stage::removeBlocks() {
  184.     bool flag = false;
  185.     int cnt = 0;
  186.     for (int i = 1; i <= n; i++) 
  187.         for (int j = 1; j <= m; j++) 
  188.             if (blocks[i][j]->getDoesErase()) {
  189.                 blocks[i][j]->blastAnimation();
  190.                 tag[i][j] = 0;
  191.                 cnt++;
  192.                 flag = true;
  193.             }
  194.     updateInfo(cnt);
  195.     return flag;
  196. }
  198. void Stage::setSelectedBlock(Block* block,int index, bool flag){
  199.     if(block!=nullptr)
  200.         block->setSelected(flag);
  201.     else return;
  202.     if (index == 1) {
  203.         this->firstSelectedBlock = block;
  204.     }
  205.     else if (index == 2) {
  206.         this->secondSelectedBlock = block;
  207.     }
  209. }
  212. //创建新的方块
  213. bool Stage::moveDownBlocks() {
  214.     bool flag = false; //如果交换后仍能消除，返回true
  215.     for (int i = 1; i <= n; i++) { //遍历从第一列开始
  216.         for (int j = 1; j <= 2*m; j++) { //从每一行的最底部开始，如果遇到空的，继续向这一行的上方遍历
  217.             if (tag[i][j] == 0) { //如果遇到空的位置
  218.                 log("开始落下未消除方块");
  219.                 int k = j + 1;
  220.                 for (; k <= 2*m; k++) //那么寻找这一列上方第一个不为空的方块，落下来
  221.                     if (tag[i][k] > 0)
  222.                         break;
  223.                 log("当前k值为：%d", k);
  224.                 if (k > 2*m || tag[i][k] <= 0)
  225.                     continue;
  226.                 if (k <= 2*m) { //说明这一列的空缺处上方，还有没落下的方块
  227.                     if (swapBlocks(i, k, i, j)) { //交换一个空缺和方块，继续遍历
  228.                         flag = true;
  229.                     }
  230.                 }
  231.             }
  232.         }
  233.     }
  234.     return flag;
  235. }
  237. void Stage::initNewBlocks() {
  238.     for (int i = 1; i <= n;i++){
  239.         int cnt = 0; //有多少个空，就在上方生成多少个
  240.         for (int j = 1; j <= m; j++)
  241.             if (tag[i][j] == 0)
  242.                 cnt++;
  243.         while (cnt--)
  244.             initBlockFromPoint(i, m + cnt+1);
  245.     }
  246. }
  248. void Stage::initBlockFromPoint(int x, int y) {
  249.     tag[x][y] = rand() % 5 + 1;
  250.     switch (tag[x][y])
  251.     {
  252.     case 1:
  253.         blocks[x][y] = Block::create("item1.png", tag[x][y], x, y); break;
  254.     case 2:
  255.         blocks[x][y] = Block::create("item2.png", tag[x][y], x, y); break;
  256.     case 3:
  257.         blocks[x][y] = Block::create("item3.png", tag[x][y], x, y); break;
  258.     case 4:
  259.         blocks[x][y] = Block::create("item4.png", tag[x][y], x, y); break;
  260.     case 5:
  261.         blocks[x][y] = Block::create("item5.png", tag[x][y], x, y); break;
  262.     default:
  263.         break;
  264.     }
  266.     blocks[x][y]->setPosition(offSet*x, offSet*y);
  267.     //blocks[i][j]->setPosition(offSet*i - 40, offSet*j + 150);
  268.     this->addChild(blocks[x][y], 1);
  269. }
  272. #endif