cocos2dx

#ifndef __Timber__

#define __Timber__

#include "cocos2d.h"

#include "TreeModel.h"

USING_NS_CC;

using namespace CocosDenshion;

class Timber : public Node

{

public:
static Timber* createTimber();
void initTimber();
void playAction(TreeBranchDirection enums);
void setTimberDie();
TreeBranchDirection getTimberDir();
void onReset();

private:
Sprite* body;
TreeBranchDirection dir;

};

#endif

#include "Timber.h"

#include "SimpleAudioEngine.h"

Timber* Timber::createTimber()

{
auto timber = new Timber();
timber->initTimber();
timber->setScale(0.5);
return timber;

}

void Timber::initTimber()

{

body = Sprite::create("role.png");
this->addChild(body);

auto aCache = AnimationCache::getInstance();

Vector<SpriteFrame*> aFrames(2);
aFrames.pushBack(SpriteFrame::create("att_left.png",Rect(0,0,303,210)));
aFrames.pushBack(SpriteFrame::create("role.png",Rect(0,0,196,257)));
aCache->addAnimation(Animation::createWithSpriteFrames(aFrames,0.1f),"left");

aFrames.clear();
aFrames.pushBack(SpriteFrame::create("att_right.png",Rect(0,0,303,210)));
aFrames.pushBack(SpriteFrame::create("role.png",Rect(0,0,196,257)));
aCache->addAnimation(Animation::createWithSpriteFrames(aFrames,0.1f),"right");

aFrames.clear();
aFrames.pushBack(SpriteFrame::create("die.png",Rect(0,0,104,110)));
aCache->addAnimation(Animation::createWithSpriteFrames(aFrames,0.1f),"die");

this->setContentSize(Size(body->getContentSize().width
,body->getContentSize().height));

}

void Timber::playAction(TreeBranchDirection enums)

{
SimpleAudioEngine::getInstance()->playEffect("music/famu.mp3");
auto aCache = AnimationCache::getInstance();
body->stopAllActions();
switch (enums)
{
case LEFT:
body->runAction(Animate::create(aCache->getAnimation("left")));
break;
case RIGHT:
body->runAction(Animate::create(aCache->getAnimation("right")));
break;
}
dir = enums;

}

void Timber::setTimberDie()

{
SimpleAudioEngine::getInstance()->playEffect("music/death.mp3");
auto aCache = AnimationCache::getInstance();
body->stopAllActions();
body->runAction(Animate::create(aCache->getAnimation("die")));

}

TreeBranchDirection Timber::getTimberDir()

{
return dir;

}

void Timber::onReset()

{
body->stopAllActions();
body->setSpriteFrame(SpriteFrame::create("role.png",Rect(0,0,196,257)));

}

#ifndef __TreeNode__

#define __TreeNode__

#include "cocos2d.h"

USING_NS_CC;

enum TreeBranchDirection

{
DEFINE,
LEFT,
RIGHT

};

class TreeNode : public Node

{

public:
static TreeNode* createNode();
void setBranch(TreeBranchDirection enums);
TreeBranchDirection getHasBranch();

private:
void initTree();
TreeBranchDirection enumBranch;

};

#endif

#include "TreeNode.h"

TreeNode* TreeNode::createNode()

{
auto treeNode = new TreeNode();
treeNode->initTree();
return treeNode;

}

void TreeNode::initTree()

{
Sprite* body = Sprite::create("body.jpg");
this->addChild(body,0,"body");
Sprite* branch = Sprite::create("branch.png");
this->addChild(branch,1,"branch");
this->setContentSize(Size(body->getContentSize().width
,body->getContentSize().height));

}

void TreeNode::setBranch(TreeBranchDirection enums)

{
enumBranch = enums;
auto branch = this->getChildByName("branch");
auto body = this->getChildByName("body");
branch->setVisible(enums!=DEFINE);
if(enums==DEFINE)return;
if(enums == RIGHT)
{
branch->setScaleX(1);
branch->setPositionX(body->getContentSize().width);
}
else
{
branch->setScaleX(-1);
branch->setPositionX(-body->getContentSize().width);
}

}

TreeBranchDirection TreeNode::getHasBranch()

{
return enumBranch;

}

#ifndef __TreeModel__

#define __TreeModel__

#include "cocos2d.h"

#include "TreeNode.h"

USING_NS_CC;

class TreeModel : public Layer

{

public:
static TreeModel* getInstance();
TreeNode* getTreeHeadNode();
TreeNode* deleteTreeHeadNode();
void initTree();
TreeBranchDirection getFirstBranch();
void onReset();

private:
void createTreeModel();
void update(float time);
TreeBranchDirection getBranch();

4000
TreeBranchDirection getAgainBranch();
Node* Treebody;
Vector<TreeNode*> treeQueue;
Vector<TreeNode*> treeCache;

};

