（15）如何使用Cocos2d-x 3.0制作基于tilemap的游戏：第三部分（完）

//in the HelloWorld class
void HelloWorld::addEnemyAtPos(Point pos)
{
    auto enemy = Sprite::create("enemy1.png");
    enemy->setPosition(pos);
    this->addChild(enemy);
}
 
// in the init method - after creating the player
// iterate through objects, finding all enemy spawn points
// create an enemy for each one
for (auto& eSpawnPoint : objects->getObjects()) {
    ValueMap& dict = eSpawnPoint.asValueMap();
    if (dict["Enemy"].asInt() == 1) {
        x = dict["x"].asInt();
        y = dict["y"].asInt();
        this->addEnemyAtPos(Point(x,y));
    }
}

// callback. starts another iteration of enemy movement.
void HelloWorld::enemyMoveFinished(Object *pSender)
{
    Sprite *enemy = (Sprite *)pSender;
 
    this->animateEnemy(enemy);
}
 
// a method to move the enemy 10 pixels toward the player
void HelloWorld::animateEnemy(Sprite *enemy)
{
    // speed of the enemy
    float actualDuration = 0.3f;
 
    // Create the actions
    auto position = (_player->getPosition() - enemy->getPosition()).normalize()*10;
    auto actionMove = MoveBy::create(actualDuration, position);
    auto actionMoveDone = CallFuncN::create(CC_CALLBACK_1(HelloWorld::enemyMoveFinished, this));
    enemy->runAction(Sequence::create(actionMove, actionMoveDone, NULL));
}
 
// add this at the end of addEnemyAtPos
// Use our animation method and
// start the enemy moving toward the player
this->animateEnemy(enemy);

//immediately before creating the actions in animateEnemy
//rotate to face the player
auto diff = ccpSub(_player->getPosition(), enemy->getPosition());
float angleRadians = atanf((float)diff.y / (float)diff.x);
float angleDegrees = CC_RADIANS_TO_DEGREES(angleRadians);
float cocosAngle = -1 * angleDegrees;
if (diff.x < 0) {
    cocosAngle += 180;
}
enemy->setRotation(cocosAngle);

// at the top of the file add a forward declaration for HelloWorld,
// because our two layers need to reference each other
 
class HelloWorld;
 
// inside the HelloWorldHud class declaration
HelloWorld *_gameLayer;
 
// Inside the HelloWorld class declaration
CC_SYNTHESIZE(int, _mode, Mode);

// in HelloWorld's init method
_mode =0;
 
//replace following two lines with CC_SYNTHESIZE
//private:
//  HelloWorld *_gameLayer;
CC_SYNTHESIZE(HelloWorld *, _gameLayer, GameLayer);
 
// in HelloWorld's createScene method
// after _hud = hud;
_hud->setGameLayer(layer);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// in HelloWorldHud's init method
// define the button
MenuItem *on = MenuItemImage::create("projectile-button-on.png", "projectile-button-on.png");
MenuItem *off = MenuItemImage::create("projectile-button-off.png", "projectile-button-off.png");
 
auto toggleItem = MenuItemToggle::createWithCallback(CC_CALLBACK_1(HelloWorldHud::projectileButtonTapped, this), off, on, NULL);
auto toggleMenu = Menu::create(toggleItem, NULL);
toggleMenu->setPosition(on->getContentSize().width * 2, on->getContentSize().height / 2);
this->addChild(toggleMenu);
 
// in HelloWorldHud
//callback for the button
//mode 0 = moving mode
//mode 1 = ninja star throwing mode
void HelloWorldHud::projectileButtonTapped(Object *pSender)
{
    if (_gameLayer->getMode() == 1) {
        _gameLayer->setMode(0);
    }
    else {
        _gameLayer->setMode(1);
    }
}

if (_mode ==0) {
// old contents of onTouchEnded
} else {
// code to throw ninja stars will go here
}

void HelloWorld::projectileMoveFinished(Object *pSender)
{
    Sprite *sprite = (Sprite *)pSender;
    this->removeChild(sprite);
}

// code to throw ninja stars will go here

cocos2d::Vector<cocos2d::Sprite *> _enemies;
cocos2d::Vector<cocos2d::Sprite *> _projectiles;

// at the end of the launch projectiles section of onTouchEnded:
_projectiles.pushBack(projectile);
 
// at the end of projectileMoveFinished:
_projectiles.eraseObject(sprite);

_enemies.pushBack(enemy);

