Cocos2d-x 3.x版2048游戏开发

时间  2021-01-04
栏目 Cocos2d-x 繁體版
原文   原文链接

https://blog.csdn.net/wwj_748/article/details/38168649

本篇博客给大家介绍如何快速开发2048这样一款休闲游戏，理解整个2048游戏的开发流程，从本篇博客你将可以学习到以下内容：

这里注明一下，本教程来自极客学院，小巫对其中代码进行了解释。

  • 2048游戏的逻辑
  • Cocos2d-x中上下左右手势的识别
  • 游戏中卡片类的创建
  • 添加卡片到游戏中
  • 游戏中的逻辑实现
  • 游戏中随机卡片的生成
  • 游戏结束判断
  • 游戏分数的添加
  • 游戏美化
笔者的开发环境：
Cocos2d-x 3.1.1（开发引擎）
Visual Studio 2012（Win32）
Xcode 5.1（Mac系统下）

理解2048游戏逻辑

2048游戏逻辑并不复杂，4*4的卡片布局，玩家通过手势上下左右滑动来累加卡片数值，直到累加到2048。笔者用一张图说明：
这是一张游戏中的图，在图中同一方向并且数值相同的卡片可以进行叠加，比如128和128在同一行，玩家可以通过向左或向右的手势，对其进行叠加。笔者向右滑动手势，则会变成以下效果：


Cocos2d-x中上下左右手势的识别

玩家在玩2048游戏时，手势是最频繁的操作，所以我们需要对手势所产生的事件进行监听。
在HelloWorldScene.h头文件中声明两个需要实现的监听事件：
[objc]  view plain  copy
  1. // 加入手势识别的事件  
  2.     virtual bool onTouchBegan(cocos2d::Touch *touch, cocos2d::Event *unused_event);  
  3.     virtual void onTouchEnded(cocos2d::Touch *touch, cocos2d::Event *unused_event);  

声明点击的位置属性
[cpp]  view plain  copy
  1. // 点击的元素位置  
  2.     int firstX, firstY, endX, endY;  


一个是触摸开始的事件，一个是触摸结束的事件。
然后再HelloWorldScene.cpp文件中实现这两个方法：
[objc]  view plain  copy
  1. // 加入手势识别的事件  
  2. bool HelloWorld::onTouchBegan(cocos2d::Touch *touch, cocos2d::Event *unused_event){  
  3.     // 触摸点  
  4.     Point touchP0 = touch->getLocation();  
  5.   
  6.     firstX = touchP0.x;  
  7.     firstY = touchP0.y;  
  8.   
  9.   
  10.     return true;  
  11. }  
  12.   
  13. // 触摸结束触发  
  14. void HelloWorld::onTouchEnded(cocos2d::Touch *touch, cocos2d::Event *unused_event){  
  15.     // 获取触摸点位置  
  16.     Point touchP0 = touch->getLocation();  
  17.     // 获取X轴和Y轴的移动距离  
  18.     endX = firstX - touchP0.x;  
  19.     endY = firstY - touchP0.y;  
  20.   
  21.     // 判断X轴和Y轴的移动距离，如果X轴的绝对值大于Y轴的绝对值就是左右否则是上下  
  22.     if (abs(endX) > abs(endY)){  
  23.         // 左右  
  24.         if (endX + 5 > 0) {  
  25.             // 左边  
  26.             if(doLeft()) {  
  27.                 autoCreateCardNumber();  
  28.                 doCheckGameOver();  
  29.             }  
  30.   
  31.         } else {  
  32.             // 右边  
  33.             if(doRight()){  
  34.                 autoCreateCardNumber();  
  35.                 doCheckGameOver();  
  36.             }  
  37.         }  
  38.   
  39.     } else {  
  40.         // 上下  
  41.         if (endY + 5 > 0) {  
  42.             // 下边  
  43.             if(doDown()) {  
  44.                 autoCreateCardNumber();  
  45.                 doCheckGameOver();  
  46.             }  
  47.         } else {  
  48.             // 上边  
  49.             if(doUp()) {  
  50.                 autoCreateCardNumber();  
  51.                 doCheckGameOver();  
  52.             };  
  53.         }  
  54.   
  55.     }  
  56. }  