#endif

#include "TreeModel.h"

static TreeModel* _layer = nullptr;

TreeModel* TreeModel::getInstance()

{
if(!_layer)
{
_layer = new TreeModel();
_layer->initTree();
_layer->setScale(0.5);
}
return _layer;

}

void TreeModel::initTree()

{
Size visibleSize = Director::getInstance()->getVisibleSize();

Sprite* base = Sprite::create("base.png");
this->addChild(base);
base->setPosition(3,base->getContentSize().height/2);

Treebody = Node::create();
this->addChild(Treebody);
Treebody->setPositionY(base->getContentSize().height);
createTreeModel();
scheduleUpdate();

}

void TreeModel::createTreeModel()

{
Treebody->removeAllChildren();
treeQueue.clear();
treeCache.clear();

Size visibleSize = Director::getInstance()->getVisibleSize();
float posY = 0;
bool isBase = true;
while (visibleSize.height*2>posY)
{
auto tree = TreeNode::createNode();
tree->setBranch(getBranch());
if(isBase)
{
posY += tree->getContentSize().height/2;
isBase = false;
}
else
{
posY += tree->getContentSize().height;
}
tree->setPositionY(posY);
Treebody->addChild(tree);
treeQueue.pushBack(tree);
}

}

void TreeModel::update(float time)

{
for (int idx=1;idx<treeQueue.size();idx++)
{
auto protree = treeQueue.at(idx-1);
auto tree = treeQueue.at(idx);
tree->setPositionY(protree->getPositionY()+protree->getContentSize().height);
}

}

TreeNode* TreeModel::deleteTreeHeadNode()

{
auto tree = treeQueue.at(0);
treeQueue.erase(0);
treeCache.pushBack(tree);
TreeNode *nextTree;
if( treeCache.size()>10 )
{
nextTree = treeCache.at(0);
Treebody->removeChild(nextTree);
treeCache.erase(0);
nextTree->setPositionX(0);
nextTree->setRotation3D(Vec3(0,0,0));
}
else
{
nextTree = TreeNode::createNode();
}
Treebody->addChild(nextTree);
nextTree->setBranch(getBranch());
treeQueue.pushBack(nextTree);
Treebody->reorderChild(tree,Treebody->getChildrenCount()+10);
auto head = treeQueue.at(0);
head->runAction( Sequence::create(MoveTo::create(0.06,Vec2(0,tree->getPositionY()))
,nullptr));
return tree;

}

TreeBranchDirection TreeModel::getBranch()

{
auto isBranch = CCRANDOM_0_1()*10 < 7;
if( treeQueue.size() == 0 )
return DEFINE;
if( !isBranch ) return DEFINE;
auto protree = treeQueue.at(treeQueue.size()-1);
switch (protree->getHasBranch())
{
case LEFT:
return (CCRANDOM_0_1()*10 < 5) ? DEFINE : LEFT;
break;
case RIGHT:
return (CCRANDOM_0_1()*10 < 5) ? DEFINE : RIGHT;
break;
case DEFINE:
return getAgainBranch();
break;
default:
return DEFINE;
break;
}

}

TreeBranchDirection TreeModel::getAgainBranch()

{
if( treeQueue.size() < 2 )
return DEFINE;
auto protree = treeQueue.at(treeQueue.size()-2);
switch (protree->getHasBranch())
{
case LEFT:
return (CCRANDOM_0_1()*10 < 6) ? RIGHT : LEFT;
break;
case RIGHT:
return (CCRANDOM_0_1()*10 < 6) ? LEFT : RIGHT;
break;
case DEFINE:
return (CCRANDOM_0_1()*10 < 4) ? LEFT : RIGHT;
break;
default:
return DEFINE;
break;
}

}

TreeBranchDirection TreeModel::getFirstBranch()

{
return treeQueue.front()->getHasBranch();

}

void TreeModel::onReset()

{
createTreeModel();

}

#ifndef __GameOver__

#define __GameOver__

#include "cocos2d.h"

USING_NS_CC;

using namespace std;

class GameOver : public Layer

{

public:
static GameOver* getInstance();
void setScore(int score);
std::function<void()> callBackFun;

private:
void onCallBack();
void initLayer();

Sprite* newScore;
LabelBMFont* _newScore;
LabelBMFont* _highestScore;

};

#endif

#include "GameOver.h"

static GameOver* _layer = nullptr;

GameOver* GameOver::getInstance()

{
if(!_layer)
{
_layer = new GameOver();
_layer->initLayer();
_layer->setScale(0.5);
}
return _layer;

}

void GameOver::initLayer()

