Cocos2dx项目实战（4）——一个都不能死

本章将复刻经典小游戏，一起来看看吧。

本文仅供个人记录和复习，不用于其他用途

游戏效果展示

游戏流程设计

• 开始界面：三个难度选择以及退出按钮
• 游戏界面：加载对应的关卡
• 关卡生成：只生成一个跑道
• 英雄生成：加载英雄的动画
• 障碍物：不断地刷新障碍物

这里要说明一下，由于跑道都是一样的，所以我们只需要编写一条跑道的代码，然后交由游戏主界面进行生成即可。

LayerStart

游戏的开始界面，用于选择关卡。

LayerStart.h

#ifndef __LayerStart__H__
#define __LayerStart__H__

#include "cocos2d.h"
USING_NS_CC;

class LayerStart: public Layer
{
public:
    static Scene* scene();
    CREATE_FUNC(LayerStart);
    bool init();

    enum DEGREE
    {
        CLASS = 1,
        ADVANCE = 2,
        HELL = 3
    };

    void classCallBack(Ref *ref);
    void advanceCallBack(Ref *ref);
    void hellCallBack(Ref *ref);
    void quitCallBack(Ref *ref);
};

#endif

游戏开始场景，很简单，生成四个按钮，然后设置对应的回调事件即可。

LayerStart.cpp

#include "LayerStart.h"
#include "LayerMain.h"

Scene* LayerStart::scene()
{
    Scene *scene = Scene::create();
    LayerStart *layer = LayerStart::create();
    scene->addChild(layer);

    return scene;
}

bool LayerStart::init()
{
    if (!Layer::init())
    {
        return false;
    }

    MenuItemLabel *classItem = MenuItemLabel::create(Label::createWithSystemFont("Class", "Arial", 30), CC_CALLBACK_1(LayerStart::classCallBack, this));
    MenuItemLabel *advanceItem = MenuItemLabel::create(Label::createWithSystemFont("Advance", "Arial", 30), CC_CALLBACK_1(LayerStart::advanceCallBack, this));
    MenuItemLabel *hellItem = MenuItemLabel::create(Label::createWithSystemFont("Hell", "Arial", 30), CC_CALLBACK_1(LayerStart::hellCallBack, this));
    MenuItemLabel *quitItem = MenuItemLabel::create(Label::createWithSystemFont("Quit", "Arial", 30), CC_CALLBACK_1(LayerStart::quitCallBack, this));

    Menu *menu = Menu::create(classItem, advanceItem, hellItem, quitItem, NULL);
    addChild(menu);
    menu->alignItemsVerticallyWithPadding(40);

    return true;
}

void LayerStart::classCallBack(Ref *ref)
{
    Scene *scene = LayerMain::scene(CLASS);
    Director::getInstance()->replaceScene(scene);
}

void LayerStart::advanceCallBack(Ref *ref)
{
    Scene *scene = LayerMain::scene(ADVANCE);
    Director::getInstance()->replaceScene(scene);
}

void LayerStart::hellCallBack(Ref *ref)
{
    Scene *scene = LayerMain::scene(HELL);
    Director::getInstance()->replaceScene(scene);
}

void LayerStart::quitCallBack(Ref *ref)
{
    Director::getInstance()->end();
}

LayerMain的创建方法需要我们提供一个参数，在这里就是对应的难度，其他的不再多说。

LayerMain

游戏主场景，也是我们玩游戏的界面。

LayerMain.h

#ifndef __LayerMain__H__
#define __LayerMain__H__

#include "cocos2d.h"
USING_NS_CC;

class LayerMain: public LayerColor
{
public:
    static Scene *scene(int layerCount);
    static LayerMain *create(int layerCount);
    bool init(int layerCount);

    static int _layerCount;
};

#endif

这里我们使用的是有参数的创建方法，接受的是LayerStart传递而来的难度系数（1、2、3）。_layerCount用于记录当前所选择的难度。

LayerMain.cpp

#include "LayerMain.h"
#include "LayerOne.h"

int LayerMain::_layerCount = 0;

Scene *LayerMain::scene(int layerCount)
{
    Scene *scene = Scene::create();
    LayerMain *layer = LayerMain::create(layerCount);
    scene->addChild(layer);

    return scene;
}

