Learning Cocos2d-x for XNA（9）——碰撞检测

游戏中碰撞的检测相当重要，任何两个sprite间都避免不了有交集，碰撞检测也体现了游戏的真实性。

矩形检测

矩形检测是一种实现方式比较简单的检测方式，简单就意味着不那么真实。原理就是将sprite纹理抽象出一个Rect，然后通过判断Rect间是否相交，以此作为sprite的碰撞检测。这种碰撞检测是不精确的，当然，如果游戏要求不高，还是可以的。

可见，构建矩形框Rect（黑色）后，判断Rect相交即可实现碰撞检测，但无论矩形如何设置，难免会有“盲点”使得检测不那么精确（第3种情况）。

CCRect.CCRectIntersetsRect

Cocos2d-x提供了方法判断Rect是否相交的方法。

游戏规则

为了讲解碰撞检测，简单地设计一个游戏，游戏的规则是：玩家通过触碰屏幕操作Wolf的移动，Gold与Bomb随机从屏幕上端往下移动。Wolf与Gold碰撞得分，Wolf与Bomb碰撞扣分。很简单检测碰撞的游戏。

前提

还是老样子，添加游戏关键两层（Scene和Layer）GameScene、GameLayer。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using cocos2d;

namespace LearningCocos2d_xForXNA.Classes
{
    class GameScene:CCScene
    {
        public GameScene()
        {
            CCLayer gameLayer = new GameLayer();
            this.addChild(gameLayer);
        }
    }
}

Sprite

Gold：继承CCSprite，构造方法中，添加各类的纹理图片，通过随机函数设置Gold的起始位置和运动，同时通过方法collideWithWolf检测是否与Wolf对象碰撞。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using cocos2d;

namespace LearningCocos2d_xForXNA.Classes
{
    class Gold:CCSprite
    {
        public Gold(CCLayer layer)
        {
            Random rnd = new Random();
            float posionX = 100 * (float)rnd.Next(1, 4);//Gold起始位置X坐标值
            this.initWithFile("img/Wolf/Others/gold");
            this.position = new CCPoint(posionX, 850);//Gold起始位置
            layer.addChild(this);
            this.runAction(CCMoveTo.actionWithDuration(5.0f, new CCPoint(posionX, -50)));//运动，垂直向下运动
        }

        /// <summary>
        /// 创建检测碰撞Rect
        /// </summary>
        /// <returns>返回用于检测碰撞的Rect</returns>
        public CCRect rect()
        {
            CCSize s = Texture.getContentSize();//Gold纹理的大小
            return new CCRect(this.position.x, this.position.y, this.contentSize.width/2, this.contentSize.height/2);//设置Rect
        }

        /// <summary>
        /// 检测是否与Wolf对象碰撞
        /// </summary>
        /// <param name="wolf"></param>
        /// <returns>碰撞返回true，否则返回false</returns>
        public bool collideWithWolf(Wolf wolf)
        {
            CCRect wolfRect = wolf.rect();
            if(CCRect.CCRectIntersetsRect(wolfRect,rect()))//通过Rect是否相交判断是否碰撞
            {
                return true;
            }
            return false;
        }
    }
}

Bomb：继承CCSprite，构造方法中，添加各类的纹理图片，通过随机函数设置Bomb的起始位置和运动，同时通过方法collideWithWolf检测是否与Wolf对象碰撞。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using cocos2d;

namespace LearningCocos2d_xForXNA.Classes
{
    class Bomb:CCSprite
    {
        public Bomb(CCLayer layer)
        {
            Random rnd = new Random();
            float posionX = 100 * (float)rnd.Next(1, 4);//Gold起始位置X坐标值
            this.initWithFile("img/Wolf/Others/bomb");
            this.position = new CCPoint(posionX, 850);//Gold起始位置
            layer.addChild(this);
            this.runAction(CCMoveTo.actionWithDuration(5.0f, new CCPoint(posionX, -50)));//运动，垂直向下运动
        }

