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

这个植物大战僵尸的小游戏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);

        }

       elseif(toggle->getTag() ==207)

        {

            toggle->setEnabled(true);

        }

       elseif(toggle->getTag() ==208)

        {

            toggle->setEnabled(true);

        }

       elseif(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));

                }

               elseif(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];

                }

            }

        }

    }

   return1;

}

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) {

           case0:

                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;

           case2:

                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;

           case3:

                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;

           case1:

                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;

           case4:

                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);

        }

    }

   elseif(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);

            

        }

    }

   elseif(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);

                }

               elseif(SunNumber <150)

                {

                    toggle->setEnabled(false);

                    toggle->setSelectedIndex(1);

                }

               break;

           case CHOMPER+100:

               if(chomperCoolTime ==0 && SunNumber >= 150)

                {

                    toggle->setSelectedIndex(0);

                    toggle->setEnabled(true);

                }

               elseif(SunNumber <150)

                {

                    toggle->setEnabled(false);

                    toggle->setSelectedIndex(1);

                }

               break;

           case JALAPENO+100:

               if(jalapenoCoolTime ==0 && SunNumber >= 125)

                {

                    toggle->setSelectedIndex(0);

                    toggle->setEnabled(true);

                }

               elseif(SunNumber <125)

                {

                    toggle->setEnabled(false);

                    toggle->setSelectedIndex(1);

                }

                

               break;

           case LILYPAD+100:

               if(lilypadCoolTime ==0 && SunNumber >= 25)

                {

                    toggle->setSelectedIndex(0);

                    toggle->setEnabled(true);

                }

               elseif(SunNumber <25)

                {

                    toggle->setEnabled(false);

                    toggle->setSelectedIndex(1);

                }

                

               break;

           case PEASHOOTER+100:

               if(peashooterCoolTime ==0 && SunNumber >= 100)

                {

                    toggle->setSelectedIndex(0);

                    toggle->setEnabled(true);

                }

               elseif(SunNumber <100)

                {

                    toggle->setEnabled(false);

                    toggle->setSelectedIndex(1);

                }

                

               break;

           case REPEATER+100:

               if(repeaterCoolTime ==0 && SunNumber >= 200)

                {

                    toggle->setSelectedIndex(0);

                    toggle->setEnabled(true);

                }

               elseif(SunNumber <200)

                {

                    toggle->setEnabled(false);

                    toggle->setSelectedIndex(1);

                }

                

               break;

           case SQUASH+100:

               if(squashCoolTime ==0 && SunNumber >= 50)

                {

                    toggle->setSelectedIndex(0);

                    toggle->setEnabled(true);

                }

               elseif(SunNumber <50)

                {

                    toggle->setEnabled(false);

                    toggle->setSelectedIndex(1);

                }

                

               break;

           case SUNFLOWER+100:

               if(sunflowerCoolTime ==0 && SunNumber >= 50)

                {

                    toggle->setSelectedIndex(0);

                    toggle->setEnabled(true);

                }

               elseif(SunNumber <50)

                {

                    toggle->setEnabled(false);

                    toggle->setSelectedIndex(1);

                }

                

               break;

           case TALLNUA+100:

               if(tallnutCoolTime ==0 && SunNumber >= 125)

                {

                    toggle->setSelectedIndex(0);

                    toggle->setEnabled(true);

                }

               elseif(SunNumber <125)

                {

                    toggle->setEnabled(false);

                    toggle->setSelectedIndex(1);

                }

                

               break;

           case THREEPEATER+100:

               if(threepeaterCoolTime ==0 && SunNumber >= 325)

                {

                    toggle->setSelectedIndex(0);

                    toggle->setEnabled(true);

                }

               elseif(SunNumber <325)

                {

                    toggle->setEnabled(false);

                    toggle->setSelectedIndex(1);

                }

                

               break;

           case WALLNUA+100:

               if(wallnutCooltime ==0 && SunNumber >= 50)

                {

                    toggle->setSelectedIndex(0);

                    toggle->setEnabled(true);

                }

               elseif(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();

}