cocos2dx之虚拟摇杆

梦里梦外; 2022-07-26 06:04 279阅读 0赞

刚刚弄的，直接上代码：

//
    //  Rocker.h
    //  Rocker
    //
    //  Created by zp on 16/4/7.
    //
    //
    
    #ifndef __Rocker__Rocker__
    #define __Rocker__Rocker__
    
    /*
     void onRockBegan(float,float,bool);
     void onRockMoved(float,float);
     void onRockEnded(float,float);
     void onRockCancelled(float,float);
     */
    
    
    #include "cocos2d.h"
    USING_NS_CC;
    #include <iostream>
    #include "CCGLProgram.h"
    class Rocker : public Layer{
    public:
        //以下所说xy方向均以摇杆轴心为原点
        
        ///开始摇杆时
        ///参数1：摇杆x方向移动；参数2：摇杆y方向移动；
        std::function<void(float,float,bool)> onRockBegan;
        
        ///摇杆中
        ///参数1：摇杆x方向移动；参数2：摇杆y方向移动；
        std::function<void(float,float)> onRockMoved;
        
        ///摇杆结束时
        ///参数1：摇杆x方向移动；参数2：摇杆y方向移动；
        std::function<void(float,float)> onRockEnded;
        
        ///摇杆意外结束时
        ///参数1：摇杆x方向移动；参数2：摇杆y方向移动；
        std::function<void(float,float)> onRockCancelled;
    public:
        Rocker():onRockBegan(nullptr),onRockMoved(nullptr),onRockEnded(nullptr),onRockCancelled(nullptr){}
    public:
        ///参数1：摇杆行动半径；参数2：手指开始触摸时的最大有效半径；参数3：摇杆底座图片；参数4：摇杆图片；参数5：摇杆轴心位置
        static Rocker* create(float radius,float Radius,std::string Rbgimg,std::string Rimg,Point positon);
        
        bool init(float radius,float Radius,std::string Rbgimg,std::string Rimg,Point positon);
        
        void setRockerTexture(std::string Rimg);
        void setRockerBGTexture(std::string Rbgimg);
    public:
        virtual bool onTouchBegan(Touch *touch, Event *unused_event);
        virtual void onTouchMoved(Touch *touch, Event *unused_event);
        virtual void onTouchEnded(Touch *touch, Event *unused_event);
        virtual void onTouchCancelled(Touch *touch, Event *unused_event);
        
        void onEnter()override;
        void onExit()override;
    protected:
        ///摇杆行动半径
        float m__radius;
        ///手指触摸最大有效半径
        float m__Radius;
        ///摇杆底座纹理名
        std::string m__Rbgimg;
        ///摇杆纹理名
        std::string m__Rimg;
        ///摇杆底座
        Sprite* m__rockerBG;
        ///摇杆
        Sprite* m__rocker;
        ///摇杆轴心位置
        Point m__rocker_p;
    };
    
    #endif /* defined(__Rocker__Rocker__) */