在HelloWorld的init方法中设置监听器的这两个方法的监听回调：
[objc]  view plain  copy
  1. // 创建手势识别的事件监听器  
  2. auto touchListener = EventListenerTouchOneByOne::create();  
  3. touchListener->onTouchBegan = CC_CALLBACK_2(HelloWorld::onTouchBegan, this);  
  4. touchListener->onTouchEnded = CC_CALLBACK_2(HelloWorld::onTouchEnded, this);  
  5.    // 添加事件监听  
  6. _eventDispatcher->addEventListenerWithSceneGraphPriority(touchListener, this);  

上面中根据计算开始位置到结束位置X轴和Y轴的移动距离来判断是向左、向右、向上还是向下的方向：
在头文件中声明四个方向的方法：
[objc]  view plain  copy
  1. // 上下左右的方法  
  2.     bool doLeft();  
  3.     bool doRight();  
  4.     bool doUp();  
  5.     bool doDown();  

然后对其进行实现。这四个方法的逻辑实现放到后面进行讲解。



游戏中卡片类的创建

卡片类是组成2048游戏的基础，4*4的方格的16个位置放置不同的卡片，每个位置为独立的一张卡片。

创建CardSprite.h的头文件：
[objc]  view plain  copy
  1. //  
  2. //  CardSprite.h  
  3. //  2048Game  
  4. //  
  5. //  Created by mac on 14-7-16.  
  6. //  
  7. //  
  8.   
  9. #ifndef ___048Game__CardSprite__  
  10. #define ___048Game__CardSprite__  
  11.   
  12. #include "cocos2d.h"  
  13.   
  14. class CardSprite:public cocos2d::Sprite {  
  15.       
  16. public:  
  17.     // 初始化游戏卡片的方法  
  18.     static CardSprite *createCardSprite(int numbers, int width, int height, float CardSpriteX, float CardSpriteY);  
  19.     virtual bool init();  
  20.     CREATE_FUNC(CardSprite);  
  21.       
  22.     // 设置数字  
  23.     void setNumber(int num);  
  24.       
  25.     // 获取数字  
  26.     int getNumber();  
  27. private:  
  28.     // 显示在界面的数字  
  29.     int number;  
  30.     void enemyInit(int numbers, int width, int height, float CardSpriteX, float CardSpriteY);  
  31.       
  32.     // 定义显示数字的控件  
  33.     cocos2d::LabelTTF *labTTFCardNumber;  
  34.       
  35.     // 显示的背景  
  36.     cocos2d::LayerColor *layerColorBG;  
  37.       
  38.       
  39. };  
  40.   
  41. #endif /* defined(___048Game__CardSprite__) */  

我们可以从游戏中看到，每张卡片有背景颜色和一个数字，所以我们在头文件需要声明它这两个属性。


