Cocos2d-x 3.2制作三消游戏《万圣大作战》2：精灵的检测与消除

在完成游戏开始界面和精灵创建后，接下来将重点介绍精灵的检测与消除功能。

1. 结构大纲

首先梳理一下整体逻辑：

• 进入游戏界面，精灵开始落下。
• 精灵落完后，检测是否有可以消除的精灵。
• 若有可消除的精灵，先将其存放在一个 List 中，而不是立即消除。
• 扫描完全部精灵后，再将 List 中的精灵消除。
• 所有精灵消除完毕后，填补消除精灵留下的空位。
• 填补完成后，再次检测是否有可以消除的精灵，如此循环。

为了实现这个循环判断，我们使用 update 函数（更新函数），并借助 scheduleUpdate 定时器实现每帧更新。

Cocos2d-x 中的定时器

Cocos2d-x 中有三种定时器：

• schedule：有三种参数组合：(selector)、(selector, interval)、(selector, interval, repeat, delay)。
• selector：更新的目标函数，即每次更新时要执行的函数。
• interval：更新的时间间隔，即每隔多长时间执行一次更新。
• repeat：更新的次数。
• delay：每次更新前等待的时间。
• scheduleUpdate：它是 Node 类的成员函数，没有参数。每个 Node 调用该函数后，每一帧都会调用 update 函数。
• scheduleOnce：有两个参数 selector 和 delay，与 schedule 中的对应参数含义相同。从函数名可知，该函数只执行一次。

由于我们每帧都会扫描一次，为了避免在扫描的同时进行消除操作，我们设定了两个变量 isAction 和 isFillSprite，分别用于判断是否正在执行动作和是否需要填补空缺位置。

检测、移除、填补相关函数

// 检测是否有可消除精灵
void checkAndRemoveSprite();
// 标记可以移除的精灵
void markRemove( SpriteShape* spr );
// 移除精灵
void removeSprite();
// 精灵的爆炸移除
void explodeSprite( SpriteShape* spr );
// 对移除的精灵进行的操作
void actionEndCallback(Node *node);
// 纵向检查
void getColChain(SpriteShape *spr, std::list<SpriteShape*> &chainList);
// 横向检查
void getRowChain(SpriteShape *spr, std::list<SpriteShape*> &chainList);
// 填补空缺
void fillSprite();

这些函数看似有重复，但实际上是为后续添加特效和其他特性做铺垫，避免后续重新调整结构。

2. 更新函数

由于调用了 scheduleUpdate，我们需要重写 update 函数：

void GameScene::update( float t )
{
// 检测是否在执行动作
if ( isAction ) {
isAction = false;
// 扫描一遍所有精灵，看有没有可以消除的
for( int r = 0 ; r < ROWS ; ++r ) {
for( int c = 0 ; c < COLS ; ++c ) {
SpriteShape* spr = map[r][c];
if (spr && spr->getNumberOfRunningActions() > 0) {
isAction = true;
break;
}
}
}
}
// 如果没有动作执行
if (!isAction) {
// 是否有精灵需要填补
if ( isFillSprite ) {
// 爆炸效果结束后才掉落新寿司，增强打击感
fillSprite();
isFillSprite = false;
}
else {
checkAndRemoveSprite();
}
}
}

该函数主要分为两部分：

• 首先判断是否正在执行动作。若正在执行动作，则再次扫描所有精灵，确认是否还有动作正在执行。
• 若没有动作执行，则判断是否有精灵需要下落。若有，则执行填补空缺函数；若没有，则开始检测是否有精灵可以消除。

3. 移除系列函数

当没有动作执行且不需要填补空缺时，会执行 checkAndRemove 系列函数。

检测是否有精灵可以移除

void GameScene::checkAndRemoveSprite()
{
SpriteShape *spr;
// 从头遍历，检查是否有可以消除的精灵
for( int r = 0 ; r < ROWS ; ++r ) {
for( int c = 0 ; c < COLS ; ++c ) {
spr = map[r][c];
if( !spr ) {
continue;
}
// 如果该精灵已经被标记为要删除，则不需要再检测它
if( spr -> getIsNeedRemove() ) {
continue;
}
// 建立一个list 存储在本精灵周围(上下)与本精灵相同的精灵
std::list< SpriteShape *> colChainList;
getColChain( spr , colChainList );
// 建立一个list 存储在本精灵周围(左右)与本精灵相同的精灵
std::list< SpriteShape *> rowChainList;
getRowChain( spr , rowChainList );
// 将精灵个数多的list 赋值 给longerList
std::list< SpriteShape *> &longerList = colChainList.size() > rowChainList.size() ? colChainList : rowChainList;
// 如果相同精灵的个数小于3个 则跳过
if( longerList.size() < 3 ) {
continue;
}
std::list<SpriteShape*>::iterator itList;
for( itList = longerList.begin() ; itList != longerList.end() ; ++itList ) {
spr = ( SpriteShape * )* itList;
if( !spr ) {
continue;
}
// 标记要消除的精灵
markRemove( spr );
}
}
}
// 消除标记了的精灵
removeSprite();
}

该函数遍历所有精灵，判断是否有精灵需要消除。若需要消除，则标记该精灵（并非立即消除）。

标记可以移除的精灵

void GameScene::markRemove( SpriteShape* spr )
{
// 如果已经标记了要移除，就不需要再标记
if ( spr -> getIsNeedRemove()) {
return;
}
// 标记该精灵可以被移除
spr -> setIsNeedRemove(true);
}