LayerMain *LayerMain::create(int layerCount)
{
    LayerMain *pRet = new LayerMain();
    if (pRet && pRet->init(layerCount))
    {
        pRet->autorelease();
    }
    else
    {
        delete pRet;
        pRet = NULL;
    }

    return pRet;
}

bool LayerMain::init(int layerCount)
{
    LayerColor::initWithColor(ccc4(255, 255, 255, 255));

    _layerCount = layerCount;

    for (int i = 0; i != layerCount; i++)
    {
        LayerOne *one = LayerOne::create(i);
        addChild(one);
    }

    return true;
}

这里的工作其实就是把_layerCount初始化，然后创建对应个数的LayerOne，也就是跑道。LayerMain继承的是LayerColor，这里调用LayerColor的初始化方法，将层的背景颜色改为白色。

Hero

用于生成英雄，并且加载动画。

Hero.h

#ifndef __Hero_H__
#define __Hero_H__
#include "cocos2d.h"

USING_NS_CC;

class Hero : public CCSprite
{
public:
    CREATE_FUNC(Hero);
    bool init();
};

#endif

Hero.cpp

#include "Hero.h"

bool Hero::init()
{
    if (!Sprite::init())
    {
        return false;
    }
    setAnchorPoint(Vec2(0, 0));


    Animation *animation = Animation::create();
    char buffer[100];
    for (int i = 0; i != 5; i++)
    {
        memset(buffer, 0, sizeof(buffer));
        sprintf(buffer, "Hero%d.png", i);
        animation->addSpriteFrameWithFile(buffer);
    }
    animation->setDelayPerUnit(0.1f);
    animation->setLoops(-1);

    Animate *animate = Animate::create(animation);

    this->runAction(animate);

    return true;
}

这里只需要一个初始化方法，加载英雄的动画，并且执行这个动画即可。

Block

用于生成随机的障碍物。

Block.h

#ifndef __Block_H__
#define __Block_H__

#include "cocos2d.h"
USING_NS_CC;

class Block :public Sprite
{
public:
    CREATE_FUNC(Block);
    bool init();

    void update(float dt);
};

#endif

Block.cpp

#include "Block.h"

bool Block::init()
{
    Sprite::init();

    Size size = Size(rand() % 30 + 10, rand() % 30 + 10);
    setContentSize(size);
    setAnchorPoint(Vec2(0, 0));

    setTextureRect(Rect(0, 0, size.width, size.height));
    setColor(Color3B::BLACK);
    scheduleUpdate();

    return true;
}

void Block::update(float dt)
{
    setPositionX(getPositionX() - 6);
}

Block的长和高被固定在10-39之间，然后我们将方块设置成黑色，并且调用定时器让这个方块每帧往左移动6。这里我们可以看出，并不是英雄在动，而是方块在不断地往前移，造成了英雄移动的假象。rand()是标准库函数，用于生成随机数。其实我们在使用这个函数时应该设立随机数种子，否则它生成的都是固定的数。

LayerOne

LayerOne用于生成一个跑道，然后加入英雄和障碍物，并且进行碰撞检测。

LayerOne.h

#ifndef __LayerOne_H__
#define __LayerOne_H__

#include "cocos2d.h"
#include "Block.h"
#include "LayerOver.h"
#include "Hero.h"
USING_NS_CC;

class LayerOne: public LayerColor
{
public:
    static LayerOne *create(int layerIndex);
    bool init(int layerIndex);

    Size winSize = Director::getInstance()->getWinSize();

    void addGround();
    void addHero();
    void addBlocks();

    void update(float dt);

    void resetFrameCount();

    bool onTouchBegan(Touch *touch, Event *pEvent);

    Hero *_hero;
    int randFrameCount;
    int curFrameCount;
    Vector<Block *> vector;
};

#endif

LayerOne的创建方法接受一个参数，不过这个参数不是代表要生成多少个跑道。前面已经说了，LayerOne只生成一条跑道，所以这里代表的是第几条跑道，这样能够方便我们设置跑道所处的位置。randFrameCount和curFrameCount都是和随机生成有关，后面会讲到。

LayerOne.cpp

#include "LayerOne.h"

LayerOne *LayerOne::create(int layerIndex)
{
    LayerOne *pRet = new LayerOne();
    if (pRet && pRet->init(layerIndex))
    {
        pRet->autorelease();
    }
    else
    {
        delete pRet;
        pRet = NULL;
    }

    return pRet;
}