CardSprite.cpp中对头文件方法的实现：
[cpp]  view plain  copy
  1. //  
  2. //  CardSprite.cpp  
  3. //  2048Game  
  4. //  
  5. //  Created by wwj on 14-7-16.  
  6. //  
  7. //  
  8.   
  9. #include "CardSprite.h"  
  10.   
  11. USING_NS_CC;  
  12.   
  13. // 初始化游戏卡片的方法  
  14. CardSprite* CardSprite::createCardSprite(int numbers, int width, int height, float CardSpriteX, float CardSpriteY) {  
  15.     // new一个卡片精灵  
  16.     CardSprite *enemy = new CardSprite();  
  17.     if (enemy && enemy->init()) {  
  18.         enemy->autorelease();  
  19.         enemy->enemyInit(numbers, width, height, CardSpriteX, CardSpriteY);  
  20.         return enemy;  
  21.     }  
  22.     CC_SAFE_DELETE(enemy);  
  23.     return NULL;  
  24. }  
  25.   
  26. // 卡片初始化方法  
  27. bool CardSprite::init() {  
  28.     if (!Sprite::init()) {  
  29.         return false;  
  30.     }  
  31.     return true;  
  32. }  
  33.   
  34.   
  35. // 设置数字  
  36. void CardSprite::setNumber(int num) {  
  37.     number = num;  
  38.       
  39.     // 判断数字的大小来调整字体的大小  
  40.     if (number >= 0) {  
  41.         labTTFCardNumber->setFontSize(80);  
  42.     }  
  43.     if (number >= 16) {  
  44.         labTTFCardNumber->setFontSize(60);  
  45.     }  
  46.     if (number >= 128) {  
  47.         labTTFCardNumber->setFontSize(40);  
  48.     }  
  49.     if (number >= 1024) {  
  50.         labTTFCardNumber->setFontSize(20);  
  51.     }  
  52.       
  53.     // 判断数组的大小调整颜色  
  54.     if (number == 0) {  
  55.         layerColorBG->setColor(cocos2d::Color3B(200, 190, 180));  
  56.     }  
  57.     if (number == 2) {  
  58.         layerColorBG->setColor(cocos2d::Color3B(240, 230, 220));  
  59.     }  
  60.     if (number == 4) {  
  61.         layerColorBG->setColor(cocos2d::Color3B(240, 220, 200));  
  62.     }  
  63.     if (number == 8) {  
  64.         layerColorBG->setColor(cocos2d::Color3B(240, 180, 120));  
  65.     }  
  66.     if (number == 16) {  
  67.         layerColorBG->setColor(cocos2d::Color3B(240, 140, 90));  
  68.     }  
  69.     if (number == 32) {  
  70.         layerColorBG->setColor(cocos2d::Color3B(240, 120, 90));  
  71.     }  
  72.     if (number == 64) {  
  73.         layerColorBG->setColor(cocos2d::Color3B(240, 90, 60));  
  74.     }  
  75.     if (number == 128) {  
  76.         layerColorBG->setColor(cocos2d::Color3B(240, 90, 60));  
  77.     }  
  78.     if (number == 256) {  
  79.         layerColorBG->setColor(cocos2d::Color3B(240, 200, 70));  
  80.     }  
  81.     if (number == 512) {  
  82.         layerColorBG->setColor(cocos2d::Color3B(240, 200, 70));  
  83.     }  
  84.     if (number == 1024) {  
  85.         layerColorBG->setColor(cocos2d::Color3B(0, 130, 0));  
  86.     }  
  87.     if (number == 2048) {  
  88.         layerColorBG->setColor(cocos2d::Color3B(0, 130, 0));  
  89.     }  
  90.       
  91.       
  92.     // 更新显示的数字  
  93.     if (number > 0) {  
  94.         labTTFCardNumber->setString(__String::createWithFormat("%i", num)->getCString() );  
  95.     } else {  
  96.         labTTFCardNumber->setString("");  
  97.     }  
  98.       
  99. }  
  100.   
  101. // 获取数字  
  102. int CardSprite::getNumber() {  
  103.     return number;  
  104. }  
  105.   
  106.   
  107. //第1个参数为数字，第2、3个参数为卡片的宽高，第4、5个参数为卡片的位置  
  108. void CardSprite::enemyInit(int numbers, int width, int height, float CardSpriteX, float CardSpriteY) {  
  109.     // 初始化数字  
  110.     number = numbers;  
  111.       
  112.     // 加入游戏卡片的背景颜色  
  113.     layerColorBG = cocos2d::LayerColor::create(cocos2d::Color4B(200, 190, 180, 255), width - 15, height - 15);  
  114.     layerColorBG->setPosition(Point(CardSpriteX, CardSpriteY));  
  115.       
  116.     // 判断如果不等于0就显示，否则为空  
  117.     if (number > 0) {  
  118.         // 加入中间字体  
  119.         labTTFCardNumber = cocos2d::LabelTTF::create(__String::createWithFormat("%i", number)->getCString(), "HirakakuProN-W6", 100);  
  120.         // 显示卡片数字的位置，这里显示在背景的中间  
  121.         labTTFCardNumber->setPosition(Point(layerColorBG->getContentSize().width/2, layerColorBG->getContentSize().height/2));  
  122.         // 添加卡片数字到背景中  
  123.         layerColorBG->addChild(labTTFCardNumber);  
  124.     } else {  
  125.         // 加入中间字体  
  126.         labTTFCardNumber = cocos2d::LabelTTF::create("", "HirakakuProN-w6", 80);  
  127.         labTTFCardNumber->setPosition(Point(layerColorBG->getContentSize().width/2, layerColorBG->getContentSize().height/2));  
  128.         layerColorBG->addChild(labTTFCardNumber);  
  129.     }  
  130.     // 将卡片添加到层  
  131.     this->addChild(layerColorBG);  
  132.       
  133. }  

每张卡片都有相同的宽和高，但数字和位置不同，数字是显示在背景中间的，所以我们需要5个参数来初始化卡片的位置。