        /// <summary>
        /// 创建检测碰撞Rect
        /// </summary>
        /// <returns>返回用于检测碰撞的Rect</returns>
        public CCRect rect()
        {
            CCSize s = Texture.getContentSize();//Bomb纹理的大小
            return new CCRect(this.position.x, this.position.y, this.contentSize.width/2, this.contentSize.height/2);//设置Rect
        }

        /// <summary>
        /// 检测是否与Wolf对象碰撞
        /// </summary>
        /// <param name="wolf"></param>
        /// <returns>碰撞返回true，否则返回false</returns>
        public bool collideWithWolf(Wolf wolf)
        {
            CCRect wolfRect = wolf.rect();
            if(CCRect.CCRectIntersetsRect(wolfRect,rect()))//通过Rect是否相交判断是否碰撞
            {
                return true;
            }
            return false;
        }
    }
}

Wolf：继承CCSprite和ICCTargetedTouchDelegate接口，构造方法中，返回对象的用于检测碰撞的Rect。ICCTargetedTouchDelegate接口是为了实现触摸屏使得Wolf移动(上讲有讲解)。在runing方法中实现Sprite跑动动画。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using cocos2d;

namespace LearningCocos2d_xForXNA.Classes
{
    class Wolf:CCSprite, ICCTargetedTouchDelegate
    {
        /// <summary>
        /// 创建检测碰撞Rect
        /// </summary>
        /// <returns>返回用于检测碰撞的Rect</returns>
        public CCRect rect()
        {
            CCSize s = Texture.getContentSize();//Wolf纹理的大小
            return new CCRect(this.position.x, this.position.y, this.contentSize.width / 2, this.contentSize.height / 2);//设置Rect
        }

        public override void onEnter()
        {
            CCTouchDispatcher.sharedDispatcher().addTargetedDelegate(this, 0, true);
            base.onEnter();
        }

        public override void onExit()
        {
            CCTouchDispatcher.sharedDispatcher().removeDelegate(this);
            base.onExit();
        }

        public virtual bool ccTouchBegan(CCTouch touch, CCEvent eventer)
        {
            return true;
        }

        public virtual void ccTouchMoved(CCTouch touch, CCEvent eventer)
        { }

        /// <summary>
        /// 触摸屏Ended事件
        /// </summary>
        /// <param name="touch"></param>
        /// <param name="eventer"></param>
        public virtual void ccTouchEnded(CCTouch touch, CCEvent eventer)
        {
            CCPoint touchPoint = touch.locationInView(touch.view());
            CCPoint convertedLocation = CCDirector.sharedDirector().convertToGL(touchPoint);

            //执行运动
            CCActionInterval move = CCMoveTo.actionWithDuration(2, convertedLocation);
            CCActionInterval move_ease_inout = CCEaseInOut.actionWithAction(move);//ease缓冲
            base.runAction(move_ease_inout);
        }

        public void ccTouchCancelled(CCTouch pTouch, CCEvent pEvent)
        {
            throw new NotImplementedException();
        }

        public void runing(CCLayer cclayer)
        {
            #region  Sprite跑动动画
            CCSize s = CCDirector.sharedDirector().getWinSize();
            // 创建批处理节点，读取plist文件
            CCSpriteBatchNode batch = CCSpriteBatchNode.batchNodeWithFile("plist/images/wolf_move");//批处理节点贴图
            cclayer.addChild(batch, 0, 1);
            CCSpriteFrameCache.sharedSpriteFrameCache().addSpriteFramesWithFile("plist/wolf_move");//读取plsit文件
            //起始精灵
            
            this.initWithSpriteFrameName("wolf_move1.png");
            this.position = (new CCPoint(s.width / 3, s.height / 2));
            batch.addChild(this);
            // 创建逐帧数组
            List<CCSpriteFrame> animFrames = new List<CCSpriteFrame>();
            string str = "";
            for (int i = 2; i < 8; i++)
            {
                string temp = "";
                temp = i.ToString();
                str = string.Format("wolf_move{0}.png", temp);
                CCSpriteFrame frame = CCSpriteFrameCache.sharedSpriteFrameCache().spriteFrameByName(str);
                animFrames.Add(frame);
            }
            //动画Animate
            CCAnimation animation = CCAnimation.animationWithFrames(animFrames, 0.2f);//Animation动画信息
            this.runAction(CCRepeatForever.actionWithAction(CCAnimate.actionWithAnimation(animation, false)));//执行动画
            #endregion
        }
    }
}

