NyanRun (5)

AppDelegate.cpp

//
//  AppDelegate.cpp
//  nyanrun
//
//  Created by Tomoaki Shimizu on 2013/02/05.
//  Copyright TKS2 2013. All rights reserved.
//

#include "AppDelegate.h"

#include "cocos2d.h"
#include "cocos-ext.h"
#include "SimpleAudioEngine.h"
#include "GameLayerLoader.h"

USING_NS_CC;
USING_NS_CC_EXT;
using namespace CocosDenshion;
using namespace std;

AppDelegate::AppDelegate()
{
}

AppDelegate::~AppDelegate()
{
}

bool AppDelegate::applicationDidFinishLaunching()
{
    CCDirector* pDirector = CCDirector::sharedDirector();
    pDirector->setOpenGLView(CCEGLView::sharedOpenGLView());
    pDirector->setDisplayStats(true);
    pDirector->setAnimationInterval(1.0 / 60);
    
    CCNodeLoaderLibrary * ccNodeLoaderLibrary = CCNodeLoaderLibrary::newDefaultCCNodeLoaderLibrary();
    ccNodeLoaderLibrary->registerCCNodeLoader("GameLayer", GameLayerLoader::loader());
    CCBReader * ccbReader = new CCBReader(ccNodeLoaderLibrary);
    CCNode* node = ccbReader->readNodeGraphFromFile("GameLayer.ccbi");
    ((GameLayer*)node)->setAnimationManager(ccbReader->getAnimationManager());

    CCScene * scene = CCScene::create();
    if(node != NULL)
        scene->addChild(node);
    ccbReader->release();
    CCDirector::sharedDirector()->runWithScene(scene);
    
    return true;
}

// This function will be called when the app is inactive. When comes a phone call,it's be invoked too
void AppDelegate::applicationDidEnterBackground()
{
    CCDirector::sharedDirector()->stopAnimation();
    SimpleAudioEngine::sharedEngine()->pauseBackgroundMusic();
    SimpleAudioEngine::sharedEngine()->pauseAllEffects();
}

// this function will be called when the app is active again
void AppDelegate::applicationWillEnterForeground()
{
    CCDirector::sharedDirector()->startAnimation();
    SimpleAudioEngine::sharedEngine()->resumeBackgroundMusic();
    SimpleAudioEngine::sharedEngine()->resumeAllEffects();
}

GameLayer.cpp

//
//  GameLayer.cpp
//  nyanrun
//
//  Created by Tomoaki Shimizu on 2013/02/05.
//  Copyright TKS2 2013. All rights reserved.
//

#include "GameLayer.h"
#include "HelloWorldScene.h"

GameLayer::GameLayer()
: mBg1(NULL)
, mBg2(NULL)
, mBg3(NULL)
{
}

GameLayer::~GameLayer()
{
    CC_SAFE_RELEASE(mBg1);
    CC_SAFE_RELEASE(mBg2);
    CC_SAFE_RELEASE(mBg3);
}

SEL_MenuHandler GameLayer::onResolveCCBCCMenuItemSelector(CCObject* pTarget, const char* pSelectorName)
{
    CCB_SELECTORRESOLVER_CCMENUITEM_GLUE(this, "tappedLeftFoot", GameLayer::tappedLeftButton);
    CCB_SELECTORRESOLVER_CCMENUITEM_GLUE(this, "tappedRightFoot", GameLayer::tappedRightButton);
    
    return NULL;
}

void GameLayer::tappedLeftButton(CCObject* pSender, CCControlEvent pCCControlEvent)
{
    tappedButton(FOOT_LEFTFOOT);
}

void GameLayer::tappedRightButton(CCObject* pSender, CCControlEvent pCCControlEvent)
{
    tappedButton(FOOT_RIGHTFOOT);
}

