您的位置:首页 > 移动开发 > Cocos引擎

Cocos2d-x简单游戏<植物大战僵尸>代码实现|第九部分:游戏场景GameScene.cpp<后续会提供源码下载链接>

2014-03-17 17:49 1001 查看
这个植物大战僵尸的小游戏Demo 虽然下,但是基本包括了:

1.植物的选取、僵尸的攻击、发射子弹;

2.太阳的生成、碰撞检测等功能;





第一部分:Cocos2d-x简单游戏<植物大战僵尸>代码实现|第一部分:开始场景

第二部分:Cocos2d-x简单游戏<植物大战僵尸>代码实现|第二部分:菜单场景

第三部分:Cocos2d-x简单游戏<植物大战僵尸>代码实现|第三部分:通关场景

第四部分:Cocos2d-x简单游戏<植物大战僵尸>代码实现|第四部分:通关失败场景

第五部分:Cocos2d-x简单游戏<植物大战僵尸>代码实现|第五部分:公用类

第六部分:Cocos2d-x简单游戏<植物大战僵尸>代码实现|第六部分:植物类

第七部分:Cocos2d-x简单游戏<植物大战僵尸>代码实现|第七部分:僵尸类

第八部分:Cocos2d-x简单游戏<植物大战僵尸>代码实现|第八部分:子弹类

第九部分<A>:Cocos2d-x简单游戏<植物大战僵尸>代码实现|第九部分:游戏场景GameScene.h
第九部分<B>:Cocos2d-x简单游戏<植物大战僵尸>代码实现|第九部分:游戏场景GameScene.cpp

#include "GameScene.h"

#include "SimpleAudioEngine.h"

#include "Plants.h"

#include "BaseData.h"

#include "Bullets.h"

#include "PassScene.h"

#include "FailScene.h"

using namespace
cocos2d;

using namespace
std;

using namespace
CocosDenshion;

USING_NS_CC;

CCScene* GameScene::scene()
{
CCScene *scene =
CCScene::create();
GameScene *layer =
GameScene::create();
scene->addChild(layer);
return scene;
}

boolGameScene::init()
{

INIT_CCLAYER_FUNC;

CCSpriteFrameCache* cache=CCSpriteFrameCache::sharedSpriteFrameCache();

cache->addSpriteFramesWithFile("Sun_default.plist");

CCSize size =CCDirector::sharedDirector()->getWinSize();

menuSprite =CCSprite::create("SeedChooser_Background.png");

menuSprite->setScale(1.5f);
menuSprite->setPosition(ccp(170, -120));
this->addChild(menuSprite,1);

char backgroundLevel[20];
sprintf(backgroundLevel,
"level%d.jpg",LEVEL);
pSprite =
CCSprite::create(backgroundLevel);
pSprite->setScale(1.5f);
pSprite->setPosition(ccp(size.width/2+260,size.height/2));
this->addChild(pSprite,0);

//创建YourHouse文字
CCSprite* yourhouse =
CCSprite::create("your house.png");
yourhouse->setScale(1.5f);
yourhouse->setScaleY(2);
yourhouse->setPosition(ccp(size.width/2, size.height/2));
this->addChild(yourhouse,1);
CCBlink* blink =
CCBlink::create(2,3);

CCCallFuncN* func =CCCallFuncN::create(this,callfuncN_selector(GameScene::removeSprite));
CCSequence* seq4 =
CCSequence::create(blink, func,
NULL);
yourhouse->runAction(seq4);

//移动场景
CCMoveTo* moveto =
CCMoveTo::create(2,ccp(size.width/2-130,size.height/2));
CCSequence* seq3 =
CCSequence::create(CCDelayTime::create(2), moveto,NULL);
pSprite->runAction(seq3);

//添加菜单
this->addMenu();

//菜单移动
barMenuSprite = CCSprite::create("barMenu1.png");
barMenuSprite->setScale(1.5f);

// barMenuSprite->setScaleX(1.2);

// barMenuSprite->setScaleY(1.4);
barMenuSprite->setPosition(ccp(140,350));
CCMoveTo* moveToBarMenu = CCMoveTo::create(2, ccp(141,295));
this->addChild(barMenuSprite,
1);
CCSequence* seq1 = CCSequence::create(CCDelayTime::create(2), moveToBarMenu,NULL);
barMenuSprite->runAction(seq1);

CCMoveTo* moveToMenu = CCMoveTo::create(2, ccp(170,120));
CCSequence* seq2 = CCSequence::create(CCDelayTime::create(2), moveToMenu,NULL);
menuSprite->runAction(seq2);

//添加太阳图标
CCSprite* sun2Sprite = CCSprite::create("sun2.png");

//sun2Sprite->setPosition(ccp(40,288));
sun2Sprite->setPosition(ccp(35,30));
sun2Sprite->setScaleY(0.8);
sun2Sprite->setScaleX(0.9);
barMenuSprite->addChild(sun2Sprite);

//添加太阳显示图标
CCSprite* sunNumSprite = CCSprite::create("sunNum.png");
sunNumSprite->setPosition(ccp(35,10));
sunNumSprite->setScaleY(0.5);
barMenuSprite->addChild(sunNumSprite,2);

//初始化数组
plantsMenuArray = CCArray::create();
plantsMenuArray->retain();

plantsSpriteArray = CCArray::create();
plantsSpriteArray->retain();

plantsArray = CCArray::create();
plantsArray->retain();

zoombieArray = CCArray::create();
zoombieArray->retain();

carArray = CCArray::create();
carArray->retain();

beforeZombie = CCArray::create();
beforeZombie->retain();
this->initFlag();

//初始化子弹数组
bulletArray = CCArray::create();
bulletArray->retain();

//初始化太阳的个数

//SunNumber = 500;
sunNumberLB = CCLabelTTF::create("50","Verdana-Bold",
15);
sunNumberLB->setPosition(ccp(20,10));
sunNumberLB->setScaleY(1.4);
sunNumberLB->setColor(ccc3(0,0,
255));
sunNumSprite->addChild(sunNumberLB,2);

//注册触摸代理
CCDirector::sharedDirector()->getTouchDispatcher()->addTargetedDelegate(this,0,
false);

//时间调度
this->schedule(schedule_selector(GameScene::createSunshine),1);//产生阳光
this->schedule(schedule_selector(GameScene::createShoote),0.6);//产生子弹
this->schedule(schedule_selector(GameScene::setSunNumberLB),0.1);

plantsIsPlanted =true;

this->LevelBar();
this->initBeforeZombie();

//this->schedule(schedule_selector(GameScene::setLevelBar), 1);

//关卡显示
CCLabelTTF* labelLevel = CCLabelTTF::create(" ","TrebuchetMS",
20);
char label[20];
sprintf(label,"第 %d 关",
LEVEL);
labelLevel->setPosition(ccp(420,270));
labelLevel->setColor(ccc3(255,0,
0));
this->addChild(labelLevel);
labelLevel->setString(label);

return
true;
}

void GameScene::setSunNumberLB()
{
sprintf(sunNum,"%d", SunNumber);
sunNumberLB->setString(sunNum);
}

void GameScene::removeSprite(cocos2d::CCSprite *sprite)
{
sprite->removeFromParent();
}