移除精灵

void GameScene::removeSprite()
{
// 做一套移除的动作
isAction = true;
for( int r = 0 ; r < ROWS ; ++r ) {
for( int c = 0 ; c < COLS ; ++c ) {
SpriteShape* spr = map[r][c];
if( !spr ) {
continue;
}
if( spr -> getIsNeedRemove() ) {
isFillSprite = true;
explodeSprite( spr );
}
}
}
}

精灵的爆炸移除

void GameScene::explodeSprite( SpriteShape* spr )
{
// 精灵的动作
spr->runAction(Sequence::create(
ScaleTo::create(0.2f, 0.0),
CallFuncN::create(CC_CALLBACK_1(GameScene::actionEndCallback, this)),
NULL));
}

对移除的精灵进行的操作

void GameScene::actionEndCallback(Node *node)
{
SpriteShape *spr = (SpriteShape *)node;
map[spr->getRow()][spr->getCol()] = NULL;
spr -> removeFromParent();
}

虽然精灵的移除和爆炸移除看起来有重复，但后续它们会有不同的作用。

4. 检测精灵

主要对某个位置的精灵进行横向和纵向检测：

纵向检查

void GameScene::getColChain(SpriteShape *spr, std::list<SpriteShape*> &chainList)
{
// 添加第一个精灵(自己)
chainList.push_back(spr);
// 向左查找
int neighborCol = spr->getCol() - 1;
while (neighborCol >= 0) {
SpriteShape *neighborSprite = map[spr->getRow()][neighborCol];
if (neighborSprite
&& (neighborSprite->getImgIndex() == spr->getImgIndex())
&& !neighborSprite->getIsNeedRemove()) {
chainList.push_back(neighborSprite);
neighborCol--;
} else {
break;
}
}
// 向右查找
neighborCol = spr->getCol() + 1;
while (neighborCol < COLS) {
SpriteShape *neighborSprite = map[spr->getRow()][neighborCol];
if (neighborSprite
&& (neighborSprite->getImgIndex() == spr->getImgIndex())
&& !neighborSprite->getIsNeedRemove()) {
chainList.push_back(neighborSprite);
neighborCol++;
} else {
break;
}
}
}

横向检查

void GameScene::getRowChain(SpriteShape *spr, std::list<SpriteShape*> &chainList)
{
// 先将第一个精灵加入进去
chainList.push_back(spr);
// 向上查找
int neighborRow = spr->getRow() - 1;
while (neighborRow >= 0) {
SpriteShape *neighborSprite = map[neighborRow][spr->getCol()];
if (neighborSprite
&& (neighborSprite->getImgIndex() == spr->getImgIndex())
&& !neighborSprite->getIsNeedRemove()) {
chainList.push_back(neighborSprite);
neighborRow--;
} else {
break;
}
}
// 向下查找
neighborRow = spr->getRow() + 1;
while (neighborRow < ROWS) {
SpriteShape *neighborSprite = map[neighborRow][spr->getCol()];
if (neighborSprite
&& (neighborSprite->getImgIndex() == spr->getImgIndex())
&& !neighborSprite->getIsNeedRemove()) {
chainList.push_back(neighborSprite);
neighborRow++;
} else {
break;
}
}
}

这两个函数通过 while 循环，从当前精灵开始向上下左右方向遍历，判断相邻精灵是否与当前精灵相同。

5. 填补空缺位置

当有精灵被消除后，需要让被消除精灵上方未被消除的部分下落，并生成新的精灵。

void GameScene::fillSprite()
{
// 重置移动方向标志
isAction = true;
int *colEmptyInfo = (int *)malloc(sizeof(int) * COLS);
memset((void *)colEmptyInfo, 0, sizeof(int) * COLS);
// 将存在的精灵降落下来
SpriteShape *spr = NULL;
for (int c = 0; c < COLS; c++) {
int removedSpriteOfCol = 0;
// 自底向上
for (int r = 0; r < ROWS; r++ ) {
spr = map[r][c];
if ( spr == NULL ) {
++removedSpriteOfCol;
} else {
if ( removedSpriteOfCol > 0) {
int newRow = r - removedSpriteOfCol;
map[newRow][c] = spr;
map[r][c] = NULL;
Point startPosition = spr->getPosition();
Point endPosition = positionOfItem(newRow, c);
float speed = (startPosition.y - endPosition.y) / GAME_SCREEN_HEIGHT*3;
spr->stopAllActions();
spr->runAction(CCMoveTo::create(speed, endPosition));
spr->setRow(newRow);
}
}
}
// 记录相应列数移除的数量
colEmptyInfo[c] = removedSpriteOfCol;
}
// 新建新的精灵，并降落
for (int c = 0; c < COLS; ++c ) {
for (int r = ROWS - colEmptyInfo[c]; r < ROWS ; ++r ) {
createSprite(r,c);
}
}
free(colEmptyInfo);
}

需要注意的是，如果按照上述方式实现后，出现所有精灵都被消除、产生新精灵后又被消除的问题，可能是因为没有对每个精灵的 isNeedRemove 进行初始化。应将其初始化为 false，可以通过构造函数实现：

SpriteShape::SpriteShape()
: m_col(0)
, m_row(0)
, m_imgIndex(0)
, m_isNeedRemove(false)
{
}

总结

本次内容简单实现了精灵的检测与消除功能，但还有很多功能有待完善，如移动交换精灵、消除特效、消除大于 3 个精灵后产生特效精灵等。后续会逐步更新这些内容。