//
    //  Rocker.cpp
    //  Rocker
    //
    //  Created by zp on 16/4/7.
    //
    //
    
    #include "Rocker.h"
    
    Rocker* Rocker::create(float radius,float Radius,std::string Rbgimg,std::string Rimg,Point positon){
        Rocker *pRet = new Rocker();
        if (pRet && pRet->init(radius,Radius,Rbgimg,Rimg,positon))
        {
            pRet->autorelease();
            return pRet;
        }
        else
        {
            delete pRet;
            pRet = NULL;
            return NULL;
        } \
    }
    
    bool Rocker::init(float radius,float Radius,std::string Rbgimg,std::string Rimg,Point positon){
        if (!Layer::init()) {
            return false;
        }
        m__radius   = radius;
        m__Radius   = Radius;
        m__Rbgimg   = Rbgimg;
        m__Rimg     = Rimg;
        m__rocker_p = positon;
        
        m__rockerBG = Sprite::create(Rbgimg);
        m__rockerBG -> setAnchorPoint(Point(0.5,0.5));
        m__rockerBG -> setPosition(positon);
        addChild(m__rockerBG,0);
        
        m__rocker   = Sprite::create(Rimg);
        m__rocker -> setAnchorPoint(Point(0.5,0.5));
        m__rocker -> setPosition(positon);
        addChild(m__rocker,1);
        
        auto l = EventListenerTouchOneByOne::create();
        l -> onTouchBegan     = CC_CALLBACK_2(Rocker::onTouchBegan, this);
        l -> onTouchMoved     = CC_CALLBACK_2(Rocker::onTouchMoved, this);
        l -> onTouchEnded     = CC_CALLBACK_2(Rocker::onTouchEnded, this);
        l -> onTouchCancelled = CC_CALLBACK_2(Rocker::onTouchCancelled, this);
        
        this->getEventDispatcher()->addEventListenerWithSceneGraphPriority(l, this);
        return true;
    }
    void Rocker::setRockerTexture(std::string Rimg){
        if (Rimg == "") {
            m__rocker -> setTexture(m__Rimg);
            return;
        }
        m__rocker -> setTexture(Rimg);
    }
    void Rocker::setRockerBGTexture(std::string Rbgimg){
        if (Rbgimg == "") {
            m__rockerBG -> setTexture(Rbgimg);
            return;
        }
        m__rockerBG -> setTexture(Rbgimg);
    }
    bool Rocker::onTouchBegan(Touch *touch, Event *unused_event){
        auto p = touch->getLocation();
        auto detal = p - m__rocker_p;
        
        auto a = atanf(detal.y/detal.x);
        auto s = std::abs(detal.y/sinf(a));
        
        if (s > m__Radius) {
            if(onRockBegan) onRockBegan(p.x,p.y,false);
            return false;
        }
        
        m__rocker -> stopAllActions();
        
        if (s > m__radius) {
            auto x = cosf(a)*m__radius;
            auto y = sinf(a)*m__radius;
            if(detal.x < 0){
                y = -y;
                x = -x;
            }
            m__rocker -> setPosition(m__rocker_p+Point(x,y));
        }else{
            m__rocker -> setPosition(p);
        }
        
        if(onRockBegan) onRockBegan(p.x,p.y,true);
        return true;
    }
    void Rocker::onTouchMoved(Touch *touch, Event *unused_event){
        auto p = touch->getLocation();
        auto detal = p - m__rocker_p;
        
        auto a = atanf(detal.y/detal.x);
        auto s = std::abs(detal.y/sinf(a));
        if (s > m__radius) {
            auto x = cosf(a)*m__radius;
            auto y = sinf(a)*m__radius;
            if(detal.x < 0){
                y = -y;
                x = -x;
            }
            m__rocker -> setPosition(m__rocker_p+Point(x,y));
        }else{
            m__rocker -> setPosition(p);
        }
        
        if(onRockMoved) onRockMoved(p.x,p.y);
    }
    void Rocker::onTouchEnded(Touch *touch, Event *unused_event){
        auto moto = MoveTo::create(0.1, m__rocker_p);
        auto seq = Sequence::create(moto,CallFunc::create([this](){;}), NULL);
        m__rocker -> runAction(seq);
        
        auto p = touch->getLocation();
        if(onRockEnded) onRockEnded(p.x,p.y);
    }
    void Rocker::onTouchCancelled(Touch *touch, Event *unused_event){
        m__rocker -> setPosition(m__rocker_p);
        
        auto p = touch->getLocation();
        if(onRockCancelled) onRockCancelled(p.x,p.y);
    }
    void Rocker::onEnter(){
        Layer::onEnter();
    }
    void Rocker::onExit(){
        getEventDispatcher()->removeEventListenersForTarget(this);
        Layer::onExit();
    }

如何使用：

1、首先包含头文件

#include "Rocker.h"

2、在.h中加入4个方法

void onRockBegan(float,float,bool);
        void onRockMoved(float,float);
        void onRockEnded(float,float);
        void onRockCancelled(float,float);

3、在.cpp的某个初始化方法中，一般写在init()中

Size visibleSize = Director::getInstance()->getVisibleSize();
        auto rocker = Rocker::create(256, 500, "Back_04.png", "Joystick_04.png", Point(visibleSize.width/2,visibleSize.height/2));
        addChild(rocker);
        rocker -> onRockBegan = CC_CALLBACK_3(HelloWorld::onRockBegan, this);
        rocker -> onRockMoved = CC_CALLBACK_2(HelloWorld::onRockMoved, this);
        rocker -> onRockEnded = CC_CALLBACK_2(HelloWorld::onRockEnded, this);
        rocker -> onRockCancelled = CC_CALLBACK_2(HelloWorld::onRockCancelled, this);

然后

void HelloWorld::onRockBegan(float x,float y,bool t){
        if (t) {
            log("有效began:%f-%f",x,y);
        }else{
            log("无效began:%f-%f",x,y);
        }
    }
    void HelloWorld::onRockMoved(float x,float y){
        log("Moved:%f-%f",x,y);
    }
    void HelloWorld::onRockEnded(float x,float y){
        log("Ended:%f-%f",x,y);
    }
    void HelloWorld::onRockCancelled(float x,float y){
        log("Cancelled:%f-%f",x,y);
    }

全部代码都贴在这里了