void GameScene::plantsMenu(CCNode* object)
{
int plantsTag = object->getTag();
CCMenuItemToggle* plantsToggle = (CCMenuItemToggle*)object;

CCSprite* cherry;
CCSprite* chomper;
CCSprite* jalapeno;
CCSprite* lilypad;
CCSprite* peashooter;
CCSprite* repeater;
CCSprite* squash;
CCSprite* sunflower;
CCSprite* tallnut;
CCSprite* threepeater;
CCSprite* wallnut;
if (plantsMenuArray->count()<6) {
switch (plantsTag) {
case CHERRY:
cherry = CCSprite::create("CherryBomb.png");
cherry->setPosition(ccp(30,190));
cherry->setScale(0.4);
plantsSpriteArray->addObject(cherry);
cherry->setTag(501);
this->addChild(cherry,
1);
plantsToggle->setEnabled(false);//菜单按钮不可用
break;
case CHOMPER:
chomper = CCSprite::create("Chomper.png");
chomper->setPosition(ccp(80,190));
chomper->setScale(0.4);
plantsSpriteArray->addObject(chomper);
chomper->setTag(502);
this->addChild(chomper,
1);
plantsToggle->setEnabled(false);//菜单按钮不可用
break;
case JALAPENO:
jalapeno = CCSprite::create("Jalapeno.png");
jalapeno->setPosition(ccp(130,190));
jalapeno->setScale(0.4);
plantsSpriteArray->addObject(jalapeno);
jalapeno->setTag(503);
this->addChild(jalapeno,
1);
plantsToggle->setEnabled(false);//菜单按钮不可用
break;
case LILYPAD:
lilypad = CCSprite::create("LilyPad.png");
lilypad->setPosition(ccp(190,190));
lilypad->setScale(0.4);
plantsSpriteArray->addObject(lilypad);
lilypad->setTag(504);
this->addChild(lilypad,
1);
plantsToggle->setEnabled(false);//菜单按钮不可用
break;
case PEASHOOTER:
peashooter = CCSprite::create("PeaShooter.png");
peashooter->setPosition(ccp(245,190));
peashooter->setScale(0.4);
plantsSpriteArray->addObject(peashooter);
peashooter->setTag(505);
this->addChild(peashooter,
1);
plantsToggle->setEnabled(false);//菜单按钮不可用
break;
case REPEATER:
repeater = CCSprite::create("Repeater.png");
repeater->setPosition(ccp(300,190));
repeater->setScale(0.4);
plantsSpriteArray->addObject(repeater);
repeater->setTag(506);
this->addChild(repeater,
1);
plantsToggle->setEnabled(false);//菜单按钮不可用
break;
case SQUASH:
squash = CCSprite::create("Squash.png");
squash->setPosition(ccp(30,130));
squash->setScale(0.4);
plantsSpriteArray->addObject(squash);
squash->setTag(507);
this->addChild(squash,
2);
plantsToggle->setEnabled(false);//菜单按钮不可用
break;
case SUNFLOWER:
sunflower = CCSprite::create("SunFlower.png");
sunflower->setPosition(ccp(80,130));
sunflower->setScale(0.4);
plantsSpriteArray->addObject(sunflower);
sunflower->setTag(508);
this->addChild(sunflower,
2);
plantsToggle->setEnabled(false);//菜单按钮不可用
break;
case TALLNUA:
tallnut = CCSprite::create("TallNut.png");
tallnut->setPosition(ccp(130,130));
tallnut->setScale(0.4);
plantsSpriteArray->addObject(tallnut);
tallnut->setTag(509);
this->addChild(tallnut,
2);
plantsToggle->setEnabled(false);//菜单按钮不可用
break;
case THREEPEATER:
threepeater = CCSprite::create("Threepeater.png");
threepeater->setPosition(ccp(190,130));
threepeater->setScale(0.4);
plantsSpriteArray->addObject(threepeater);
threepeater->setTag(510);
this->addChild(threepeater,
2);
plantsToggle->setEnabled(false);//菜单按钮不可用
break;
case WALLNUA:
wallnut = CCSprite::create("WallNut.png");
wallnut->setPosition(ccp(250,130));
wallnut->setScale(0.4);
plantsSpriteArray->addObject(wallnut);
wallnut->setTag(511);
this->addChild(wallnut,
2);
plantsToggle->setEnabled(false);//菜单按钮不可用
break;
default:
break;
}

}
if(plantsMenuArray->count()<6)
{
CCMenuItemToggle* toggleItem;
if (plantsTag>=101 && plantsTag<=111)
{
switch (plantsTag) {
case CHERRY:
toggleItem =this->createMenuItem1("CherryBomb.png","CherryBomb
副本.png",201);
toggleItem->setScale(0.8);
break;
case CHOMPER:
toggleItem =this->createMenuItem1("Chomper.png","Chomper
副本.png",202);
toggleItem->setScale(0.8);
break;
case JALAPENO:
toggleItem =this->createMenuItem1("Jalapeno.png","Jalapeno
副本.png",203);
toggleItem->setScale(0.8);
break;
case LILYPAD:
toggleItem =this->createMenuItem1("LilyPad.png","LilyPad
副本.png",204);
toggleItem->setScale(0.8);
break;
case PEASHOOTER:
toggleItem =this->createMenuItem1("PeaShooter.png","PeaShooter
副本.png",205);
toggleItem->setScale(0.8);
break;
case REPEATER:
toggleItem =this->createMenuItem1("Repeater.png","Repeater
副本.png",206);
toggleItem->setScale(0.8);
break;
case SQUASH:
toggleItem =this->createMenuItem1("Squash.png","Squash
副本.png",207);
toggleItem->setScale(0.8);
break;
case SUNFLOWER:
toggleItem =this->createMenuItem1("SunFlower.png","SunFlower
副本.png",208);
toggleItem->setScale(0.8);
break;
case TALLNUA:
toggleItem =this->createMenuItem1("TallNut.png","TallNut
副本.png",209);
toggleItem->setScale(0.8);
break;
case THREEPEATER:
toggleItem =this->createMenuItem1("Threepeater.png","Threepeater
副本.png",210);
toggleItem->setScale(0.8);
break;
case WALLNUA:
toggleItem =this->createMenuItem1("WallNut.png","WallNut
副本.png",211);
toggleItem->setScale(0.8);
break;
default:
break;
}
plantsMenuArray->addObject(toggleItem);
for (int i =1; i<7; i++)
{
if(plantsMenuArray->count() ==i)
{
CCSprite* sprite = (CCSprite*)plantsSpriteArray->objectAtIndex(i-1);
CCJumpTo* jumpTo = CCJumpTo::create(0.7, ccp(80+(i-1)*35,300),
70, 1);
sprite->runAction(jumpTo);
plantsToggle->setTag(plantsTag+100);
}
}
}
}

}

void GameScene::plantingPlant(cocos2d::CCNode *plant)
{
CCMenuItemToggle* plantToggle = (CCMenuItemToggle*)plant;
int plantsTag = plant->getTag();
Plants* thePlant;
switch (plantsTag) {
case CHERRY+100:
SunNumber -=150;
cherryCoolTime=5;
plantToggle->setSelectedIndex(1);
plantToggle->setEnabled(false);
thePlant =new Plants(Cherry);
plantsArray->addObject(thePlant);
plantsIsPlanted =false;
break;
case CHOMPER+100:
SunNumber -=150;
chomperCoolTime=7;
plantToggle->setSelectedIndex(1);
plantToggle->setEnabled(false);
thePlant =new Plants(CorpseFlower);
plantsArray->addObject(thePlant);
plantsIsPlanted =false;
break;
case JALAPENO+100:
SunNumber -=125;
jalapenoCoolTime=5;
plantToggle->setSelectedIndex(1);
plantToggle->setEnabled(false);
thePlant =new Plants(Paprika);
plantsArray->addObject(thePlant);
plantsIsPlanted =false;
break;
case LILYPAD+100:
SunNumber -=25;
lilypadCoolTime=5;
plantToggle->setSelectedIndex(1);
plantToggle->setEnabled(false);
thePlant =new Plants(Lilypad);
plantsArray->addObject(thePlant);
plantsIsPlanted =false;
break;
case PEASHOOTER+100:
SunNumber -=100;
peashooterCoolTime=5;
plantToggle->setSelectedIndex(1);
plantToggle->setEnabled(false);
thePlant =new Plants(SmallPea);
thePlant->setPosition(ccp(0, -100));//解决在点击菜单后,没有种植时,子弹从ccp(0,0)位置飞出的情况
plantsArray->addObject(thePlant);
plantsIsPlanted =false;
break;
case REPEATER+100:
SunNumber -=200;
repeaterCoolTime=5;
plantToggle->setSelectedIndex(1);
plantToggle->setEnabled(false);
thePlant =new Plants(MidllePea);
thePlant->setPosition(ccp(0, -100));//解决在点击菜单后,没有种植时,子弹从ccp(0,0)位置飞出的情况
plantsArray->addObject(thePlant);
plantsIsPlanted =false;
break;
case SQUASH+100:
SunNumber -=50;
squashCoolTime=5;
plantToggle->setSelectedIndex(1);
plantToggle->setEnabled(false);
thePlant =new Plants(Pumpkin);
plantsArray->addObject(thePlant);
plantsIsPlanted =false;
break;
case SUNFLOWER+100:
SunNumber -=50;
sunflowerCoolTime=5;
plantToggle->setSelectedIndex(1);
plantToggle->setEnabled(false);
thePlant =new Plants(Sunflower);
thePlant->setPosition(ccp(0, -100));//解决在点击菜单后,没有种植时,子弹从ccp(0,0)位置飞出的情况
plantsArray->addObject(thePlant);
plantsIsPlanted =false;
break;
case TALLNUA+100:
SunNumber -=125;
tallnutCoolTime=5;
plantToggle->setSelectedIndex(1);
plantToggle->setEnabled(false);
thePlant =new Plants(largeNut);
plantsArray->addObject(thePlant);
plantsIsPlanted =false;
break;
case THREEPEATER+100:
SunNumber -=325;
threepeaterCoolTime=5;
plantToggle->setSelectedIndex(1);
plantToggle->setEnabled(false);
thePlant =new Plants(ThreeBulletPea);
thePlant->setPosition(ccp(0, -100));//解决在点击菜单后,没有种植时,子弹从ccp(0,0)位置飞出的情况
plantsArray->addObject(thePlant);
plantsIsPlanted =false;
break;
case WALLNUA+100:
SunNumber -=50;
wallnutCooltime=5;
plantToggle->setSelectedIndex(1);
plantToggle->setEnabled(false);
thePlant =new Plants(SmallNut);
plantsArray->addObject(thePlant);
plantsIsPlanted =false;
break;
default:
break;
}

}

CCMenuItemToggle* GameScene::createMenuItem(constchar* plantName1,
const char* plantName2,
int tag)
{
CCMenuItemImage* image = CCMenuItemImage::create(plantName1, plantName1);
image->setScale(0.5);
CCMenuItemImage* image1 = CCMenuItemImage::create(plantName2, plantName2);
image1->setScale(0.5);
CCMenuItemToggle* toggle = CCMenuItemToggle::createWithTarget(this, menu_selector(GameScene::plantsMenu), image,image1,NULL);
toggle->setTag(tag);
return toggle;
}

CCMenuItemToggle* GameScene::createMenuItem1(constchar* plantName1,
const char* plantName2,
int tag)
{
CCMenuItemImage* image = CCMenuItemImage::create(plantName1, plantName1);
image->setScale(0.5);
CCMenuItemImage* image1 = CCMenuItemImage::create(plantName2, plantName2);
image1->setScale(0.5);
CCMenuItemToggle* toggle = CCMenuItemToggle::createWithTarget(this, menu_selector(GameScene::plantingPlant), image,image1,NULL);
toggle->setTag(tag);
return toggle;
}

void GameScene::moveScenePosition()
{
CCMoveTo* moveTo = CCMoveTo::create(2, ccp(270,160));
pSprite->runAction(moveTo);
}

void GameScene::sunAction()
{

// //阳光

// CCSprite* sunSprite = CCSprite::createWithSpriteFrameName("Sun-1(被拖移).tiff");

// sunSprite->setPosition(ccp(240, 160));

// sunSprite->setScale(0.5);

// this->addChild(sunSprite);

// CCArray* sunArray = CCArray::create();

// sunArray->retain();

// CCSpriteFrameCache* cache = CCSpriteFrameCache::sharedSpriteFrameCache();

// char name[50];

// for (int i = 1; i<23; i++) {

// sprintf(name, "Sun-%i(被拖移).tiff", i);

// CCSpriteFrame* frame = cache->spriteFrameByName(name);

// sunArray->addObject(frame);

// }

// CCAnimation* animation = CCAnimation::createWithSpriteFrames(sunArray,0.3);

// CCAnimate* animate = CCAnimate::create(animation);

// sunSprite->runAction(CCRepeatForever::create(animate));

// sunArray->release();
}

void GameScene::addMenu()
{

//添加樱桃
CCMenuItemToggle* toggleCherry =this->createMenuItem("CherryBomb.png","CherryBomb
副本.png",101);
toggleCherry->setSelectedIndex(0);//设置成彩色的;

//添加食人花
CCMenuItemToggle* toggleChomper =this->createMenuItem("Chomper.png","Chomper
副本.png",102);

//添加尖椒
CCMenuItemToggle* toggleJalapeno =this->createMenuItem("Jalapeno.png","Jalapeno
副本.png",103);

//添加荷叶
CCMenuItemToggle* toggleLilyPad =this->createMenuItem("LilyPad.png","LilyPad
副本.png",104);

//添加射豆枪(100)
CCMenuItemToggle* togglePeaShooter =this->createMenuItem("PeaShooter.png","PeaShooter
副本.png",105);

//添加射豆枪(200)
CCMenuItemToggle* toggleRepeater =this->createMenuItem("Repeater.png","Repeater
副本.png",106);

//添加南瓜
CCMenuItemToggle* toggleSquash =this->createMenuItem("Squash.png","Squash
副本.png",107);

//添加向日葵
CCMenuItemToggle* toggleSunFlower =this->createMenuItem("SunFlower.png","SunFlower
副本.png",108);

//添加坚果
CCMenuItemToggle* toggleTallNut =this->createMenuItem("TallNut.png","TallNut
副本.png",109);

//添加三枪射豆枪
CCMenuItemToggle* toggleThreepeater =this->createMenuItem("Threepeater.png","Threepeater
副本.png",110);

//添加坚果墙
CCMenuItemToggle* toggleWallNut =this->createMenuItem("WallNut.png","WallNut
副本.png",111);

//添加重置按钮
CCMenuItemImage* selectReset = CCMenuItemImage::create("selectReset0.png","selectReset1.png");
selectReset->setTarget(this, menu_selector(GameScene::resetBarMenu));

//添加确定按钮
CCMenuItemImage* selectSure = CCMenuItemImage::create("selectSure0.png","selectSure1.png");
selectSure->setTarget(this, menu_selector(GameScene::beSure));

CCMenu* menu1 = CCMenu::create(toggleCherry, toggleChomper, toggleJalapeno, toggleLilyPad, togglePeaShooter, toggleRepeater,NULL);
menu1->setPosition(ccp(170,190));
menu1->alignItemsHorizontallyWithPadding(-20);
menu1->setTag(601);
menuSprite->addChild(menu1);

CCMenu* menu2 = CCMenu::create(toggleSquash, toggleSunFlower, toggleTallNut, toggleThreepeater, toggleWallNut,NULL);
menu2->setPosition(ccp(140,120));
menu2->alignItemsHorizontallyWithPadding(-20);
menu2->setTag(602);
menuSprite->addChild(menu2);

CCMenu* menu3 = CCMenu::create(selectReset, selectSure,NULL);
menu3->setPosition(ccp(170,50));
menu3->alignItemsHorizontallyWithPadding(30);
menu3->setTag(603);
menuSprite->addChild(menu3);
}

void GameScene::resetBarMenu()
{
plantsMenuArray->removeAllObjects();
plantsSpriteArray->removeAllObjects();
menuSprite->removeChildByTag(601);
menuSprite->removeChildByTag(602);
menuSprite->removeChildByTag(603);
this->addMenu();
for (int i =501; i<512; i++) {
this->removeChildByTag(i);
}
}

void GameScene::beSure()
{
for (int i =501; i<512; i++) {
this->removeChildByTag(i);
}
CCMenu* menu = CCMenu::createWithArray(plantsMenuArray);
menu->setPosition(ccp(168,300));
menu->alignItemsHorizontallyWithPadding(-25);
this->addChild(menu,2);

//添加准备安放植物字体
CCSpriteFrameCache* cache = CCSpriteFrameCache::sharedSpriteFrameCache();
cache->addSpriteFramesWithFile("PrepareGrowPlants_default.plist");
CCSprite* fontSprite = CCSprite::createWithSpriteFrameName("PrepareGrowPlants1.tiff");
fontSprite->setPosition(ccp(240,160));
this->addChild(fontSprite);
char fontName[30];
CCArray* fontArray = CCArray::create();
fontArray->retain();
for (int i =1; i <=
3; i++)
{
sprintf(fontName,"PrepareGrowPlants%d.tiff", i);
CCSpriteFrame* frame = cache->spriteFrameByName(fontName);
fontArray->addObject(frame);
}
CCAnimation* animation = CCAnimation::createWithSpriteFrames(fontArray,0.8);
CCAnimate* animate = CCAnimate::create(animation);
CCCallFuncN* funcn = CCCallFuncN::create(this, callfuncN_selector(GameScene::removeSprite));
CCSequence* seq = CCSequence::create(CCDelayTime::create(2), animate, funcn,NULL);
fontSprite->runAction(seq);

for (int i =0; i < plantsMenuArray->count(); i++) {
CCMenuItemToggle* toggle = (CCMenuItemToggle*)plantsMenuArray->objectAtIndex(i);
if(toggle->getTag() ==
204)
{
toggle->setEnabled(true);
}
else
if(toggle->getTag() ==207)
{
toggle->setEnabled(true);
}
else
if(toggle->getTag() ==208)
{
toggle->setEnabled(true);
}
else
if(toggle->getTag() ==211)
{
toggle->setEnabled(true);
}
else
{
toggle->setSelectedIndex(1);
toggle->setEnabled(false);
}

}

CCMoveTo* moveTo = CCMoveTo::create(2.0, ccp(170, -150));
menuSprite->runAction(moveTo);
this->moveScenePosition();

//添加小车
CCCallFunc* funcar = CCCallFunc::create(this, callfunc_selector(GameScene::addCar));
CCSequence* seqcar = CCSequence::create(CCDelayTime::create(2), funcar,NULL);
this->runAction(seqcar);
this->removeBeforeZombie();

cherryCoolTime =5;
chomperCoolTime =7;
jalapenoCoolTime =5;
lilypadCoolTime =5;
peashooterCoolTime =5;
repeaterCoolTime =5;
squashCoolTime =5;
sunflowerCoolTime =2;
tallnutCoolTime =5;
threepeaterCoolTime =5;
wallnutCooltime =5;

timer = 0;//初始化控制僵尸数量的标志
productZombie =0;
this->schedule(schedule_selector(GameScene::appearZombie),1);
this->schedule(schedule_selector(GameScene::createSunshineWithoutSunflower),5);
this->schedule(schedule_selector(GameScene::checkHitWithBulletAndPlant),0.01);
this->schedule(schedule_selector(GameScene::judgeCoolTime),0.1);
this->schedule(schedule_selector(GameScene::reduceCoolTime),1);
this->schedule(schedule_selector(GameScene::checkHitOtherPlantsAndZombie),0.5);
this->schedule(schedule_selector(GameScene::checkFial),0.5);
this->schedule(schedule_selector(GameScene::checkHitCarWithZoombie),0.01);

//this->schedule(schedule_selector(GameScene::pass), 1);

}

bool GameScene::ccTouchBegan(CCTouch *pTouch, CCEvent *pEvent)
{
CCLog("%f, %f", pTouch->getLocation().x, pTouch->getLocation().y);

return
true;
}

void GameScene::ccTouchMoved(CCTouch *pTouch, CCEvent *pEvent)
{

}

void GameScene::ccTouchEnded(CCTouch *pTouch, CCEvent *pEvent)
{
int Flag =
this->getFlag(pTouch->getLocation());
if (Flag !=
1) {
CCPoint zeroPoint =this->getPositionMessage(pTouch->getLocation());
if(zeroPoint.x !=0 && zeroPoint.y !=0)
{
if(!plantsIsPlanted)
{
Plants* plant = (Plants*)plantsArray->objectAtIndex(plantsArray->count()-1);
if(plant->specialSkill == CollapseSkill)
{
plant->setAnchorPoint(ccp(0.5,0.2));
}
else
if(plant->specialSkill != ChimeaSkill && plant->specialSkill != BombSkill)
{
this->setFlagValue(pTouch->getLocation());
}
plant->setPosition(this->getPositionMessage(pTouch->getLocation()));
this->addChild(plant,
1);
plant =NULL;
plantsIsPlanted =true;
}
}

}

}

void GameScene::ccTouchCancelled(CCTouch *pTouch, CCEvent *pEvent)
{

}

void GameScene::onExit()
{
plantsMenuArray->release();
plantsSpriteArray->release();

// for(int i = 0; i < plantsArray->count(); i++)

// {

// delete plantsArray->objectAtIndex(i);

// }
plantsArray->release();
zoombieArray->release();
bulletArray->release();
carArray->release();
beforeZombie->release();
this->unscheduleAllSelectors();
}

CCPoint GameScene::getPositionMessage(cocos2d::CCPoint point)
{
for(int i =0; i <
9; i++)
{
if(point.x >= (20+i*46) && point.x <= (20+(i+1)*46))
{
for (int j =0; j <
5; j++)
{
if(point.y >= (15+j*53) && point.y <= (15+(j+1)*53))
{
return ccp((45+i*46), (45+j*53));

}
}
}
}
return ccp(0, -100);
}

void GameScene::initFlag()
{
for (int i =0; i <
9; i++) {
for (int j =0 ; j <
5; j++) {
flag[i][j] =0;
}
}
}

int GameScene::getFlag(CCPoint point)
{
for(int i =0; i <
9; i++)
{
if(point.x >= (20+i*46) && point.x <= (20+(i+1)*46))
{
for (int j =0; j <
5; j++)
{
if(point.y >= (15+j*53) && point.y <= (15+(j+1)*53))
{
return flag[i][j];
}
}
}
}
return
1;
}

void GameScene::setFlagValue(cocos2d::CCPoint point)
{
for(int i =0; i <
9; i++)
{
if(point.x >= (20+i*46) && point.x <= (20+(i+1)*46))
{
for (int j =0; j <
5; j++)
{
if(point.y >= (15+j*53) && point.y <= (15+(j+1)*53))
{
flag[i][j] =1;
}
}
}
}

}
void GameScene::setFlagValue1(cocos2d::CCPoint point)
{
for(int i =0; i <
9; i++)
{
if(point.x >= (20+i*46) && point.x <= (20+(i+1)*46))
{
for (int j =0; j <
5; j++)
{
if(point.y >= (15+j*53) && point.y <= (15+(j+1)*53))
{
flag[i][j] =0;
}
}
}
}

}

void GameScene::createSunshine()
{
if(plantsArray->count() !=
0)
{
for(int i =0; i < plantsArray->count(); i++)
{
Plants* plant = (Plants*)plantsArray->objectAtIndex(i);
if(plant->plantsName == Sunflower)
{
plant->createSunInterval--;
Bullet* bullet;
if(plant->createSunInterval ==
0)
{
bullet =new Bullet(plant, plant->getPosition(),
this);
plant->createSunInterval = plant->tempCreateSunInterval;
}
}
}
}
}

void GameScene::createShoote()
{
if(plantsArray->count() !=
0)
{
for(int i =0; i < plantsArray->count(); i++)
{
Plants* plant = (Plants*)plantsArray->objectAtIndex(i);
for(int j =0; j < zoombieArray->count(); j++)//检测当没有僵尸的时候植物不发射子弹
{
Zoombie* zoombie = (Zoombie*)zoombieArray->objectAtIndex(j);
CCPoint pPosition = plant->getPosition();
CCPoint zPosition = pSprite->convertToWorldSpace(zoombie->getPosition());//转换世界坐标
if(zPosition.x-pPosition.x<440 && zPosition.y == pPosition.y)
{
if(plant->plantsName != Sunflower)
{
plant->createPeaInterval--;
Bullet* bullet;
if(plant->createPeaInterval ==
0)
{
bullet =new Bullet(plant, plant->getPosition(),
this);
plant->createPeaInterval = plant->tempCreatePeaInterval;
}
}

}
}
}
}

}

void GameScene::addZoombie()
{
if(productZombie <= theZombieArray[LEVEL-1])
{
int random;
int randomPosition;
if(LEVEL ==
1)
{
randomPosition =2;
}
if(LEVEL ==
2)
{
do {
randomPosition = arc4random()%4;
}while (randomPosition ==
0 || randomPosition ==
4);

}
if(LEVEL >=
3)
{
randomPosition = arc4random()%5;
}

for (int i =1; i <= LEVEL; i++) {
if(LEVEL == i)
{
do {
random = arc4random()%(i+1);
}while (random >=
5);
}
}
Zoombie* zoombie;
switch (random) {
case
0:
zoombie =new Zoombie(Zombie);
zoombie->setPosition(ccp(580,45+randomPosition*53));
pSprite->addChild(zoombie);
zoombie->runZombieAction(zoombie->plistStr);
zoombieArray->addObject(zoombie);
zoombie->startMove();
this->setLevelBar();
productZombie++;
break;
case
2:
zoombie =new Zoombie(BucketheadZombie);
zoombie->setPosition(ccp(580,45+randomPosition*53));
pSprite->addChild(zoombie);
zoombie->runZombieAction(zoombie->plistStr);
zoombieArray->addObject(zoombie);
zoombie->startMove();
this->setLevelBar();
productZombie++;
break;
case
3:
zoombie =new Zoombie(ConeheadZombie);
zoombie->setPosition(ccp(580,45+randomPosition*53));
pSprite->addChild(zoombie);
zoombie->runZombieAction(zoombie->plistStr);
zoombieArray->addObject(zoombie);
zoombie->startMove();
this->setLevelBar();
productZombie++;
break;
case
1:
zoombie =new Zoombie(FlagZombie);
zoombie->setPosition(ccp(580,45+randomPosition*53));
pSprite->addChild(zoombie);
zoombie->runZombieAction(zoombie->plistStr);
zoombieArray->addObject(zoombie);
zoombie->startMove();
this->setLevelBar();
productZombie++;
break;
case
4:
zoombie =new Zoombie(PoleVaultingZombie);
zoombie->setPosition(ccp(580,45+randomPosition*53));
pSprite->addChild(zoombie);
zoombie->runZombieAction(zoombie->plistStr);
zoombieArray->addObject(zoombie);
zoombie->startMove();
this->setLevelBar();
productZombie++;
break;
default:
break;
}

}
}

void GameScene::checkHitWithBulletAndPlant()
{

CCArray* tempBulletArray = CCArray::create();//创建临时子弹数组,存放打中僵尸的子弹
tempBulletArray->retain();
CCArray* tempZoombieArray = CCArray::create();//存放被打中的僵尸
tempZoombieArray->retain();
CCArray* newZoombieArray = CCArray::create();//存放戴帽子的僵尸被击中一定次数后产生的新僵尸
newZoombieArray->retain();
CCArray* unHitBullet = CCArray::create();
unHitBullet->retain();
Bullet* bullet;
Zoombie* zoombie;
for(int i =0; i < bulletArray->count(); i++)
{
for (int j =0; j < zoombieArray->count(); j++)
{
bullet = (Bullet*)bulletArray->objectAtIndex(i);
zoombie = (Zoombie*)zoombieArray->objectAtIndex(j);
CCPoint bulletPoint = bullet->getPosition();
CCPoint zoombiePoint = pSprite->convertToWorldSpace(zoombie->getPosition());//因为僵尸是加在pSprite背景层上的,所以必须把pSprite转换为世界坐标,这样僵尸坐标才能正确显示;
if(zoombiePoint.x-bulletPoint.x>-20 && zoombiePoint.x-bulletPoint.x<10
&& bulletPoint.y-zoombiePoint.y>-30 && bulletPoint.y-zoombiePoint.y<40)
{
tempBulletArray->addObject(bullet);
bullet->removeFromParent();
zoombie->blood -=2;
if (zoombie->zoombieType == ConeheadZombie || zoombie->zoombieType == BucketheadZombie) {
if(zoombie->blood <=
0)
{
zoombie->removeFromParent();
tempZoombieArray->addObject(zoombie);
Zoombie* newzoombie =new Zoombie(Zombie);
newzoombie->setPosition(zoombie->getPosition());
pSprite->addChild(newzoombie);
newzoombie->startMove();
newZoombieArray->addObject(newzoombie);
}
}
if(zoombie->blood <=
0)
{
CCCallFunc* func1 = CCCallFunc::create(zoombie, callfunc_selector(Zoombie::runDieAction));
CCCallFuncN* func2 = CCCallFuncN::create(zoombie, callfuncN_selector(GameScene::removeSprite));
CCSequence* seq = CCSequence::create(func1, CCDelayTime::create(1), func2,NULL);
zoombie->runAction(seq);
tempZoombieArray->addObject(zoombie);
//this->pass();
//this->pass();
}

}
if(bullet->getPosition().x ==
500)
{
bullet = (Bullet*)bulletArray->objectAtIndex(i);
unHitBullet->addObject(bullet);
bullet->removeFromParent();
}

}
}

for (int i =0; i < tempBulletArray->count(); i++) {
bulletArray->removeObject(tempBulletArray->objectAtIndex(i));
}

for (int i =0 ; i < tempZoombieArray->count(); i++) {
zoombieArray->removeObject(tempZoombieArray->objectAtIndex(i));
}

for (int i =0; i < newZoombieArray->count(); i++) {
zoombieArray->addObject(newZoombieArray->objectAtIndex(i));
}

for (int i =0; i <unHitBullet->count() ; i++) {
bulletArray->removeObject(unHitBullet->objectAtIndex(i));
}

tempBulletArray->release();
tempZoombieArray->release();
newZoombieArray->release();
unHitBullet->release();

}

#warning marl
void GameScene::createSunshineWithoutSunflower(){
CCSprite* sunSprite1 = CCSprite::createWithSpriteFrameName("Sun-1(被拖移).tiff");
CCSprite* sunSprite2 = CCSprite::createWithSpriteFrameName("Sun-1(被拖移).tiff");
sunSprite1->setScale(0.5);
sunSprite2->setScale(0.5);
CCMenuItemSprite* itemsprite = CCMenuItemSprite::create(sunSprite1, sunSprite2);
CCMenu* menu = CCMenu::create(itemsprite,NULL);

int x;
int y;
do {
x = arc4random()%480;
}while (x <
70 || x >410);
do {
y = arc4random()%290;
}while (y <
70 || y >290);
menu->setPosition(ccp(x,340));
this->addChild(menu,
2);
itemsprite->setTarget(this, menu_selector(Bullet::collectSunshine));

CCArray* sunArray = CCArray::create();
sunArray->retain();
CCSpriteFrameCache* cache = CCSpriteFrameCache::sharedSpriteFrameCache();
char name[50];
for (int i =1; i<23; i++)
{
sprintf(name,"Sun-%i(被拖移).tiff",
i);
CCSpriteFrame* frame = cache->spriteFrameByName(name);
sunArray->addObject(frame);
}
CCAnimation* animation = CCAnimation::createWithSpriteFrames(sunArray,0.3);
CCAnimate* animate = CCAnimate::create(animation);
sunSprite1->runAction(CCRepeatForever::create(animate));//这里不能使用菜单精灵来执行runAction动作

CCMoveTo* moveTo = CCMoveTo::create(10, ccp(x, y));
menu->runAction(moveTo);

}

void GameScene::LevelBar()
{
CCSprite* levelProgress = CCSprite::create("FlagMeterLevelProgress.png");
levelProgress->setPosition(ccp(400,310));
levelProgress->setScaleY(1.1);
levelProgress->setScaleX(1.8);
this->addChild(levelProgress);

theLevelBar = CCControlSlider::create("timerBar1.png","timerBar2.png",
"timerBar3.png");
theLevelBar->setMinimumValue(4);
theLevelBar->setMaximumValue(theZombieArray[LEVEL-1]+4);
theLevelBar->setPosition(ccp(400,295));

//theLevelBar->setValue(4);
this->addChild(theLevelBar);

theLevelBarProgressBar =4;
}

void GameScene::setLevelBar()
{
theLevelBar->setValue(theLevelBarProgressBar);
theLevelBarProgressBar++;
}

void GameScene::appearZombie()
{
timer++;
if(timer <10)
{
if(timer ==
1)
{
this->schedule(schedule_selector(GameScene::addZoombie),5);
}
}
else
if(timer >=10 && timer<=20)
{
if(timer ==
10)
{
CCSprite* largeWave = CCSprite::create("LargeWave.png");
largeWave->setPosition(ccp(240,160));
this->addChild(largeWave);
CCBlink* blink = CCBlink::create(3,4);
CCCallFuncN* funcn = CCCallFuncN::create(this, callfuncN_selector(GameScene::removeSprite));
CCSequence* seq1 = CCSequence::create(blink,funcn,NULL);
largeWave->runAction(seq1);

CCCallFunc* func = CCCallFunc::create(this, callfunc_selector(GameScene::appearZombie1));
CCSequence* seq2 = CCSequence::create(CCDelayTime::create(3), func,NULL);
this->runAction(seq2);

}
}
else
if(timer >20)
{
if(timer ==
21)
{
CCSprite* finalWave = CCSprite::create("FinalWave.png");
finalWave->setPosition(ccp(240,160));
this->addChild(finalWave);
CCBlink* blink = CCBlink::create(3,4);
CCCallFuncN* funcn = CCCallFuncN::create(this, callfuncN_selector(GameScene::removeSprite));
CCSequence* seq1 = CCSequence::create(blink,funcn,NULL);
finalWave->runAction(seq1);

CCCallFunc* func = CCCallFunc::create(this, callfunc_selector(GameScene::appearZombie2));
CCSequence* seq2 = CCSequence::create(CCDelayTime::create(3), func,NULL);
this->runAction(seq2);
this->schedule(schedule_selector(GameScene::pass),1);
}
}
}

void GameScene::appearZombie1()
{
this->unschedule(schedule_selector(GameScene::addZoombie));
this->schedule(schedule_selector(GameScene::addZoombie),3);
}

void GameScene::appearZombie2()
{
this->unschedule(schedule_selector(GameScene::addZoombie));
this->schedule(schedule_selector(GameScene::addZoombie),2);
}

void GameScene::pass()
{
if(zoombieArray->count() <=
0)

{

//this->unscheduleAllSelectors();
CCCallFunc* func = CCCallFunc::create(this, callfunc_selector(GameScene::changeSuccessScene));
CCSequence* seq = CCSequence::create(CCDelayTime::create(2), func,NULL);
this->runAction(seq);
}

}

void GameScene::judgeCoolTime()
{
for (int j =0; j < plantsMenuArray->count(); j++)
{
CCMenuItemToggle* toggle = (CCMenuItemToggle*)plantsMenuArray->objectAtIndex(j);
switch (toggle->getTag())
{
case CHERRY+100:
if(cherryCoolTime ==
0 && SunNumber >=
150)
{
toggle->setSelectedIndex(0);
toggle->setEnabled(true);
}
else
if(SunNumber <150)
{
toggle->setEnabled(false);
toggle->setSelectedIndex(1);
}
break;
case CHOMPER+100:
if(chomperCoolTime ==
0 && SunNumber >=
150)
{
toggle->setSelectedIndex(0);
toggle->setEnabled(true);
}
else
if(SunNumber <150)
{
toggle->setEnabled(false);
toggle->setSelectedIndex(1);
}
break;
case JALAPENO+100:
if(jalapenoCoolTime ==
0 && SunNumber >=
125)
{
toggle->setSelectedIndex(0);
toggle->setEnabled(true);
}
else
if(SunNumber <125)
{
toggle->setEnabled(false);
toggle->setSelectedIndex(1);
}

break;
case LILYPAD+100:
if(lilypadCoolTime ==
0 && SunNumber >=
25)
{
toggle->setSelectedIndex(0);
toggle->setEnabled(true);
}
else
if(SunNumber <25)
{
toggle->setEnabled(false);
toggle->setSelectedIndex(1);
}

break;
case PEASHOOTER+100:
if(peashooterCoolTime ==
0 && SunNumber >=
100)
{
toggle->setSelectedIndex(0);
toggle->setEnabled(true);
}
else
if(SunNumber <100)
{
toggle->setEnabled(false);
toggle->setSelectedIndex(1);
}

break;
case REPEATER+100:
if(repeaterCoolTime ==
0 && SunNumber >=
200)
{
toggle->setSelectedIndex(0);
toggle->setEnabled(true);
}
else
if(SunNumber <200)
{
toggle->setEnabled(false);
toggle->setSelectedIndex(1);
}

break;
case SQUASH+100:
if(squashCoolTime ==
0 && SunNumber >=
50)
{
toggle->setSelectedIndex(0);
toggle->setEnabled(true);
}
else
if(SunNumber <50)
{
toggle->setEnabled(false);
toggle->setSelectedIndex(1);
}

break;
case SUNFLOWER+100:
if(sunflowerCoolTime ==
0 && SunNumber >=
50)
{
toggle->setSelectedIndex(0);
toggle->setEnabled(true);
}
else
if(SunNumber <50)
{
toggle->setEnabled(false);
toggle->setSelectedIndex(1);
}

break;
case TALLNUA+100:
if(tallnutCoolTime ==
0 && SunNumber >=
125)
{
toggle->setSelectedIndex(0);
toggle->setEnabled(true);
}
else
if(SunNumber <125)
{
toggle->setEnabled(false);
toggle->setSelectedIndex(1);
}

break;
case THREEPEATER+100:
if(threepeaterCoolTime ==
0 && SunNumber >=
325)
{
toggle->setSelectedIndex(0);
toggle->setEnabled(true);
}
else
if(SunNumber <325)
{
toggle->setEnabled(false);
toggle->setSelectedIndex(1);
}

break;
case WALLNUA+100:
if(wallnutCooltime ==
0 && SunNumber >=
50)
{
toggle->setSelectedIndex(0);
toggle->setEnabled(true);
}
else
if(SunNumber <50)
{
toggle->setEnabled(false);
toggle->setSelectedIndex(1);
}

break;

default:
break;
}
}

}

void GameScene:: reduceCoolTime()
{
for (int j =0; j < plantsMenuArray->count(); j++)
{
CCMenuItemToggle* toggle = (CCMenuItemToggle*)plantsMenuArray->objectAtIndex(j);
switch (toggle->getTag())
{
case CHERRY+100:
if(cherryCoolTime !=
0)
{
cherryCoolTime--;
}
break;
case CHOMPER+100:
if(chomperCoolTime !=
0)
{
chomperCoolTime--;
}
break;
case JALAPENO+100:
if(jalapenoCoolTime !=
0)
{
jalapenoCoolTime--;

}
break;
case LILYPAD+100:
if(lilypadCoolTime !=
0)
{
lilypadCoolTime--;
}
break;
case PEASHOOTER+100:
if(peashooterCoolTime !=
0)
{
peashooterCoolTime--;
}
break;
case REPEATER+100:
if(repeaterCoolTime !=
0)
{
repeaterCoolTime--;
}
break;
case SQUASH+100:
if(squashCoolTime !=
0)
{
squashCoolTime--;
}
break;
case SUNFLOWER+100:
if(sunflowerCoolTime !=
0)
{
sunflowerCoolTime--;
}
break;
case TALLNUA+100:
if(tallnutCoolTime !=
0)
{
tallnutCoolTime--;
}
break;
case THREEPEATER+100:
if(threepeaterCoolTime !=
0)
{
threepeaterCoolTime--;
}
break;
case WALLNUA+100:
if(wallnutCooltime !=
0)
{
wallnutCooltime--;
}
break;
default:
break;
}
}

}

void GameScene::checkHitOtherPlantsAndZombie()
{
CCArray* eatedPlant = CCArray::create();
eatedPlant->retain();
CCArray* boomedZombie = CCArray::create();
boomedZombie->retain();
for (int i =0; i < plantsArray->count(); i++)
{
for (int j =0 ; j < zoombieArray->count(); j++)
{
Plants* plant = (Plants*)plantsArray->objectAtIndex(i);
Zoombie* zoombie = (Zoombie*)zoombieArray->objectAtIndex(j);
CCPoint plantPoint = plant->getPosition();
CCPoint zoombiePoint = pSprite->convertToWorldSpace(zoombie->getPosition());

if(zoombiePoint.x-plantPoint.x >-50 && zoombiePoint.x-plantPoint.x<30
&& zoombiePoint.y-plantPoint.y>=0 && zoombiePoint.y-plantPoint.y<20)
{
if(plant->plantsName == Pumpkin)//判断是否为南瓜
{
plant->stopAllActions();
plant->pumpKinAction(plant, zoombiePoint);
eatedPlant->addObject(plant);
boomedZombie->addObject(zoombie);
//this->pass();
zoombie->isAttack =true;
CCCallFuncN* func = CCCallFuncN::create(this, callfuncN_selector(GameScene::collapseZombie));
CCSequence* seq = CCSequence::create(CCDelayTime::create(0.6), func,NULL);
zoombie->runAction(seq);
}

}

if(zoombiePoint.x-plantPoint.x >=
10 && zoombiePoint.x-plantPoint.x<20 && zoombiePoint.y-plantPoint.y>=0 && zoombiePoint.y-plantPoint.y<20)
{
if(plant->plantsName == CorpseFlower)
{
if(plant->canAttack)
{

CCCallFuncN* funcn3 = CCCallFuncN::create(zoombie, callfuncN_selector(GameScene::removeSprite));
CCSequence* seq1 = CCSequence::create(CCDelayTime::create(0.8), funcn3,NULL);
zoombie->runAction(seq1);

//zoombie->removeFromParent();
boomedZombie->addObject(zoombie);
//this->pass();
zoombie->isAttack =false;

CCCallFuncN* funcn1 = CCCallFuncN::create(this, callfuncN_selector(GameScene::chomperAction1));
CCCallFuncN* funcn2 = CCCallFuncN::create(this, callfuncN_selector(GameScene::chomperAction2));
CCSequence* seq = CCSequence::create(funcn1,funcn2,NULL);
plant->runAction(seq);
}
}

}

if(zoombiePoint.x-plantPoint.x >0 && zoombiePoint.x-plantPoint.x<10
&& zoombiePoint.y-plantPoint.y>=0 && zoombiePoint.y-plantPoint.y<20)
{
if(zoombie->zoombieType == PoleVaultingZombie)
{
if(!zoombie->isJump)
{
if(plant->plantsName == SmallNut)
{

if(plant->lifeForce >
8 && plant->lifeForce <=
15)
{
plant->smallNutActionEatOverMoreHarm();
}
if(plant->lifeForce >
1 && plant->lifeForce <=
8)
{
plant->smallNutActionEatOverMoreHarm();
}
}

if(plant->plantsName == largeNut)
{
if(plant->lifeForce >
10 && plant->lifeForce <=
20)
{
plant->largeNutActionEatOvetByZombie();
}
if(plant->lifeForce >
1 && plant->lifeForce <=
10)
{
plant->largeNutActionEatOverMoreharm();
}

}

if(plant->lifeForce !=
0)
{
plant->lifeForce--;
}
if(!zoombie->isAttack)//判断僵尸是否在攻击
{
zoombie->runAttackAction();
zoombie->isAttack =true;
plant->addZombieAttackThisPlant->addObject(zoombie);
}
if(plant->lifeForce ==
0)//判断植物生命力
{
for (int i =0; i < plant->addZombieAttackThisPlant->count();
i++)
{
if(plant->addZombieAttackThisPlant->count() !=0)
{
Zoombie* zoombie = (Zoombie*)plant->addZombieAttackThisPlant->objectAtIndex(i);
zoombie->continueMove();
zoombie->startMove();
zoombie->isAttack =false;

}
}
eatedPlant->addObject(plant);
plant->removeFromParent();
}

}
}
else
{
if(plant->plantsName == SmallNut)
{

if(plant->lifeForce >
8 && plant->lifeForce <=
15)
{
plant->smallNutActionEatOverByZombie();
}
if(plant->lifeForce >
1 && plant->lifeForce <=
8)
{
plant->smallNutActionEatOverMoreHarm();
}
}

if(plant->plantsName == largeNut)
{
if(plant->lifeForce >
10 && plant->lifeForce <=
20)
{
plant->largeNutActionEatOvetByZombie();
}
if(plant->lifeForce >
1 && plant->lifeForce <=
10)
{
plant->largeNutActionEatOverMoreharm();
}

}

if(plant->lifeForce !=
0)
{
plant->lifeForce--;
}
if(!zoombie->isAttack)//判断僵尸是否在攻击
{
zoombie->runAttackAction();
zoombie->isAttack =true;
plant->addZombieAttackThisPlant->addObject(zoombie);
}
if(plant->lifeForce ==
0)//判断植物生命力
{
for (int i =0; i < plant->addZombieAttackThisPlant->count();
i++)
{
if(plant->addZombieAttackThisPlant->count() !=0)
{
Zoombie* zoombie = (Zoombie*)plant->addZombieAttackThisPlant->objectAtIndex(i);
zoombie->continueMove();
zoombie->startMove();
zoombie->isAttack =false;

}
}
eatedPlant->addObject(plant);
this->setFlagValue1(plant->getPosition());
plant->removeFromParent();
}

}
}
if(plant->plantsName == Paprika)
{
if(plantPoint.y == zoombiePoint.y)
{
CCCallFuncN* funcn = CCCallFuncN::create(this, callfuncN_selector(GameScene::zoombieBoomDie));
CCSequence* seq = CCSequence::create(CCDelayTime::create(2), funcn,NULL);
zoombie->runAction(seq);
eatedPlant->addObject(plant);
boomedZombie->addObject(zoombie);
//this->pass();

}
}
if(plant->plantsName == Cherry)
{
float distance = sqrtf((plantPoint.x-zoombiePoint.x)*(plantPoint.x-zoombiePoint.x)+(plantPoint.y-zoombiePoint.y)*(plantPoint.y-zoombiePoint.y));
if(distance <=
80)
{
CCCallFuncN* funcn = CCCallFuncN::create(this, callfuncN_selector(GameScene::zoombieBoomDie));
CCSequence* seq = CCSequence::create(CCDelayTime::create(1.4), funcn,NULL);
zoombie->runAction(seq);
eatedPlant->addObject(plant);
boomedZombie->addObject(zoombie);
//this->pass();
}
}

if(zoombie->zoombieType == PoleVaultingZombie)
{
if(zoombiePoint.x-plantPoint.x >0 && zoombiePoint.x-plantPoint.x<22
&& zoombiePoint.y-plantPoint.y>=0 && zoombiePoint.y-plantPoint.y<20)
{
if(!zoombie->isJump)
{
zoombie->Jump();
}
}
}
}
}

for (int i =0; i < eatedPlant->count(); i++)
{
if(eatedPlant->count() !=
0)
{
plantsArray->removeObject(eatedPlant->objectAtIndex(i));
}
}
for(int i =0; i < boomedZombie->count(); i++)
{
if(boomedZombie->count() !=
0)
{
zoombieArray->removeObject(boomedZombie->objectAtIndex(i));
}
}

eatedPlant->release();
boomedZombie->release();
}

void GameScene::zoombieBoomDie(Zoombie* zoombie)
{
zoombie->stopAllActions();
zoombie->runBoomDie();

//this->pass();
}

void GameScene::collapseZombie(Zoombie* zoombie)
{
zoombie->runDieAction();
}

void GameScene::chomperAction1(Plants* plant)
{
plant->corpseFlowerAction1();
}

void GameScene::chomperAction2(Plants* plant)
{
plant->corpseFlowerAction2();
}

void GameScene::chomperAction3(Plants* plant)
{
plant->corpseFlowerAction3();
}

void GameScene::changeFailedScene()
{

// CCTransitionCrossFade* fade = CCTransitionCrossFade::create(0.5, FailScene::scene());

// CCDirector::sharedDirector()->replaceScene(fade);
}

void GameScene::checkFial()
{
for (int i =0; i < zoombieArray->count(); i++)
{
if(zoombieArray->count() !=
0)
{
Zoombie* zoombie = (Zoombie*)zoombieArray->objectAtIndex(i);
CCPoint zoombiePoint = pSprite->convertToWorldSpace(zoombie->getPosition());
if(zoombiePoint.x <= -10)//如果成立,则所有植物和僵尸停止动作
{
CCSprite* sprite = CCSprite::create("ZombiesWon.png");
sprite->setPosition(ccp(240,160));
sprite->setScale(0.5);
this->addChild(sprite);
CCBlink* blink = CCBlink::create(2,2);
CCCallFunc* func = CCCallFunc::create(this, callfunc_selector(GameScene::changeFailedScene));
CCSequence* seq = CCSequence::create(blink,func,NULL);
sprite->runAction(seq);

for (int j =0 ;j < plantsArray->count(); j++)
{
if(plantsArray->count() !=
0)
{
Plants* plant = (Plants*)plantsArray->objectAtIndex(j);
plant->stopAllActions();
}

}
for (int k =0 ; k < zoombieArray->count(); k++)
{
if(zoombieArray->count() !=
0)
{
Zoombie* stopZombie = (Zoombie*)zoombieArray->objectAtIndex(k);
stopZombie->stopAllActions();
}

}

CCCallFunc* func1 = CCCallFunc::create(this, callfunc_selector(GameScene::changeFailedScene));
CCSequence* seq1 = CCSequence::create(CCDelayTime::create(3), func1,NULL);
this->runAction(seq1);
}
}
}

}

void GameScene::changeSuccessScene()
{
CCTransitionCrossFade* fade = CCTransitionCrossFade::create(1, PassScene::scene());
CCDirector::sharedDirector()->replaceScene(fade);

}

void GameScene:: addCar()
{
for (int i =0; i <
5; i++) {
CCSprite* car = CCSprite::create("LawnMower.gif");
car->setPosition(ccp(-20,45+i*53));
this->addChild(car);
carArray->addObject(car);
CCMoveTo* moveTo = CCMoveTo::create(0.5, ccp(0,45+i*53));
car->runAction(moveTo);
}
}

void GameScene::checkHitCarWithZoombie()
{
CCArray* tempCarArray = CCArray::create();
tempCarArray->retain();
CCArray* tempZombieArray = CCArray::create();
tempZombieArray->retain();
for (int i =0; i < carArray->count(); i++)
{
for (int j =0 ; j < zoombieArray->count(); j++)
{
CCSprite* sprite = (CCSprite*)carArray->objectAtIndex(i);
Zoombie* zoombie = (Zoombie*)zoombieArray->objectAtIndex(j);
CCPoint spritePoint = sprite->getPosition();
CCPoint zoombiePoint = pSprite->convertToWorldSpace(zoombie->getPosition());
if(zoombiePoint.x-spritePoint.x>0 && zoombiePoint.x-spritePoint.x<30
&& zoombiePoint.y == spritePoint.y)
{
CCMoveTo* moveToEnd = CCMoveTo::create(4, ccp(500,spritePoint.y));
CCCallFuncN* func = CCCallFuncN::create(this, callfuncN_selector(GameScene::removeSprite));
CCCallFuncND* funcnd = CCCallFuncND::create(this, callfuncND_selector(GameScene::removeCar), tempCarArray);
CCSequence* seq = CCSequence::create(moveToEnd,func,funcnd,NULL);
sprite->runAction(seq);
tempZombieArray->addObject(zoombie);
tempCarArray->addObject(sprite);
zoombie->stopAllActions();
zoombie->runDieAction();
}
}
}
for (int i =0; i < tempZombieArray->count(); i++)
{
if(tempZombieArray->count() !=
0)
{
zoombieArray->removeObject(tempZombieArray->objectAtIndex(i));
}
}

}

void GameScene::removeCar(cocos2d::CCNode *node, cocos2d::CCArray *array)
{
for (
int i =0 ; i < array->count(); i++) {
if(array->count() !=
0)
{
carArray->removeObject(array->objectAtIndex(i));
}
}
}

void GameScene::initBeforeZombie()
{
Zoombie* zoombie1 =new Zoombie(Zombie);
zoombie1->setPosition(ccp(660,65));
pSprite->addChild(zoombie1);
beforeZombie->addObject(zoombie1);

Zoombie* zoombie2 =new Zoombie(BucketheadZombie);
zoombie2->setPosition(ccp(690,121));
pSprite->addChild(zoombie2);
beforeZombie->addObject(zoombie2);

Zoombie* zoombie3 =new Zoombie(ConeheadZombie);
zoombie3->setPosition(ccp(680,174));
pSprite->addChild(zoombie3);
beforeZombie->addObject(zoombie3);

Zoombie* zoombie4 =new Zoombie(FlagZombie);
zoombie4->setPosition(ccp(660,227));
pSprite->addChild(zoombie4);
beforeZombie->addObject(zoombie4);

Zoombie* zoombie5 =
new Zoombie(PoleVaultingZombie);
zoombie5->setPosition(ccp(640,174));
pSprite->addChild(zoombie5);
beforeZombie->addObject(zoombie5);
}

voidGameScene::removeBeforeZombie()
{
for (int i =0; i <
beforeZombie->count(); i++) {
Zoombie* zoombie = (Zoombie*)beforeZombie->objectAtIndex(i);
zoombie->removeFromParent();
}

beforeZombie->removeAllObjects();
}
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: 
相关文章推荐