添加卡片到游戏中

卡片放置在4*4方框中的不同位置，首先我们需要计算出每张卡片的宽高，然后计算每张卡片所在的位置，最后进行显示。
在HelloWorldScene.h头文件中声明创建卡片的方法：
[cpp]  view plain  copy
  1. // 创建卡片  
  2. void createCardSprite(cocos2d::Size size);  

在HelloWorldScene.cpp中实现该方法：
[cpp]  view plain  copy
  1. // 创建卡片，size为屏幕大小  
  2. void HelloWorld::createCardSprite(cocos2d::Size size) {  
  3.     // 求出单元格的宽度和高度，28为左右距离  
  4.     int lon = (size.width - 28) / 4;  
  5.       
  6.     // 4*4的单元格  
  7.     for (int j = 0; j < 4; j++) {  
  8.         for (int i = 0; i < 4; i++) {  
  9.             // 数字0，宽高相同为lon,lon+j+20为卡片X轴位置，如lon+0+20为第一个卡片的位置，20是每张卡片的间隙，lon+i+20+size.height/6代表的意思是屏幕大小竖方向分了六份，我们这里只放4个位置  
  10.            CardSprite *card = CardSprite::createCardSprite(0, lon, lon, lon * j + 10, lon * i + 10 + size.height / 6);  
  11.             addChild(card);  
  12.               
  13.             // 添加卡片到二维数组中  
  14.             cardArr[j][i] = card;  
  15.         }  
  16.     }  
  17. }  

笔者对每张卡片显示的位置在代码中进行了说明，读者也可以思考一下为什么要这么做。

游戏中的逻辑实现