void GameLayer::tappedButton(EFoot currentFoot)
{
    if (mBeforeFoot == currentFoot)
    {
        mAnimationManager->runAnimationsForSequenceNamedTweenDuration("Tumble", 0);
        mBeforeFoot = FOOT_UNKNOWN;
    }
    else
    {
        mCount++;
        if (mCount >= GOAL_COUNT)
        {
            mAnimationManager->runAnimationsForSequenceNamedTweenDuration("Goal", 0);
            return;
        }
        
        mBeforeFoot = currentFoot;
        
        switch (currentFoot)
        {
            case FOOT_LEFTFOOT:
                mAnimationManager->runAnimationsForSequenceNamedTweenDuration("Leftfoot", 0);
                break;
                
            case FOOT_RIGHTFOOT:
                mAnimationManager->runAnimationsForSequenceNamedTweenDuration("Rightfoot", 0);
                break;
                
            default:
                return;
        }
        
        float moveTime = 1.0 / 3;
        float moveDistanceForBG3 = (this->mBg3->getContentSize().width - CCDirector::sharedDirector()->getWinSize().width) / GOAL_COUNT;
        
        CCMoveBy* move1 = CCMoveBy::create(moveTime, ccp(-moveDistanceForBG3 / 4, 0));
        this->mBg1->runAction(move1);
        
        CCMoveBy* move2 = CCMoveBy::create(moveTime, ccp(-moveDistanceForBG3 / 2, 0));
        this->mBg2->runAction(move2);
        
        CCMoveBy* move3 = CCMoveBy::create(moveTime, ccp(-moveDistanceForBG3, 0));
        this->mBg3->runAction(move3);
        
        float moveDistanceForCat = CCDirector::sharedDirector()->getWinSize().width / 2 / GOAL_COUNT;
        
        CCNode* cat = this->getChildByTag(1);
        CCMoveBy* move = CCMoveBy::create(moveTime, ccp(moveDistanceForCat, 0));
        cat->runAction(move);
    }
}

SEL_CCControlHandler GameLayer::onResolveCCBCCControlSelector(CCObject* pTarget, const char* pSelectorName)
{
    return NULL;
}

bool GameLayer::onAssignCCBMemberVariable(CCObject* pTarget, const char* pMemberVariableName, CCNode* pNode)
{
    CCB_MEMBERVARIABLEASSIGNER_GLUE(this, "mBg1", CCSprite*, this->mBg1);
    CCB_MEMBERVARIABLEASSIGNER_GLUE(this, "mBg2", CCSprite*, this->mBg2);
    CCB_MEMBERVARIABLEASSIGNER_GLUE(this, "mBg3", CCSprite*, this->mBg3);
    
    return false;
}

void GameLayer::setAnimationManager(CCBAnimationManager *pAnimationManager)
{
    CC_SAFE_RELEASE_NULL(mAnimationManager);
    mAnimationManager = pAnimationManager;
    CC_SAFE_RETAIN(mAnimationManager);
}

GameLayer.h

//
//  GameLayer.h
//  nyanrun
//
//  Created by Tomoaki Shimizu on 2013/02/05.
//  Copyright TKS2 2013. All rights reserved.
//

#ifndef __GAME_LAYER__
#define __GAME_LAYER__

#include "cocos2d.h"
#include "cocos-ext.h"

USING_NS_CC;
USING_NS_CC_EXT;

#define GOAL_COUNT 100

class GameLayer : public CCLayer
, public CCBSelectorResolver
, public CCBMemberVariableAssigner
{
protected:
    enum EFoot
    {
        FOOT_UNKNOWN = 0,
        FOOT_LEFTFOOT = 1,
        FOOT_RIGHTFOOT = 2,
    };

    int mCount;
    EFoot mBeforeFoot;
    CCSprite* mBg1;
    CCSprite* mBg2;
    CCSprite* mBg3;
    CCBAnimationManager* mAnimationManager;
    
    virtual SEL_MenuHandler onResolveCCBCCMenuItemSelector(CCObject* pTarget, const char* pSelectorName);
    virtual SEL_CCControlHandler onResolveCCBCCControlSelector(CCObject* pTarget, const char* pSelectorName);
    
    virtual bool onAssignCCBMemberVariable(CCObject* pTarget, const char* pMemberVariableName, CCNode* pNode);
    void tappedLeftButton(CCObject* pSender, CCControlEvent pCCControlEvent);
    void tappedRightButton(CCObject* pSender, CCControlEvent pCCControlEvent);
    void tappedButton(EFoot currentFoot);
    
public:
    GameLayer();
    virtual ~GameLayer();
    
    CCB_STATIC_NEW_AUTORELEASE_OBJECT_WITH_INIT_METHOD(GameLayer, create);
    
    void setAnimationManager(CCBAnimationManager *pAnimationManager);
};

#endif /* __GAME_LAYER__ */