cocos2d-x之怪物系统

 这次接着上次的分析，上次加了武器系统，这回增加怪物系统 
        原文出处http://bbs.9ria.com/thread-242991-1-1.html 
        MonsterSystem.h 
         
        #ifndef __MONSTER_SYSTEM_H__
        #define __MONSTER_SYSTEM_H__
        #include "cocos2d.h"
        #include "MonsterSprite.h"
        
        #include "BulletsSprite.h"
        typedef struct MonsterUtils{
         float initBlood;// 初始化气血
         float initSpeed;// 初始化速度
         float defend;// 怪物的防御力
         float hurt;// 怪物的伤害值
         char* monsName;// 在设置怪物的时候的通用名字
         char* picName;// 怪物的图片
         char* fileName;// 怪物所对应的plist 文件的名字
         int   type;// 怪物类型
         int   runCount;// 奔跑动画张数
         int   actCount;// 攻击动画张数
         int   detCount;// 死亡动画张数
         float maxRun;// 最大移动距离
         char* attackRangeRec;//是在怪物身上划定一个受到的攻击范围 这样可以让不规则的 图片 看起来受到攻击的时候更逼真一点 字符串的 格式是这样的{{x,y},{w, h}}
        } Monster;
        class DefenderGameLayer;
        // 此类是生产和销毁系统
        class MonsterSystem{
        public:
         MonsterSystem();
         ~MonsterSystem();
         cocos2d::CCArray* getIdleMonsterArry();// 用来保存空闲的怪物
         cocos2d::CCArray* getRunMonsterArray();// 用来保存正在奔跑中的怪物
         void addMonster(int type,int count);// 用于主线程调用来远远不断的产生怪物
         void setDefenderGameLayer(DefenderGameLayer* defenderGameLayer);
         bool collisionDetection(BulletsSprite* bulletsSprite);// 传入弓箭 检测是否和怪物发生碰撞
         void recoverMonster(MonsterSprite* monsterSprite);// 回收怪物
        private:
         cocos2d::CCArray* idleMonsterArry;// 用来保存空闲的怪物
         cocos2d::CCArray* runMonsterArray;// 用来保存正在奔跑中的怪物
            MonsterSprite*    productMonster(int type);//根据类型来产生响应的怪物的数量 
         DefenderGameLayer* defenderGameLayer;// 游戏主类
         void addDefenderGameLayer(MonsterSprite* monsterSprite);// 把奔跑中的怪物添加到 主界面里面
         Monster dutu;// 每次添加新的怪物都需要在这里添加一个 并且在构造方法里面初始化
        };
        #endif
        
        
         
         
         
          
        MonsterSystem.cpp 
         
        #include "MonsterSystem.h"
        #include "DefenderGameLayer.h"
        USING_NS_CC;
        MonsterSystem::MonsterSystem(){
        
         idleMonsterArry= CCArray::create();// 用来保存空闲的怪物
         idleMonsterArry->retain();
         this->runMonsterArray=CCArray::create(); // 用来保存正在奔跑中的怪物
         this->runMonsterArray->retain();
         /**********************************************************************
         float initBlood;// 初始化气血
         float initSpeed;// 初始化速度
         float defend;// 怪物的防御力
         float hurt;// 怪物的伤害值
         char* picName;// 怪物的图片
         char* fileName;// 怪物所对应的plist 文件的名字
         int   type;// 怪物类型
         int   runCount;// 奔跑动画张数
         int   actCount;// 攻击动画张数
         int   detCount;// 死亡动画张数
         float maxRun;// 最大移动距离
         float minX; // 下面的这四个参数其实 是在怪物身上划定一个受到的攻击范围 这样可以让不规则的 图片 看起来受到攻击的时候更逼真一点 
         float minY;
         float maxX;
         float maxY;                                                    
         ************************************************************************/
         this->dutu.initBlood=100;
         this->dutu.initSpeed=5;
         this->dutu.defend=1;
         this->dutu.hurt=10;
         this->dutu.monsName="dutu";
         this->dutu.picName="monster/dutu.png";
         this->dutu.fileName="monster/dutu.plist";
         this->dutu.type=1;
         this->dutu.runCount=8;
         this->dutu.actCount=14;
         this->dutu.detCount=8;
         this->dutu.maxRun=800*0.14; 
         this->dutu.attackRangeRec="{{70,45},{30,110}}";
        
        }
        
        根据类型来产生响应的怪物
        MonsterSprite*    MonsterSystem::productMonster(int type){
         if(type==1){
         MonsterSprite* sp=MonsterSprite::createWithMonsterRul(dutu.fileName,CCTextureCache::sharedTextureCache()->textureForKey(dutu.picName),dutu.monsName,dutu.runCount,dutu.actCount,dutu.detCount);
         sp->setHurt(dutu.hurt);
         sp->setDefense(dutu.defend);
         sp->setBlood(dutu.initBlood);
         sp->setSpeed(dutu.initSpeed);
         sp->setmaxRemoving(dutu.maxRun);
         sp->setMonType(dutu.type);
         sp->setMonState(1);
         sp->setAttackRange(CCRectFromString(dutu.attackRangeRec));
         sp->setMonsterSystemUtils(this);
         return sp;  
         }
         return NULL;
        }
        // 把奔跑中的怪物添加到 主界面里面
        void MonsterSystem::addDefenderGameLayer(MonsterSprite* monsterSprite){
         // 获取0-1 之间的数
         float ran=CCRANDOM_0_1();
         CCSize size=this->defenderGameLayer->getContentSize();
         float x=size.width;
         float temp=size.height*ran+monsterSprite->getContentSize().height/2;//得到随机放置的纵坐标
         float y=0;//初始化y值
         if (temp>=size.height){//如果超过了界限
         y=size.height-monsterSprite->getContentSize().height/2;//则让精灵的正上方与屏幕对齐
         }else{
         if(ran!=0){
         if (size.height*rangetContentSize().height/2){
         y=temp+10;
         }else {
         y=size.height*ran;
         }
        这里我加了一个部分，源代码只是考虑了下半部分，而没有考虑上半部分
        /else if(size.height*ran>size.height-monsterSprite->getContentSize().height/2){  y=temp-10;   } 
        
         }else {
         y=monsterSprite->getContentSize().height/2;
         }
         }
         monsterSprite->setAnchorPoint(ccp(0,0.5));
         monsterSprite->setPosition(ccp(x,y));
        
         if(this->defenderGameLayer){
         this->defenderGameLayer->addChild(monsterSprite,2);
         monsterSprite->runAnimation();
         }
         this->getRunMonsterArray()->addObject(monsterSprite);
        }
        
        // 传入弓箭 检测是否和怪物发生碰撞
        bool MonsterSystem::(BulletsSprite* bulletsSprite){
         bool iscon=false;
         if (this->getRunMonsterArray())
         {
         // 下面是检测 弓箭 是否和怪物发生碰撞
         for(int i=0;igetRunMonsterArray()->count();i++){
         MonsterSprite* monsterSprite=(MonsterSprite*)this->getRunMonsterArray()->objectAtIndex(i);
         // 怪物的状态必须不是死亡的状态
         if (monsterSprite->getMonState()!=4) 
         {
         // 判断当前的怪物所受攻击的区域时候和弓箭 是否发生碰撞
             iscon=bulletsSprite->boundingBox().intersectsRect(monsterSprite->converNowRect());
         if (iscon)
         {
         // 表示怪物受到攻击 怪物要进行掉血 操作
         monsterSprite->fallBlood(bulletsSprite->getHurt());
         iscon=true;
         break;
         }else{
         continue;
         }
         }
        
         }
         }
         return iscon;
        }
        
        void MonsterSystem::recoverMonster(MonsterSprite* monsterSprite){
         // 把死掉的怪物回收以下
         this->getRunMonsterArray()->removeObject(monsterSprite,false);
         // 从界面上移除掉
         this->defenderGameLayer->removeChild(monsterSprite,false);
         // 还原怪物的 部分属性
         if(monsterSprite->getMonType()==1){
         monsterSprite->setBlood(dutu.initBlood);
         monsterSprite->setPosition(CCPointZero);
         monsterSprite->setMonType(dutu.type);
         // 停掉所有动画
         monsterSprite->stopAllActions();
         }
         this->getIdleMonsterArry()->addObject(monsterSprite);
        }
        
        ;// 用于主线程调用来远远不断的产生怪物
        void MonsterSystem::addMonster(int type,int count){
        
         for(int i=0;i
         MonsterSprite* runmon=NULL;
        
         for(int j=0;jgetIdleMonsterArry()->count();j++){
         MonsterSprite* temmon=(MonsterSprite*)this->getIdleMonsterArry()->objectAtIndex(j);
         if (temmon->getMonType()==type){
         runmon=temmon;
         break;
         }
        
         }
         // 如果从空闲的线程 得到了需要的 怪物类型  就添加到界面上 反之 则需要创建一个
         if (runmon){
         this->getIdleMonsterArry()->removeObject(runmon,false);
         this->addDefenderGameLayer(runmon);
         }else {
         MonsterSprite* temmon= this->productMonster(type);
         if (temmon)
         {
         this->getIdleMonsterArry()->addObject( this->productMonster(type));
         i--;//这里是把新创建的monster加入到空闲数组中，这样就能够重新检索一遍以便调用addDefenderGameLayer()
         }else {
         break;
         }
        
         }
        
        
         }
        
        }
        void MonsterSystem::setDefenderGameLayer(DefenderGameLayer* defenderGameLayer){
         this->defenderGameLayer=defenderGameLayer;
        }
        
        CCArray* MonsterSystem::getRunMonsterArray(){
         return this->runMonsterArray;
        
        }
        CCArray* MonsterSystem::getIdleMonsterArry(){
         return this->idleMonsterArry;
        }
        
        MonsterSystem::~MonsterSystem(){
         if (idleMonsterArry)
         {
         this->idleMonsterArry->autorelease();
         }
         if (runMonsterArray)
         {
         this->runMonsterArray->autorelease();
         }
        
        }MonsterSprite.h 
         
         
        #ifndef __MONSTER_SPRITE_H__
        #define __MONSTER_SPRITE_H__
        #include "cocos2d.h"
        class MonsterSystem;
        class MonsterSprite:public cocos2d::CCSprite{
        public:
         MonsterSprite(void);
         ~MonsterSprite(void);
         void moveRun();// 移动函数
         CC_SYNTHESIZE(float,hurt,Hurt);//伤害值
         CC_SYNTHESIZE(float,defense,Defense);//防御值
         CC_SYNTHESIZE(float,speed,Speed);//移动速度
         CC_SYNTHESIZE(float,maxRemoving,maxRemoving);// 移动的最大距离
         CC_SYNTHESIZE(float,blood,Blood);// 怪物气血值
         CC_SYNTHESIZE(int,monType,MonType);// 怪物类型
         CC_SYNTHESIZE(int,monState,MonState);// 怪物状态 1 静止状态  2 行动状态 3 攻击状态 4 死亡状态
         CC_SYNTHESIZE(cocos2d::CCRect,attackRange,AttackRange);// 接受攻击的范围
        
         void runAnimation();// 执行奔跑动画
         void deathAnimation();// 执行死亡动画
         void attackAnimation();// 执行攻击动画
         void fallBlood(float hurt);// 这个是接受攻击 主要改变 该怪物的气血值 和血条的显示
         // 第一个参数的意思是 加载的plist 文件的名字 第二个是 plist 对应的图片纹理 第三个是 图片的通用名字 第四个 走路动画图片张数，第五个是 攻击时候的参数  第六个是 死亡动画的张数
         // 在这里贴别说明一点为了达到动画的通用性 我们规定 plist 中的图片命名格式是这样的 pic-1编号 是跑步图片 pic-2编号是 攻击图片 pic-x编号是死亡图片
         static MonsterSprite* createWithMonsterRul(const char* filename,cocos2d::CCTexture2D* ccTexture2D,const char* pic,int runcount,int attackcount,int deathcout );
         void setMonsterSystemUtils(MonsterSystem* monsterSystem);
         cocos2d::CCRect converNowRect();// 这个方法是把最初设计的攻击范围 转化到当前 界面的坐标系中的矩形
        protected:
         cocos2d::CCArray* runArray;//奔跑动画序列帧
         cocos2d::CCArray* deathArray;//死亡动画序列帧
         cocos2d::CCArray* attackArray;//攻击动画序列帧  
         cocos2d::CCProgressTimer* bloodBwlid;// 这个是血条
         virtual void deathAnimationCallBack(cocos2d::CCNode* pSed);// 死亡动画回调函数
         virtual void attackAnimationCallBack(cocos2d::CCNode* pSed);// 攻击动画回调函数
         virtual void runAnimationCallBack(cocos2d::CCNode* pSed);//奔跑动画回调函数
         virtual bool setUpdateView();
         static MonsterSprite* createWithSpriteFrame(cocos2d::CCSpriteFrame *pSpriteFrame); 
         MonsterSystem* monsterSystem; 
         void myload(float tim);
        
        };
        #endif
         MosterSprite.cpp 
         
          
         
        #include "MonsterSprite.h"
        #include "MonsterSystem.h"
        USING_NS_CC;
        MonsterSprite::MonsterSprite(void){
         runArray=CCArray::create();//奔跑动画序列帧
         runArray->retain();
         deathArray=CCArray::create();//死亡动画序列帧
         deathArray->retain();
         attackArray=CCArray::create();//攻击动画序列帧  
         attackArray->retain();
        
        }
        MonsterSprite* MonsterSprite::createWithMonsterRul(const char* filename,CCTexture2D* ccTexture2D,const char* pic,int runcount,int attackcount,int deathcout ){
         CCSpriteFrameCache::sharedSpriteFrameCache()->addSpriteFramesWithFile(filename,ccTexture2D);//打开缓冲文件
         CCSpriteFrame* temp=CCSpriteFrameCache::sharedSpriteFrameCache()->spriteFrameByName(CCString::createWithFormat("%s-10.png",pic)->getCString());//怪物需要一张图片作为初始化的画面
         MonsterSprite* monst=MonsterSprite::createWithSpriteFrame(temp);//创建一个初始化的怪物精灵
         if (monst&&monst->setUpdateView()&&ccTexture2D){  
         // 初始化 奔跑动画序列帧
         for(int i=0;i
        
         monst->runArray->addObject(CCSpriteFrameCache::sharedSpriteFrameCache()->spriteFrameByName(CCString::createWithFormat("%s-1%d.png",pic,i)->getCString()));
         }
         // 初始化 攻击动画 序列帧
         for(int i=0;i
         monst->attackArray->addObject(CCSpriteFrameCache::sharedSpriteFrameCache()->spriteFrameByName(CCString::createWithFormat("%s-2%d.png",pic,i)->getCString()));
         }
        
         // 初始化 死亡动画 序列帧
         for(int i=0;i
         monst->deathArray->addObject(CCSpriteFrameCache::sharedSpriteFrameCache()->spriteFrameByName(CCString::createWithFormat("%s-3%d.png",pic,i)->getCString()));
         }
         // 初始化血条
        
        
         return monst;
         }else {
         return NULL;
         }
        }
        MonsterSprite* MonsterSprite::createWithSpriteFrame(CCSpriteFrame *pSpriteFrame){//创建怪物精灵对象
         MonsterSprite* monSter=new MonsterSprite();
         if (pSpriteFrame&&monSter&&monSter->initWithSpriteFrame(pSpriteFrame))//如果初始化怪物精灵成功，则将MonsterSprite加入内存管理计数器
         {
         monSter->autorelease();
         return monSter;
         }
         CC_SAFE_DELETE(monSter);
         return NULL;
        }
        
        bool MonsterSprite::setUpdateView(){
         bool isRet=false;
         do 
         {
         // 添加血条的背景图片
         CCSprite* bloodbackimg=CCSprite::createWithTexture(CCTextureCache::sharedTextureCache()->textureForKey("game/monster_blood_frame.png"));
         CC_BREAK_IF(!bloodbackimg); //增加血条框精灵
         bloodbackimg->setPosition(ccp(this->getContentSize().width/2,this->getContentSize().height+2));//放到距离怪物上方2高度的正上方
         this->addChild(bloodbackimg,1);//添加血条框到怪物
        
         // 添加进度条
         CCSprite* blood=CCSprite::createWithTexture(CCTextureCache::sharedTextureCache()->textureForKey("game/monster_blood.png"));
         CC_BREAK_IF(!blood);//增加血条进度框
         this->bloodBwlid=CCProgressTimer::create(blood);//将血条绑定为进度条
         CC_BREAK_IF(!bloodBwlid);
         bloodBwlid->setType(kCCProgressTimerTypeBar);// 设置成横向的
         //可以看作是按矩形显示效果的进度条类型
         bloodBwlid->setMidpoint(ccp(0,0)); 
         //  用来设定进度条横向前进的方向从左向右或是从右向左
         bloodBwlid->setBarChangeRate(ccp(1,0));
        
         bloodBwlid->setPosition(ccp(this->getContentSize().width/2,this->getContentSize().height+2));
         bloodBwlid->setPercentage(100);
         this->addChild(bloodBwlid,2);
         isRet=true;
         } while (0);
         return isRet;
        
        }
        
        
        // 执行奔跑动画
        void MonsterSprite::runAnimation(){
        
         this->setMonState(2);
         this->stopAllActions();
         if(this->runArray->count()>0){
         CCAnimation *animation=CCAnimation::createWithSpriteFrames(runArray,0.15f);
         CCAnimate *animate=CCAnimate::create(animation);
         CCCallFuncN *onComplete =  CCCallFuncN::create(this, callfuncN_selector(MonsterSprite::runAnimationCallBack));  
         CCSequence* pse=CCSequence::create(animate,onComplete,NULL);
         // 一直执行奔跑动画
         this->runAction(CCRepeatForever::create(pse));
        
         this->schedule(schedule_selector(MonsterSprite::myload),0.15);
         }
        }
        
        void MonsterSprite::myload(float tie){
         if (this->getMonState()==2){
         this->moveRun();
         }
        }
        
         void MonsterSprite::runAnimationCallBack(CCNode* pSed){
          
         }
        
        // 执行死亡动画
        void MonsterSprite::deathAnimation(){
         this->setMonState(4);
         this->stopAllActions();
         if(this->deathArray->count()>0){
         CCAnimation *animation=CCAnimation::createWithSpriteFrames(deathArray,0.15f);
         CCAnimate *animate=CCAnimate::create(animation);
         CCCallFuncN *onComplete =  CCCallFuncN::create(this, callfuncN_selector(MonsterSprite::deathAnimationCallBack));  
         CCSequence* pse=CCSequence::create(animate,onComplete,NULL);
         this->runAction(pse);
         }
        }
        
        
         void MonsterSprite::deathAnimationCallBack(CCNode* pSed){
          if(this->monsterSystem){
          this->monsterSystem->recoverMonster(this);
          }
          this->unscheduleAllSelectors();
        }
        
        // 执行攻击动画
        void MonsterSprite::attackAnimation(){
         this->setMonState(3);
         this->stopAllActions();
         if(this->attackArray->count()>0){
         CCAnimation *animation=CCAnimation::createWithSpriteFrames(attackArray,0.15f);
         CCAnimate *animate=CCAnimate::create(animation);
         CCCallFuncN *onComplete =  CCCallFuncN::create(this, callfuncN_selector(MonsterSprite::attackAnimationCallBack));  
         CCSequence* pse=CCSequence::create(animate,onComplete,NULL);
         this->runAction(CCRepeatForever::create(pse));
         }
        }
        // 这个是接受攻击 主要改变 该怪物的气血值 和血条的显示
        void MonsterSprite::fallBlood(float hurted){
         float temp=this->getBlood();
         // 按照 一点防御 能抵挡10%的伤害 来计算
         this->setBlood(temp-(hurted-this->getDefense()*0.1));
         if(this->getBlood()<=0){
         this->bloodBwlid->setPercentage(0);
         this->deathAnimation();
         }else {
         this->bloodBwlid->setPercentage(this->getBlood());
         }
        }
        
        void MonsterSprite::attackAnimationCallBack(CCNode* pSed){
         CCLOG("donghuazhixing2");
        
          this->unscheduleAllSelectors();
        }
        
        
        
        
        void MonsterSprite::moveRun(){
         int x=this->getPositionX();
         if(this->getMonState()==2){
         // 当X 的坐标小于 最小的距离是 需要调用 攻击动画
         x=x-this->getSpeed();
         this->setPositionX(x);
         if(x<=this->getmaxRemoving()){
         this->attackAnimation();
         }
         }
        
        }
        
        CCRect MonsterSprite::converNowRect(){
                // 得到当前的 怪物的所在的矩形
         CCRect monsret=this->boundingBox();
         float x=monsret.getMinX()+this->getAttackRange().getMinX();
         float y=monsret.getMinY()-this->getAttackRange().getMinY();
         return CCRect(x,y,this->getAttackRange().getMaxX(),this->getAttackRange().getMaxY());
        }
        
        void MonsterSprite::setMonsterSystemUtils(MonsterSystem* monsterSystem){
         this->monsterSystem=monsterSystem;
        }
        MonsterSprite::~MonsterSprite(void){
         if (runArray)
         {
         runArray->autorelease();
         }
        
         if (deathArray)
         {
         deathArray->autorelease();
         }
        
         if (attackArray)
         {
         attackArray->autorelease();
         }
        }