cocos2dx 2.2.6 + box2d 成就600行代码的 完整桌球游戏

cocos2dx 的强大，本博主不需要多表明，直接上代码，但是本人保证 绝对运行不了，因为不会共享资源。

头文件

#include "Box2D/Box2D.h"

#include "GLES-Render.h"

#define PTM_RATIO 32.0f

#include <deque>

typedef deque<b2Body*> deleteBodyDeque;

#define Baiqiu_Tag 100
#define Hit_qiu_max 6

//碰撞检测器
class MyContactListener : public b2ContactListener
{
    
public:
    
    MyContactListener():_shengyuqiu(Hit_qiu_max){_BodyDeque.clear();};
    
    ~MyContactListener(){};
    
    //碰撞开始
    void BeginContact(b2Contact*contact)
    { // handle begin event
        
        if( contact->GetFixtureA()->GetBody()->GetUserData() == nullptr )
        {
            b2Body* CurBody = contact->GetFixtureB()->GetBody();
            
            auto phy = static_cast<CCPhysicsSprite*>(CurBody->GetUserData() );
            phy->getParent()->setVisible(false);
            _BodyDeque.push_back(CurBody);
        }
        else if( contact->GetFixtureB()->GetBody()->GetUserData() == nullptr )
        {
            b2Body* CurBody = contact->GetFixtureA()->GetBody();
            
            auto phy = static_cast<CCPhysicsSprite*>(CurBody->GetUserData() );
            phy->getParent()->setVisible(false);
            _BodyDeque.push_back(CurBody);
        }
    }
    
    //碰撞结束
    void EndContact(b2Contact* contact)
    { // handle end event
    }
    
    
    
    void PreSolve(b2Contact* contact,const b2Manifold* oldManifold)
    { // handle pre-solve event
    }
    
    
    
    void PostSolve(b2Contact* contact,const b2ContactImpulse* impulse)
    
    { // handle post-solve event
    }
    
    //碰撞检测后，在 box2d step（）后执行删除body
    void   deleteBody()
    {
        for( auto Cur:_BodyDeque )
        {
            b2World* Wold = Cur->GetWorld();
            
            auto phy = static_cast<CCPhysicsSprite*>(Cur->GetUserData());
            
            if( phy->getTag() == 100 )
            {
                CCMessageBox("白球进入，Game Over！", "游戏结束");
            }
            else
            {
                _shengyuqiu --;
                
                if(_shengyuqiu<=0)
                {
                     CCMessageBox("完成所有目标，Good！", "游戏完成");
                }
            }
            
            Wold->DestroyBody(Cur);
        }
        
        _BodyDeque.clear();
    }
private:
    
    deleteBodyDeque     _BodyDeque;
    int                 _shengyuqiu;
};

class CTableTennis: public CCLayer
{
    
public:
    
    CTableTennis():_CurWorld(nullptr),_CurAngle(0.0f),_IsMiaozhun(false){}
    
    ~CTableTennis(){ delete _CurWorld; delete _Gles; delete _ContactListener; }
    
    CREATE_FUNC(CTableTennis);
    
    bool init();
    
    void update( float fdt );
    
    void draw();
    
    virtual bool ccTouchBegan(CCTouch *pTouch, CCEvent *pEvent);
    virtual void ccTouchMoved(CCTouch *pTouch, CCEvent *pEvent);
    virtual void ccTouchEnded(CCTouch *pTouch, CCEvent *pEvent);
    
    void registerWithTouchDispatcher(void);
    
    //创建颜色球
    void    createSEqiu( int Max );
    
    //切换坐标系
    b2Vec2 changePos( CCPoint pos )
    {
        return b2Vec2(pos.x/PTM_RATIO, pos.y/PTM_RATIO);
    }
    
    //切换坐标系
    CCPoint changePos( b2Vec2 pos )
    {
        return ccp(pos.x*PTM_RATIO, pos.y*PTM_RATIO);
    }
    
    //根据box2d Body创建台球精灵
    bool    createTaiqiu( const char* SpriteName,b2Body* body_,int Tag = 0 );
    
    //创建球洞的刚体，用于检测进洞
    void    createCheckeD();
    
    //画瞄准虚线
    void    drawDottedLine( CCPoint startPoint, CCPoint endPoint );
    