2048游戏最重要的部分就是四个方向的逻辑实现，也是开发这个游戏的难点所在。
[cpp]  view plain  copy
  1. // 向左  
  2. bool HelloWorld::doLeft(){  
  3.     log("doLeft");  
  4.       
  5.     bool isdo = false;  
  6.     // 最外层循环为4*4迭代  
  7.     for (int y = 0; y < 4; y++) {  
  8.         for (int x = 0; x < 4; x++) {  
  9.               
  10.             // 这一层循环为判断卡片是合并还是清空  
  11.             for (int x1 = x + 1; x1 < 4; x1++) {  
  12.                 if (cardArr[x1][y]->getNumber() > 0) {// 有数字  
  13.                     if (cardArr[x][y]->getNumber() <= 0) { // 为空  
  14.                         // 设置为右边卡片的数值  
  15.                         cardArr[x][y]->setNumber(cardArr[x1][y]->getNumber());  
  16.                         cardArr[x1][y]->setNumber(0);  
  17.                           
  18.                         x--;  
  19.                         isdo = true;  
  20.                           
  21.                     } else if(cardArr[x][y]->getNumber() == cardArr[x1][y]->getNumber()) {  
  22.                         // 当前卡片的值与其比较卡片的值相等，设置为其的2倍  
  23.                         cardArr[x][y]->setNumber(cardArr[x][y]->getNumber()*2);  
  24.                         cardArr[x1][y]->setNumber(0);  
  25.                           
  26.                           
  27.                         // 设置分数  
  28.                         score += cardArr[x][y]->getNumber();  
  29.                         labelTTFCardNumber->setString(__String::createWithFormat("%i", score)->getCString());  
  30.                         isdo = true;  
  31.                     }  
  32.                     break;// 跳出  
  33.                 }  
  34.             }  
  35.         }  
  36.     }  
  37.       
  38.     return isdo;  
  39. }  
  40.   
  41. // 向右  
  42. bool HelloWorld::doRight(){  
  43.     log("doRight");  
  44.       
  45.     bool isdo = false;  
  46.     // 最外层循环为4*4迭代  
  47.     for (int y = 0; y < 4; y++) {  
  48.         for (int x = 3; x >= 0; x--) {  
  49.               
  50.             // 循环判断左边卡片往右是合并还是清空  
  51.             for (int x1 = x - 1; x1 >= 0; x1-- ) {  
  52.                 if (cardArr[x1][y]->getNumber() > 0) {  
  53.                     if (cardArr[x][y]->getNumber() <= 0) {  
  54.                         cardArr[x][y]->setNumber(cardArr[x1][y]->getNumber());  
  55.                           
  56.                         x++;  
  57.                         isdo = true;  
  58.                     }  
  59.                     else if (cardArr[x][y]->getNumber() == cardArr[x1][y]->getNumber()) {  
  60.                         cardArr[x][y]->setNumber(cardArr[x][y]->getNumber() * 2);  
  61.                         cardArr[x1][y]->setNumber(0);  
  62.                           
  63.                         // 设置分数  
  64.                         score += cardArr[x][y]->getNumber();  
  65.                         labelTTFCardNumber->setString(__String::createWithFormat("%i", score)->getCString());  
  66.   
  67.                         isdo = true;  
  68.                     }  
  69.                     break;  
  70.                 }  
  71.   
  72.             }  
  73.         }  
  74.           
  75.     }  
  76.       
  77.     return isdo;  
  78.   
  79. }  
  80.   
  81. // 向上  
  82. bool HelloWorld::doUp(){  
  83.     log("doUp");  
  84.     bool isdo = false;  
  85.     // 最外层循环为4*4迭代  
  86.     for (int x = 0; x < 4; x++) {  
  87.         for (int y = 3; y >= 0; y--) {  
  88.               
  89.             // 这一层循环为判断卡片是合并还是清空  
  90.             for (int y1 = y - 1; y1 >= 0; y1--) {  
  91.                 if (cardArr[x][y1]->getNumber() > 0) {// 有数字  
  92.                     if (cardArr[x][y]->getNumber() <= 0) { // 为空  
  93.                         // 设置为右边卡片的数值  
  94.                         cardArr[x][y]->setNumber(cardArr[x][y1]->getNumber());  
  95.                         cardArr[x][y1]->setNumber(0);  
  96.                           
  97.                         y++;  
  98.                         isdo = true;  
  99.                           
  100.                     } else if(cardArr[x][y]->getNumber() == cardArr[x][y1]->getNumber()) {  
  101.                         // 当前卡片的值与其比较卡片的值相等，设置为其的2倍  
  102.                         cardArr[x][y]->setNumber(cardArr[x][y]->getNumber()*2);  
  103.                         cardArr[x][y1]->setNumber(0);  
  104.                           
  105.                         // 设置分数  
  106.                         score += cardArr[x][y]->getNumber();  
  107.                         labelTTFCardNumber->setString(__String::createWithFormat("%i", score)->getCString());  
  108.   
  109.                         isdo = true;  
  110.                     }  
  111.                     break;// 跳出  
  112.                 }  
  113.             }  
  114.         }  
  115.     }  
  116.       
  117.     return isdo;  
  118.   
  119. }  
  120.   
  121. // 向下  
  122. bool HelloWorld::doDown(){  
  123.     log("doDown");  
  124.     bool isdo = false;  
  125.     // 最外层循环为4*4迭代  
  126.     for (int x = 0; x < 4; x++) {  
  127.         for (int y = 0; y < 4; y++) {  
  128.               
  129.             // 这一层循环为判断卡片是合并还是清空  
  130.             for (int y1 = y + 1; y1 < 4; y1++) {  
  131.                 if (cardArr[x][y1]->getNumber() > 0) {// 有数字  
  132.                     if (cardArr[x][y]->getNumber() <= 0) { // 为空  
  133.                         // 设置为右边卡片的数值  
  134.                         cardArr[x][y]->setNumber(cardArr[x][y1]->getNumber());  
  135.                         cardArr[x][y1]->setNumber(0);  
  136.                           
  137.                         y--;  
  138.                         isdo = true;  
  139.                           
  140.                     } else if(cardArr[x][y]->getNumber() == cardArr[x][y1]->getNumber()) {  
  141.                         // 当前卡片的值与其比较卡片的值相等，设置为其的2倍  
  142.                         cardArr[x][y]->setNumber(cardArr[x][y]->getNumber()*2);  
  143.                         cardArr[x][y1]->setNumber(0);  
  144.                           
  145.                           
  146.                         // 设置分数  
  147.                         score += cardArr[x][y]->getNumber();  
  148.                         labelTTFCardNumber->setString(__String::createWithFormat("%i", score)->getCString());  
  149.   
  150.                         isdo = true;  
  151.                     }  
  152.                     break;// 跳出  
  153.                 }  
  154.             }  
  155.         }  
  156.     }  
  157.       
  158.     return isdo;  
  159. }  


游戏中随机卡片的生成