void HelloWorld::testCollisions(float dt)
{
    Vector<Sprite*> projectilesToDelete;
 
    // iterate through projectiles
    for (Sprite *projectile : _projectiles) {
        auto projectileRect = Rect(
            projectile->getPositionX() - projectile->getContentSize().width / 2,
            projectile->getPositionY() - projectile->getContentSize().height / 2,
            projectile->getContentSize().width,
            projectile->getContentSize().height);
 
        Vector<Sprite*> targetsToDelete;
 
        // iterate through enemies, see if any intersect with current projectile
        for (Sprite *target : _enemies) {
            auto targetRect = Rect(
                target->getPositionX() - target->getContentSize().width / 2,
                target->getPositionY() - target->getContentSize().height / 2,
                target->getContentSize().width,
                target->getContentSize().height);
 
            if (projectileRect.intersectsRect(targetRect)) {
                targetsToDelete.pushBack(target);
            }
        }
 
        // delete all hit enemies
        for (Sprite *target : targetsToDelete) {
            _enemies.eraseObject(target);
            this->removeChild(target);
        }
 
        if (targetsToDelete.size() > 0) {
            // add the projectile to the list of ones to remove
            projectilesToDelete.pushBack(projectile);
        }
        targetsToDelete.clear();
    }
 
    // remove all the projectiles that hit.
    for (Sprite *projectile : projectilesToDelete) {
        _projectiles.eraseObject(projectile);
        this->removeChild(projectile);
    }
    projectilesToDelete.clear();
}

this->schedule(schedule_selector(HelloWorld::testCollisions));

#include "cocos2d.h"
 
class GameOverLayer : public cocos2d::LayerColor
{
public:
    GameOverLayer() :_label(NULL) {};
    virtual ~GameOverLayer();
    bool init();
    CREATE_FUNC(GameOverLayer);
 
    void gameOverDone();
 
    CC_SYNTHESIZE_READONLY(cocos2d::LabelTTF*, _label, Label);
};
 
class GameOverScene : public cocos2d::Scene
{
public:
    GameOverScene() :_layer(NULL) {};
    ~GameOverScene();
    bool init();
    CREATE_FUNC(GameOverScene);
 
    CC_SYNTHESIZE_READONLY(GameOverLayer*, _layer, Layer);
};

#include "GameOverScene.h"
#include "HelloWorldScene.h"
USING_NS_CC;
bool GameOverScene::init()
{
    if (Scene::init())
    {
        this->_layer = GameOverLayer::create();
        this->_layer->retain();
        this->addChild(_layer);
 
        return true;
    }
    else
    {
        return false;
    }
}
 
GameOverScene::~GameOverScene()
{
    if (_layer)
    {
        _layer->release();
        _layer = NULL;
    }
}
 
bool GameOverLayer::init()
{
    if (LayerColor::initWithColor(Color4B(255, 255, 255, 255)))
    {
        auto winSize = Director::getInstance()->getWinSize();
        this->_label = LabelTTF::create("", "Artial", 32);
        _label->retain();
        _label->setColor(Color3B(0, 0, 0));
        _label->setPosition(Point(winSize.width / 2, winSize.height / 2));
        this->addChild(_label);
 
        this->runAction(Sequence::create(
            DelayTime::create(3),
            CallFunc::create(CC_CALLBACK_0(GameOverLayer::gameOverDone, this)),
            NULL));
 
        return true;
    }
    else
    {
        return false;
    }
}
 
void GameOverLayer::gameOverDone()
{
    Director::getInstance()->replaceScene(HelloWorld::createScene());
}
 
GameOverLayer::~GameOverLayer()
{
    if (_label)
    {
        _label->release();
        _label = NULL;
    }
}

// put the number of melons on your map in place of the '2'
if (_numCollected == 2) {
    this->win();
}

void HelloWorld::win()
{
    GameOverScene *gameOverScene = GameOverScene::create();
    gameOverScene->getLayer()->getLabel()->setString("You Win!");
    Director::getInstance()->replaceScene(gameOverScene);
}

#include "GameOverScene.h"

for (Sprite *target : _enemies) {
    auto targetRect = Rect(
        target->getPosition().x - (target->getContentSize().width / 2),
        target->getPosition().y - (target->getContentSize().height / 2),
        target->getContentSize().width,
        target->getContentSize().height);
    if (targetRect.containsPoint(_player->getPosition())) {
        this->lose();
    }
}

void HelloWorld::lose()
{
    GameOverScene *gameOverScene = GameOverScene::create();
    gameOverScene->getLayer()->getLabel()->setString("You Lose!");
    Director::getInstance()->replaceScene(gameOverScene);
}