    //更新瞄准虚线
    void    updateDottedLine( CCPoint startPoint, CCPoint endPoint, CCDrawNode* CurNode = nullptr );
    
    //计算虚线的位置以及角度
    CCPoint    mathDottedLineEnd( float step, float angle );
    
private:
    
    b2World*         _CurWorld;
    GLESDebugDraw*   _Gles;
    b2Body*          _CurBaiqiu;
    MyContactListener* _ContactListener;
    float              _CurAngle;
    
    CCRect          _miaozhunRect;
    CCRect          _yongliRect;
    
    CCRect          _preYongLi;
    CCRect          _preYongLi2;
    bool            _IsMiaozhun;
};

 cpp

#include "TableTennis.h"

bool CTableTennis::init()
{
    auto winSize = CCDirector::sharedDirector()->getWinSize();
    
    if (!CCLayer::init())
    {
        return false;
    }
    
    _ContactListener = new MyContactListener;
    
    _CurWorld = new b2World(b2Vec2(0,0));
    _CurWorld->SetAllowSleeping(true);
    _CurWorld->SetContinuousPhysics(true);
    
    _CurWorld->SetContactListener(_ContactListener);
    
    GB2ShapeCache::sharedGB2ShapeCache()->addShapesWithFile("NewActivity/qiutai_box2d.plist");
    CCSpriteFrameCache::sharedSpriteFrameCache()->addSpriteFramesWithFile("NewActivity/billiards.plist");
    
    b2BodyDef _bodydef;
    _bodydef.position.Set((winSize.width*0.5f- 480.0f)/PTM_RATIO, 0);
    b2Body* taiqiu = _CurWorld->CreateBody(&_bodydef);
    GB2ShapeCache::sharedGB2ShapeCache()->addFixturesToBody(taiqiu, "qiutai");
    
    _bodydef.type = b2_dynamicBody;
    _bodydef.linearDamping = 0.8f;
    //_bodydef.angularDamping = 0.1f;
    b2CircleShape cs;
    cs.m_radius = 0.48f;
    _bodydef.position.Set((winSize.width* 0.5f - 213.0f)/PTM_RATIO, 265.0f/PTM_RATIO);
    _bodydef.bullet = true;
    auto zuoqiu = _CurWorld->CreateBody(&_bodydef);
    
    b2FixtureDef zuoqiufde;
    zuoqiufde.shape =&cs;
    zuoqiufde.friction = 0.0f;
    zuoqiufde.density = 10.0f;
    zuoqiufde.restitution = 0.98f;
    zuoqiu->CreateFixture(&zuoqiufde);

    _CurBaiqiu = zuoqiu;

    scheduleUpdate();
    
    setTouchEnabled(true);
    
    auto taiqiuzhuo = CCPhysicsSprite::createWithSpriteFrameName("qiutai.png");
    taiqiuzhuo->setAnchorPoint(ccp(0,0));
    taiqiuzhuo->setB2Body(taiqiu);
    taiqiuzhuo->setPTMRatio(PTM_RATIO);
    taiqiu->SetUserData(taiqiuzhuo);
    addChild(taiqiuzhuo);
    
    createTaiqiu( "baiqiu.png", _CurBaiqiu, Baiqiu_Tag );
    
    createSEqiu(Hit_qiu_max);
    
    createCheckeD();
    
    drawDottedLine( changePos(_CurBaiqiu->GetPosition()), mathDottedLineEnd( 430.0f, _CurAngle ) );
    
    _miaozhunRect = CCRect(0,0, winSize.width, winSize.height );
    _yongliRect = CCRect(taiqiuzhuo->getPositionX(), taiqiuzhuo->getPositionY()+52.0f, 120.0f, 400.0f );
    
    auto liliangkuangdise = CCSprite::createWithSpriteFrameName("liliangkuangdise.png");
    liliangkuangdise->setPosition(ccp( taiqiuzhuo->getPositionX()+20.0f, taiqiuzhuo->getPositionY()+taiqiuzhuo->getContentSize().height*0.5f ));
    addChild(liliangkuangdise,100);
    
    auto liliangtiao = CCSprite::createWithSpriteFrameName("liliangtiao1.png");
    liliangtiao->setAnchorPoint(ccp(0.5f,0.0f));
    liliangtiao->setPosition(ccp(liliangkuangdise->getPositionX(), liliangkuangdise->getPositionY() + liliangtiao->getContentSize().height * 0.5f-2) );
    liliangtiao->setRotation(180.0f);
    _preYongLi = liliangtiao->getTextureRect();
    liliangtiao->setTextureRect( CCRectMake(_preYongLi.origin.x, _preYongLi.origin.y, _preYongLi.size.width, _preYongLi.size.height*0.0f) );
    addChild(liliangtiao,100,111 );
    
    auto liliangkuang = CCSprite::createWithSpriteFrameName("liliangkuang1.png");
    liliangkuang->setPosition(liliangkuangdise->getPosition());
    addChild(liliangkuang,101);
    
    auto liliangkuang2dise = CCSprite::createWithSpriteFrameName("liliangkuang2dise.png");
    liliangkuang2dise->setPosition(ccp( winSize.width * 0.5f, 530.0f ));
    addChild(liliangkuang2dise,100,201);
    
    auto liliangtiao2 = CCSprite::createWithSpriteFrameName("liliangtiao2.png");
    liliangtiao2->setAnchorPoint(ccp(0,0.5f));
    liliangtiao2->setPosition(ccp( winSize.width * 0.5f-liliangtiao2->getContentSize().width*0.5f, 530.0f ));
    _preYongLi2 = liliangtiao2->getTextureRect();
    liliangtiao2->setTextureRect( CCRectMake(_preYongLi2.origin.x, _preYongLi2.origin.y, 0, _preYongLi2.size.height));
    addChild(liliangtiao2,100,202);
    
    auto liliangkuang2 = CCSprite::createWithSpriteFrameName("liliangkuang2.png");
    liliangkuang2->setPosition(ccp( winSize.width * 0.5f, 530.0f ));
    addChild(liliangkuang2,100,203);
    
    for (int i = 0; i<3; ++i)
    {
        getChildByTag(i+201)->setVisible(false);
    }
    return true;
}