在HelloWorldScene.h头文件中声明随机生成卡片的方法：
[cpp]  view plain  copy
  1. // 自动卡片生成  
  2. void autoCreateCardNumber();  

在HelloWorldScene.cpp实现该方法：
[cpp]  view plain  copy
  1. // 自动生成卡片  
  2. void HelloWorld::autoCreateCardNumber() {  
  3.     int i = CCRANDOM_0_1() * 4;  
  4.     int j = CCRANDOM_0_1() * 4;  
  5.       
  6.     // 判断是否已经存在的位置  
  7.     if (cardArr[i][j]->getNumber() > 0) {  
  8.         // 已存在，递归创建  
  9.         autoCreateCardNumber();  
  10.     } else {  
  11.         // 生成2和4的比例是1:9的概率  
  12.         cardArr[i][j]->setNumber(CCRANDOM_0_1() * 10 < 1 ? 4:2);  
  13.     }  
  14. }  

游戏结束判断

在HelloWorldScene.h中声明判断游戏结束的方法：
[cpp]  view plain  copy
  1. // 判断游戏是否还能继续运行下去  
  2.     void doCheckGameOver();  
在HelloWorldScene.cpp中实现该方法：
[cpp]  view plain  copy
  1. // 游戏是否还能继续运行下去  
  2. void HelloWorld::doCheckGameOver() {  
  3.     bool isGameOver = true;  
  4.       
  5.     for (int y = 0; y < 4; y++) {  
  6.         for (int x = 0; x < 4; x++) {  
  7.             if (cardArr[x][y]->getNumber() == 0  
  8.                 || (x>0 && (cardArr[x][y]->getNumber() == cardArr[x-1][y]->getNumber() ))  
  9.                 || (x<3 && (cardArr[x][y]->getNumber() == cardArr[x+1][y]->getNumber()))  
  10.                 || (y<0 && (cardArr[x][y]->getNumber() == cardArr[x][y-1]->getNumber()))  
  11.                 || (x<3 && (cardArr[x][y]->getNumber() == cardArr[x][y+1]->getNumber()))) {  
  12.                 isGameOver = false;  
  13.             }  
  14.         }  
  15.     }  
  16.     if (isGameOver) {  
  17.         // 结束游戏  
  18.         Director::getInstance()->replaceScene(TransitionFade::create(1, HelloWorld::createScene()));  
  19.     }  
  20.   
  21. }  

游戏分数的添加

2048中需要对分数进行统计并显示给玩家，我们在HelloWolrdScene.h文件中声明分数和显示分数的控件：
[cpp]  view plain  copy
  1. // 整体游戏的分数  
  2.     int score;  
  3.     // 定义显示数据的控件  
  4.     cocos2d::LabelTTF *labelTTFCardNumber;  

在HelloWorldScene.cpp中对分数初始化为0，并显示“分数”的文本：
[cpp]  view plain  copy
  1. score = 0;  
  2.    
  3.    
  4.  // 获得屏幕可视大小  
  5.  Size visibleSize = Director::getInstance()->getVisibleSize();  
  6.  // 加入游戏的背景  
  7.  auto layerColorBG = cocos2d::LayerColor::create(cocos2d::Color4B(180,170,160, 255));  
  8.  this->addChild(layerColorBG);  
  9.  // 在上方加入游戏的分数  
  10.  auto labelTTFCardNumberName = LabelTTF::create("分数:","HirakakuProN-W6", 80);  
  11.  labelTTFCardNumberName->setPosition(Point(visibleSize.width/5, visibleSize.height-100));  
  12.  addChild(labelTTFCardNumberName);  
  13.    
  14.    
  15.  labelTTFCardNumber = LabelTTF::create("0", "HirakakuProN-W6", 80);  
  16.  labelTTFCardNumber->setPosition(visibleSize.width/2+100, visibleSize.height - 100);  
  17.  addChild(labelTTFCardNumber  
  18.           );  
  19.    

关于分数的计算，在游戏中的逻辑已经实现，具体读者可以查看代码，后面笔者也会提供完整的代码。

游戏美化

2048中我们会发现不同的数字会有不同的背景，然后字体大小也会随数值的变化而变化，实现这个需要通过判断数值的大小来显示不同的颜色背景和设置不同字体大小。