bool LayerOne::init(int layerIndex)
{
    LayerColor::initWithColor(Color4B(255, 255, 255, 255));

    setContentSize(Size(320, 150));
    setAnchorPoint(Vec2(0, 0));
    setPositionY(layerIndex * 150 + 20);

    addGround();
    addHero();

    auto listener = EventListenerTouchOneByOne::create();
    listener->onTouchBegan = CC_CALLBACK_2(LayerOne::onTouchBegan, this);
    listener->setSwallowTouches(true);
    Director::getInstance()->getEventDispatcher()->addEventListenerWithSceneGraphPriority(listener, this);

    scheduleUpdate();
    resetFrameCount();

    return true;
}

void LayerOne::addGround()
{
    Sprite *bg = Sprite::create();
    bg->setTextureRect(Rect(0, 0, winSize.width, 4));
    bg->setColor(Color3B::BLACK);
    bg->setAnchorPoint(Vec2(0, 0));
    bg->setPosition(Vec2(0, 0));
    addChild(bg);
}

void LayerOne::addHero()
{
    _hero = Hero::create();
    _hero->setPosition(Vec2(50, 4));
    addChild(_hero);
}

void LayerOne::addBlocks()
{
    Block *b = Block::create();
    b->setPosition(Vec2(320, 4));
    addChild(b);
    vector.pushBack(b);
}

void LayerOne::resetFrameCount()
{
    curFrameCount = 0;
    randFrameCount = rand() % 40 + 30;
}

void LayerOne::update(float dt)
{
    curFrameCount++;
    if (curFrameCount > randFrameCount)
    {
        resetFrameCount();
        addBlocks();
    }

    for (auto &b = vector.rbegin(); b != vector.rend(); b++)
    {
        if ((*b)->getPositionX() < 0)
        {
            (*b)->removeFromParentAndCleanup(true);
        }
        Rect rect = _hero->boundingBox();
        rect.size.width -= 30;
        if (rect.intersectsRect((*b)->boundingBox()))
        {
            Scene *scene = LayerOver::scene();
            Director::getInstance()->replaceScene(scene);
        }
    }
}

bool LayerOne::onTouchBegan(Touch *touch, Event *pEvent)
{
    if (_hero->getPositionY() > 4)
    {
        return false;
    }

    if (this->boundingBox().containsPoint(touch->getLocation()))
    {
        JumpBy *by = JumpBy::create(0.5, Vec2(0, 0), 80, 1);
        _hero->runAction(by);
    }

    return false;
}

LayerOne同样继承自LayerColor，主要是设置背景颜色为白色。这里我们将层的大小设置为长320高150，由于我们需要显示其他的内容，所以不把层的高度设置成窗口高度的1/3。层的位置设置就根据传入的layerCount，从下到上依次设置。addGround()其实就是在层的底部生成一条黑色的跑道，addHero()就是加入Hero类。

关于触摸事件，这里要说明一下。由于我们只编写了一个LayerOne，当这个类被多次调用时，哪怕生成的跑道处在不同的位置，只要点击其中一条跑道，其他的两个都会执行回调事件。为了避免这种情况，我们对当前触摸点进行了判断，所以，只要触摸点处在当前层中，就会执行跳跃动作，而其他的层由于没有包含触摸点，所以不会有反应。

其实这里比较关键的是update()，我们用resetFrameCount()生成了一个30到69之间的随机数，然后在update()将curFrameCount不断递增，这样就做到了随机生成障碍物，并且使得障碍物没有那么密集（因为最快也要30帧才能生成一个）。一旦我们的障碍物生成了，就需要再次调用resetFrameCount()，开始新一轮的递增。接下来是英雄的碰撞检测，我在之前的章节已经提到过了。

总结

至此，我们完成了《一个都不能死》的游戏开发。项目实战进行到了第四个，我们会发现游戏开发需要严谨的架构和逻辑。这几个游戏虽然不大，但也不代表我们可以想怎么写就怎么写。这款游戏是一个很好的例子，它的层与层之间都分隔开来，一个层只完成一个工作。我们在编写函数时，也经常被教导说一个函数只完成一个工作。这不是多此一举，而是为了让代码结构清晰明了。