void CTableTennis::update( float fdt )
{
    _CurWorld->Step( fdt, 8, 1 );
    
    _ContactListener->deleteBody();
    
    for (b2Body* Cur = _CurWorld->GetBodyList(); Cur; Cur = Cur->GetNext() )
    {
        if ( Cur->GetType() == b2_dynamicBody && Cur->IsAwake() == true )
        {
            if( abs(Cur->GetLinearVelocity().x) < 0.2f && abs(Cur->GetLinearVelocity().y) < 0.2f )
            {
                Cur->SetAwake(false);
            }
        }
    }

    if(_IsMiaozhun)
    {
        for (b2Body* Cur = _CurWorld->GetBodyList(); Cur; Cur = Cur->GetNext() )
        {
            if ( Cur->GetType() == b2_dynamicBody && Cur->IsAwake() == true )
            {
                return;
            }
        }
        
        _IsMiaozhun = false;
    }
}

void CTableTennis::draw()
{
    CCLayer::draw();
}

bool CTableTennis::ccTouchBegan(CCTouch *pTouch, CCEvent *pEvent)
{
    if (_IsMiaozhun)
    {
        return false;
    }
    
    return true;
}

void CTableTennis::ccTouchMoved(CCTouch *pTouch, CCEvent *pEvent)
{
    if (_yongliRect.containsPoint(pTouch->getStartLocation()))
    {
        auto juli = pTouch->getStartLocation().y - pTouch->getLocation().y;
        
        if (juli<0) {
            juli = 0;
        }
        else if( juli > _preYongLi.size.height )
        {
            juli = _preYongLi.size.height;
        }
        
        auto liliangtiao = static_cast<CCSprite*>(getChildByTag(111));
        liliangtiao->setTextureRect( CCRectMake(_preYongLi.origin.x, _preYongLi.origin.y, _preYongLi.size.width, juli) );
        
        for (int i = 0; i<3; ++i)
        {
            getChildByTag(i+201)->setVisible(true);
        }
        
        float prelidu = juli/_preYongLi.size.height;
        
        liliangtiao = static_cast<CCSprite*>(getChildByTag(202));
        liliangtiao->setTextureRect( CCRectMake(_preYongLi2.origin.x, _preYongLi2.origin.y, _preYongLi2.size.width*prelidu, _preYongLi2.size.height) );
    }
    else if (_miaozhunRect.containsPoint(pTouch->getStartLocation()))
    {
        if (_miaozhunRect.containsPoint(pTouch->getLocation()))
        {
            auto startPos = changePos(_CurBaiqiu->GetPosition());
            updateDottedLine( startPos, pTouch->getLocation() );
        }
        
    }

}