这个功能的实现是在卡片类设置数值的时候实现的，代码逻辑如下：
[cpp]  view plain  copy
  1. // 设置数字  
  2. void CardSprite::setNumber(int num) {  
  3.     number = num;  
  4.       
  5.     // 判断数字的大小来调整字体的大小  
  6.     if (number >= 0) {  
  7.         labTTFCardNumber->setFontSize(80);  
  8.     }  
  9.     if (number >= 16) {  
  10.         labTTFCardNumber->setFontSize(60);  
  11.     }  
  12.     if (number >= 128) {  
  13.         labTTFCardNumber->setFontSize(40);  
  14.     }  
  15.     if (number >= 1024) {  
  16.         labTTFCardNumber->setFontSize(20);  
  17.     }  
  18.       
  19.     // 判断数组的大小调整颜色  
  20.     if (number == 0) {  
  21.         layerColorBG->setColor(cocos2d::Color3B(200, 190, 180));  
  22.     }  
  23.     if (number == 2) {  
  24.         layerColorBG->setColor(cocos2d::Color3B(240, 230, 220));  
  25.     }  
  26.     if (number == 4) {  
  27.         layerColorBG->setColor(cocos2d::Color3B(240, 220, 200));  
  28.     }  
  29.     if (number == 8) {  
  30.         layerColorBG->setColor(cocos2d::Color3B(240, 180, 120));  
  31.     }  
  32.     if (number == 16) {  
  33.         layerColorBG->setColor(cocos2d::Color3B(240, 140, 90));  
  34.     }  
  35.     if (number == 32) {  
  36.         layerColorBG->setColor(cocos2d::Color3B(240, 120, 90));  
  37.     }  
  38.     if (number == 64) {  
  39.         layerColorBG->setColor(cocos2d::Color3B(240, 90, 60));  
  40.     }  
  41.     if (number == 128) {  
  42.         layerColorBG->setColor(cocos2d::Color3B(240, 90, 60));  
  43.     }  
  44.     if (number == 256) {  
  45.         layerColorBG->setColor(cocos2d::Color3B(240, 200, 70));  
  46.     }  
  47.     if (number == 512) {  
  48.         layerColorBG->setColor(cocos2d::Color3B(240, 200, 70));  
  49.     }  
  50.     if (number == 1024) {  
  51.         layerColorBG->setColor(cocos2d::Color3B(0, 130, 0));  
  52.     }  
  53.     if (number == 2048) {  
  54.         layerColorBG->setColor(cocos2d::Color3B(0, 130, 0));  
  55.     }  
  56.       
  57.       
  58.     // 更新显示的数字  
  59.     if (number > 0) {  
  60.         labTTFCardNumber->setString(__String::createWithFormat("%i", num)->getCString() );  
  61.     } else {  
  62.         labTTFCardNumber->setString("");  
  63.     }  
  64.       
  65. }  
最后笔者给出所有代码清单：
AppDelegate.h
AppDelegate.cpp
HelloWorldScene.h
HelloWorldScene.cpp
CardSprite.h
CardSprite.cpp

>>>AppDelegate.h
[cpp]  view plain  copy
  1. #ifndef  _APP_DELEGATE_H_  
  2. #define  _APP_DELEGATE_H_  
  3.   
  4. #include "cocos2d.h"  
  5.   
  6. /** 
  7. @brief    The cocos2d Application. 
  8.  
  9. The reason for implement as private inheritance is to hide some interface call by Director. 
  10. */  
  11. class  AppDelegate : private cocos2d::Application  
  12. {  
  13. public:  
  14.     AppDelegate();  
  15.     virtual ~AppDelegate();  
  16.   
  17.     /** 
  18.     @brief    Implement Director and Scene init code here. 
  19.     @return true    Initialize success, app continue. 
  20.     @return false   Initialize failed, app terminate. 
  21.     */  
  22.     virtual bool applicationDidFinishLaunching();  
  23.     */  
  24.     virtual bool applicationDidFinishLaunching();  
  25.   
  26.     /** 
  27.     @brief  The function be called when the application enter background 
  28.     @param  the pointer of the application 
  29.     */  
  30.     virtual void applicationDidEnterBackground();  
  31.   
  32.     /** 
  33.     @brief  The function be called when the application enter foreground 
  34.     @param  the pointer of the application 
  35.     */  
  36.     virtual void applicationWillEnterForeground();  
  37. };  
  38.   
  39. #endif // _APP_DELEGATE_H_
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程