{
auto bg = Sprite::create("over.png");
this->addChild(bg);
this->setContentSize(Size(bg->getContentSize().width
,bg->getContentSize().height));
_newScore = LabelBMFont::create("99999", "fonts/font-issue1343.fnt");
_highestScore = LabelBMFont::create("99999", "fonts/font-issue1343.fnt");
this->addChild(_newScore);
this->addChild(_highestScore );
_highestScore->setPositionY(-100);
auto play = MenuItemImage::create(
"play.png",
"play.png",
CC_CALLBACK_0(GameOver::onCallBack, this));
auto menu = Menu::create(play, NULL);
this->addChild(menu);
menu->setPosition(0,play->getContentSize().height-bg->getContentSize().height/2);

newScore = Sprite::create("newScore.png");
this->addChild(newScore);
newScore->setPositionY(newScore->getContentSize().width/3);

}

void GameOver::onCallBack()

{
if(callBackFun)
callBackFun();
this->setVisible(false);

}

void GameOver::setScore(int score)

{
int maxScore = score;
char string[50] = {0};
sprintf(string, "Score %d", score);
_newScore->setString(string);

maxScore = UserDefault::getInstance()->getIntegerForKey("maxScore");
if( maxScore < score )
{
UserDefault::getInstance()->setIntegerForKey("maxScore",score);
}
newScore->setVisible(( maxScore < score ));
char str2[50] = {0};
sprintf(str2, "Max Score %d", ( maxScore < score ) ? score : maxScore);
_highestScore->setString(str2);

UserDefault::getInstance()->flush();

}

#ifndef __GameScore__

#define __GameScore__

#include "cocos2d.h"

USING_NS_CC;

class GameScore : public Layer

{

public:
static GameScore* createScore();
void initScore();
std::function<void()> callBackFun;
void setScore(int score);
void onReset();

private:
Sprite* _blood;
int _score;
float _speed;
int _addPre;
int _levelNum;
Node* _level;
LabelBMFont* _scoreLabel;
ProgressTimer* progress;

void callBack();
void setLevel();

};

#endif

#include "GameScore.h"

GameScore* GameScore::createScore()

{
auto timber = new GameScore();
timber->initScore();
timber->setScale(0.5);
return timber;

}

void GameScore::initScore()

{
auto bg  = Sprite::create("blood_bg.png");
addChild(bg);
_score = 0;
_speed=0.02;
_addPre = 20;
_levelNum = 0;

progress = ProgressTimer::create(Sprite::create("blood.png"));
progress->setType(ProgressTimer::Type::BAR);
progress->setPercentage(100);
progress->setMidpoint(Vec2(0,0));
progress->setBarChangeRate(Vec2(1,0));
addChild(progress);

_scoreLabel = LabelBMFont::create("0", "fonts/font-issue1343.fnt");
this->addChild(_scoreLabel);

_level = Node::create();
auto lev = Sprite::create("level.png");
_level->addChild(lev,0);
auto lab = LabelBMFont::create("0", "fonts/font-issue1343.fnt");
lab->setPosition(lev->getContentSize().width/2+50,10);
lab->setScale(1.5);
_level->addChild(lab,1,"level");
this->addChild(_
abed
level);
_level->setVisible(false);

}

void GameScore::callBack()

{
if(callBackFun)
callBackFun();

}

void GameScore::setScore(int score)

{
_score = score;
int num = _score/20;
if( num>20 ) num = 20;
progress->stopAllActions();
int pro = progress->getPercentage()+_addPre - num*0.5;
if( pro > 100 ) pro = 100;
char string[12] = {0};
sprintf(string, "%d", score);

_scoreLabel->setString(string);
progress->setPercentage(pro);

auto to1 = Sequence::create(ProgressTo::create(_speed*pro, 0),CallFunc::create(CC_CALLBACK_0(GameScore::callBack,this)),nullptr);
progress->runAction(to1);
setLevel();

}

void GameScore::setLevel()

{
int num = _score/20;
if( num > _levelNum )
{
_levelNum = _score/20;
auto lab = static_cast<LabelBMFont*>(_level->getChildByName("level"));
char string[12] = {0};
sprintf(string, "%d", _levelNum);
lab->setString(string);
_level->setPosition(Vec2(0,0));
_level->setVisible(true);
_level->runAction(Sequence::create(MoveBy::create(0.7,Vec2(0,200)),Hide::create(),nullptr));
}

}

void GameScore::onReset()

{
_score = 0;
_speed=0.02;
_addPre = 20;
_levelNum = 0;

progress->stopAllActions();
progress->setPercentage(100);
auto to1 = Sequence::create(ProgressTo::create(_speed*100, 0),CallFunc::create(CC_CALLBACK_0(GameScore::callBack,this)),nullptr);
progress->runAction( to1);
char string[12] = {0};
sprintf(string, "%d", 0);
_scoreLabel->setString(string);

}