void CTableTennis::ccTouchEnded(CCTouch *pTouch, CCEvent *pEvent)
{
    if (_yongliRect.containsPoint(pTouch->getStartLocation()))
    {
        auto liliangtiao = static_cast<CCSprite*>(getChildByTag(111));
        
        auto CurSize = liliangtiao->getTextureRect().size.height;
        
        float prelidu = CurSize/_preYongLi.size.height;
        
        _CurBaiqiu->SetLinearVelocity( changePos( ccpMult( ccpForAngle(_CurAngle) , 1500.0f*prelidu)) );
        
        liliangtiao->setTextureRect( CCRectMake(_preYongLi.origin.x, _preYongLi.origin.y, _preYongLi.size.width, 0) );
        
        if (prelidu != 0.0f )
        {
            _IsMiaozhun = true;
            getChildByTag( 88 )->setVisible(false);
            getChildByTag( 99 )->setVisible(false);
            getChildByTag( 10 )->setVisible(false);
        }
        
        for (int i = 0; i<3; ++i)
        {
            getChildByTag(i+201)->setVisible(false);
        }
    }
}

void CTableTennis::registerWithTouchDispatcher(void)
{
    CCTouchDispatcher* pDispatcher = CCDirector::sharedDirector()->getTouchDispatcher();
    pDispatcher->addTargetedDelegate(this, -128, true);
    CCLayer::registerWithTouchDispatcher();
}

void    CTableTennis::createSEqiu( int Max )
{
    b2BodyDef _bodydef;
    _bodydef.type = b2_dynamicBody;
    _bodydef.linearDamping = 0.8f;
    _bodydef.bullet = true;
    b2CircleShape cs;
    b2FixtureDef zuoqiufde;
    cs.m_radius = 0.48f;
    zuoqiufde.shape = &cs;
    zuoqiufde.friction = 0.0f;
    zuoqiufde.density = 10.0f;
    zuoqiufde.restitution = 0.98f;
    auto winSize = CCDirector::sharedDirector()->getWinSize();
    
    CCPoint array[6] = { ccp(0.0f,0.0f), ccp( 30.0f, 15.0f ), ccp(30.0f,-15.0f),
                         ccp(60.0f,30.0f), ccp(60.0f,0.0f), ccp(60.0f,-30.0f) };
    
    std::string spriteName[6] = { "huangqiu.png", "lanqiu.png", "lvqiu.png",
                                     "hongqiu.png", "heiqiu.png", "ziqiu.png" };
    
    for (int i = 0 ; i<Max; ++i)
    {
        b2Vec2 CurPos = changePos(ccp(winSize.width*0.5f + 213.0f + array[i].x, 265.0f+array[i].y));
        _bodydef.position.Set(CurPos.x,CurPos.y);
        auto zuoqiu = _CurWorld->CreateBody(&_bodydef);
        zuoqiu->CreateFixture(&zuoqiufde);
        
        createTaiqiu( spriteName[i].c_str(), zuoqiu );
    }
}

bool    CTableTennis::createTaiqiu( const char* SpriteName,b2Body* body_,int Tag )
{
    b2Body* TempBody = body_;
    
    if (!TempBody)
    {
        return false;
    }
    
    auto Node = CCNode::create();
    addChild(Node);
    
    auto baiqiu = CCPhysicsSprite::createWithSpriteFrameName(SpriteName);
    
    if (!baiqiu)
    {
        return false;
    }
    
    auto shadow = CCPhysicsSprite::createWithSpriteFrameName("qiuying.png");
    
    if (!shadow)
    {
        return false;
    }
    //taiqiuzhuo->setAnchorPoint(ccp(0,0));
    baiqiu->setB2Body(body_);
    shadow->setB2Body(body_);
    body_->SetUserData(baiqiu);
    baiqiu->setPTMRatio(PTM_RATIO);
    shadow->setPTMRatio(PTM_RATIO);
    Node->addChild(shadow,0,Tag);
    Node->addChild(baiqiu,0,Tag);
    
    return true;
}