Layer层

在GameLayer中，构造方法中，实例化得分面板（记录分数），初始化Wolf，然后通过调用schedule方法不断地产生Gold和Bomb，在方法collide中不断地检测Wolf与Gold、Bomb的碰撞情况。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using cocos2d;

namespace LearningCocos2d_xForXNA.Classes
{
    class GameLayer:CCLayer
    {
        Random rnd=new Random();//随机变量
        const int likelihoodGold = 70;//产生Gold的比例
        const int likelihoodBomb = 30;//产生Bomb的比例
        CCLabelTTF lblScore;//文本，记录游戏得分
        int score;//得分
        Wolf wolf;//主角
        List<Gold> golds = new List<Gold>();//用于存储Gold对象
        List<Bomb> bombs = new List<Bomb>();//用于存储Bomb对象
        public GameLayer()
        {
            base.isTouchEnabled = true;//开启触屏事件
            CCDirector.sharedDirector().deviceOrientation = ccDeviceOrientation.kCCDeviceOrientationPortraitUpsideDown;//设置朝向，竖屏

            //得分
            score = 0;
            lblScore = CCLabelTTF.labelWithString(string.Format("得分：{0}",score), "Yahei", 30);
            lblScore.position = new CCPoint(100, 100);
            this.addChild(lblScore);

            wolf = new Wolf();
            wolf.runing(this);//Sprite跑动动画

            this.schedule(CreateGoldOrBomb, 3.0f);//每隔3.0秒调用函数，类似线程
            this.schedule(collide);//默认下1.0/60s执行
            
        }

        /// <summary>
        /// 创建Gold对象
        /// </summary>
        /// <param name="dt">时间间隔</param>
        public void CreateGoldOrBomb(float dt)
        {
            int random = rnd.Next(1, 100);//产生1-100间随机数
            if (random < 30)//产生Bomb
            {
                Bomb bomb = new Bomb(this);
                bombs.Add(bomb);
            }
            else//产生Gold
            {
                Gold gold = new Gold(this);
                golds.Add(gold);
            }
        }

        /// <summary>
        /// 碰撞检测
        /// </summary>
        /// <param name="dt"></param>
        public void collide(float dt)
        {
            for (int i = 0; i < golds.Count; i++)//遍历golds
            {
                if (golds[i].collideWithWolf(wolf))//调用Gold判断碰撞的方法，如果碰撞返回true，否则返回false
                {
                    removeChild(golds[i], true);//将碰撞的Gold节点移除
                    golds.RemoveAt(i);//移除泛型golds中节点
                    lblScore.setString(string.Format("得分：{0}", (++score).ToString().Trim()));//得分
                }
            }
            for (int i = 0; i < bombs.Count; i++)//遍历bombs
            {
                if (bombs[i].collideWithWolf(wolf))//调用Bomb判断碰撞的方法，如果碰撞返回true，否则返回false
                {
                    removeChild(bombs[i], true);//将碰撞的Bomb节点移除
                    bombs.RemoveAt(i);//移除泛型bombs中节点
                    lblScore.setString(string.Format("得分：{0}", (--score).ToString().Trim()));//扣分
                }
            }
        }
    }
}

进行游戏

游戏中，触摸屏幕操作Wolf的移动，去吃Gold得分，避开Bomb。

 

著作权声明：本文由http://www.cnblogs.com/suguoqiang 原创，欢迎转载分享。请尊重作者劳动，转载时保留该声明和作者博客链接，谢谢！