void    CTableTennis::createCheckeD()
{
    
    b2BodyDef _bodydef;
    _bodydef.position.Set(0, 0);
    b2CircleShape cs;
    cs.m_radius = 0.1f;
    
    b2FixtureDef def;
    def.shape = &cs;
    def.density = 0.0f;
    
    CCPoint array[6] = { ccp(-430.0f,220.0f), ccp( -430.0f,-220.0f ), ccp(0.0f,-230.0f),
        ccp(430.0f,-220.0f), ccp(430.0f,220.0f), ccp(0.0f,230.0f) };
    
    auto winSize = CCDirector::sharedDirector()->getWinSize();
    
    for (int i = 0 ; i<6; ++i)
    {
        b2Vec2 CurPos = changePos(ccp(winSize.width*0.5f + array[i].x, 266.0f +array[i].y));
        _bodydef.position.Set(CurPos.x,CurPos.y);
        auto zuoqiu = _CurWorld->CreateBody(&_bodydef);
        zuoqiu->CreateFixture(&def);
    }
}

void    CTableTennis::drawDottedLine( CCPoint startPoint, CCPoint endPoint )
{
    auto drawNode = CCDrawNode::create();

    updateDottedLine(startPoint,endPoint,drawNode );
    
    drawNode->setZOrder(30);
    drawNode->setTag(10);
    this->addChild(drawNode);
}

void    CTableTennis::updateDottedLine( CCPoint startPoint, CCPoint endPoint, CCDrawNode* CurNode )
{
    CCDrawNode* drawNode = CurNode;
    
    if (!CurNode)
    {
        drawNode = static_cast<CCDrawNode*>(getChildByTag(10));
    }
    
    drawNode->setVisible(true);
    drawNode->clear();
    
    float stepLength = 6.0f;
    float spaceLength = 15;
    
    auto CurVector = ccpNormalize( ccpSub(endPoint,  startPoint) );
    
    CCPoint nextPoint = startPoint;
    CCPoint dictPoint;
    
    while (true)
    {
        float endpos =ccpLength(ccpSub(endPoint, nextPoint));
        
        if ( endpos <= spaceLength )
        {
            break;
        }
        
        endpos =ccpLength(ccpSub(endPoint, dictPoint));
        
        if ( endpos <= stepLength )
        {
            break;
        }
        
        dictPoint = ccpAdd(nextPoint, ccpMult(CurVector, stepLength));
        
        drawNode->drawSegment(nextPoint, dictPoint, 1, ccc4f(1.0f, 1.0f, 1.0f, 0.3f));
        
        nextPoint = ccpAdd(dictPoint, ccpMult(CurVector, spaceLength));
        
    }
    
    auto zhunxing = getChildByTag( 88 );
    if (!zhunxing)
    {
        zhunxing = CCSprite::createWithSpriteFrameName( "zhunxing.png" );
        addChild(zhunxing, 20, 88 );
    }
    zhunxing->setVisible(true);
    zhunxing->setPosition(endPoint);
    
    auto qGan = getChildByTag( 99 );
    if (!qGan)
    {
        qGan = CCSprite::createWithSpriteFrameName( "qiugan.png" );
        qGan->setAnchorPoint( ccp(1.05f,0.5f) );
        addChild(qGan, 20, 99 );
    }
    qGan->setVisible(true);
    qGan->setPosition(startPoint);
    
    _CurAngle = ccpToAngle(CurVector);
    
    qGan->setRotation( CC_RADIANS_TO_DEGREES( -_CurAngle ) );
    
}

CCPoint    CTableTennis::mathDottedLineEnd( float step, float angle )
{
    auto StartPos_ = changePos(_CurBaiqiu->GetPosition());
    
    CCPoint endPos_;
    
    endPos_.x = step * cosf( angle ) + StartPos_.x;
    endPos_.y = step * sinf(angle) + StartPos_.y;
    
    return endPos_;
}

 少量注释，看不懂那就没办法，没那个时间写！

运行gif