使用Sneaky 的源码改写的在cocos2d-x 2.x后的版本中~可以使用来遥控物体

下面的源码是用开源的Sneaky 改的， 可以在cocos2d-x 2.0.x后的版本运行。 只需要修改几个地方。

在当前改好的源码里，我加入了JoyStick控制方向的时候改变按钮的状态。 分为diable 和press 。 加入了相应方法。 有的方法里对应的进行修改。

如果有哪里改的不好或是还要改进的建议，需要提下，谢谢留个言~

这个sneaky 主要是四个类。 SneakyButtton ，SneakButtonSkinnedBase，SneakyJoystic，SneakyJoysticSkinnerBase。

我在我的工程里用到，写了个使用sneaky的类ToggleLayer。

使用的时候可以复制所有，然后修改toggleLayer的相应方法里的数据就可以达到控制目的。

SneakyButton.h~~~~~~~~~~~

#ifndef __SNEAKY_BUTTON_H__
#define __SNEAKY_BUTTON_H__

#include "cocos2d.h"

class SneakyButton : public cocos2d::CCNode, public cocos2d::CCTargetedTouchDelegate
{
public:
static SneakyButton *initSneakyButton();

protected:
cocos2d::CCPoint center;
float radiusSq;

cocos2d::CCRect bounds;

CC_SYNTHESIZE(bool, status, Status);
CC_SYNTHESIZE_READONLY(bool, active, IsActive);
CC_SYNTHESIZE_READONLY(bool, value, Value);
CC_SYNTHESIZE(bool, isHoldable, IsHoldable);
CC_SYNTHESIZE(bool, isToggleable, IsToggleable);
CC_SYNTHESIZE(float, rateLimit, RateLimit);

CC_SYNTHESIZE_READONLY(float, radius, Radius);

//Public methods
virtual void onEnterTransitionDidFinish();
virtual void onExit();
bool initWithRect(cocos2d::CCRect rect);
void limiter(float delta);
void setRadius(float r);

virtual bool ccTouchBegan(cocos2d::CCTouch *touch, cocos2d::CCEvent *event);
virtual void ccTouchMoved(cocos2d::CCTouch *touch, cocos2d::CCEvent *event);
virtual void ccTouchEnded(cocos2d::CCTouch *touch, cocos2d::CCEvent *event);
virtual void ccTouchCancelled(cocos2d::CCTouch *touch, cocos2d::CCEvent *event);

void touchDelegateRelease();
void touchDelegateRetain();
};

#endif

sneakyButton.cpp

#include "SneakyButton.h"

using namespace cocos2d;

void SneakyButton::onEnterTransitionDidFinish()
{
CCDirector::sharedDirector()->getTouchDispatcher()->addTargetedDelegate(this, 1, true);
}

void SneakyButton::onExit()
{
CCDirector::sharedDirector()->getTouchDispatcher()->removeDelegate(this);
}

bool SneakyButton::initWithRect(CCRect rect)
{
bool pRet = false;
//if(CCSprite::init()){

bounds = CCRectMake(0, 0, rect.size.width, rect.size.height);
center = CCPointMake(rect.size.width/2, rect.size.height/2);
status = 1; //defaults to enabled
active = false;
value = 0;
isHoldable = 0;
isToggleable = 0;
radius = 32.0f;
rateLimit = 1.0f/120.0f;

setPosition(rect.origin); //not sure about this
pRet = true;
//}
return pRet;
}

void SneakyButton::limiter(float delta)
{
value = 0;
this->unschedule(schedule_selector(SneakyButton::limiter));
active = false;
}

void SneakyButton::setRadius(float r)
{
radius = r;
radiusSq = r*r;
}

bool SneakyButton::ccTouchBegan(CCTouch *touch, CCEvent *event)
{
if (active) return false;

CCPoint location = CCDirector::sharedDirector()->convertToGL(touch->locationInView());
location = this->convertToNodeSpace(location);
//Do a fast rect check before doing a circle hit check:
if(location.x < -radius || location.x > radius || location.y < -radius || location.y > radius){
return false;
}else{
float dSq = location.x*location.x + location.y*location.y;
if(radiusSq > dSq){
active = true;
if (!isHoldable && !isToggleable){
value = 1;
this->schedule(schedule_selector(SneakyButton::limiter), rateLimit);
}
if (isHoldable) value = 1;
if (isToggleable) value = !value;
return true;
}
}
return false;
}

void SneakyButton::ccTouchMoved(CCTouch *touch, CCEvent *event)
{
if (!active) return;

CCPoint location = CCDirector::sharedDirector()->convertToGL(touch->locationInView());
location = this->convertToNodeSpace(location);
//Do a fast rect check before doing a circle hit check:
if(location.x < -radius || location.x > radius || location.y < -radius || location.y > radius){
return;
}else{
float dSq = location.x*location.x + location.y*location.y;
if(radiusSq > dSq){
if (isHoldable) value = 1;
}
else {
if (isHoldable) value = 0; active = false;
}
}
}

void SneakyButton::ccTouchEnded(CCTouch *touch, CCEvent *event)
{
if (!active) return;
if (isHoldable) value = 0;
if (isHoldable||isToggleable) active = false;
}

void SneakyButton::ccTouchCancelled(CCTouch *touch, CCEvent *event)
{
this->ccTouchEnded(touch, event);
}

void SneakyButton::touchDelegateRelease()
{
this->release();
}

void SneakyButton::touchDelegateRetain()
{
this->retain();
}

SneakyButton * SneakyButton::initSneakyButton()
{
SneakyButton *button = new SneakyButton();
button->initWithRect(CCRectZero);
button->autorelease();
return button;
}

SneakyButtonSkinnedBase.h

#ifndef __SNEAKY_BUTTON_SKINNED_H__
#define __SNEAKY_BUTTON_SKINNED_H__

#include "SneakyButton.h"

class SneakyButtonSkinnedBase : public cocos2d::CCLayer
{
CC_SYNTHESIZE_READONLY(cocos2d::CCSprite *, defaultSprite, DefaultSprite);
CC_SYNTHESIZE_READONLY(cocos2d::CCSprite *, activatedSprite, ActivatedSprite);
CC_SYNTHESIZE_READONLY(cocos2d::CCSprite *, disabledSprite, DisabledSprite);
CC_SYNTHESIZE_READONLY(cocos2d::CCSprite *, pressSprite, PressSprite);

CC_SYNTHESIZE_READONLY(SneakyButton *, button, Button); //Not sure about this

//Public methods
LAYER_NODE_FUNC(SneakyButtonSkinnedBase);
SneakyButtonSkinnedBase();
virtual ~SneakyButtonSkinnedBase();
bool init();
void watchSelf(float delta);
void setContentSize(cocos2d::CCSize s);
void setDefaultSprite(cocos2d::CCSprite *aSprite);
void setActivatedSprite(cocos2d::CCSprite *aSprite);
void setDisabledSprite(cocos2d::CCSprite *aSprite);
void setPressSprite(cocos2d::CCSprite *aSprite);
void setButton(SneakyButton *aButton);
};

#endif

SneakyButtonSkinnerBase.cpp

#include "SneakyButtonSkinnedBase.h"

using namespace cocos2d;

SneakyButtonSkinnedBase::~SneakyButtonSkinnedBase()
{
if (defaultSprite)
{
defaultSprite->release();
defaultSprite = NULL;
}
if (activatedSprite)
{
activatedSprite->release();
activatedSprite = NULL;
}
if (disabledSprite)
{
disabledSprite->release();
disabledSprite = NULL;
}
if (pressSprite)
{
pressSprite->release();
pressSprite = NULL;
}
if (button)
{
button->release();
button = NULL;
}

this->unschedule(schedule_selector(SneakyButtonSkinnedBase::watchSelf));

}

bool SneakyButtonSkinnedBase::init() //Possible errors here
{
bool pRet = false;
if(CCLayer::init()){
this->defaultSprite = NULL;
//defaultSprite->retain();
this->activatedSprite = NULL;
//activatedSprite->retain();
this->disabledSprite = NULL;
//disabledSprite->retain();
this->pressSprite = NULL;
//pressSprite->retain();
this->button = NULL;
//button->retain();

this->schedule(schedule_selector(SneakyButtonSkinnedBase::watchSelf));
pRet = true;
}
return pRet;
}

void SneakyButtonSkinnedBase::watchSelf(float delta) //Be Careful Here
{
if (!this->button->getStatus()){
if(disabledSprite){
disabledSprite->setVisible(true);
}
else {
disabledSprite->setVisible(false);
}
}
else {
if(!this->button->getIsActive()){
pressSprite->setVisible(false);
if(this->button->getValue() == 0){
activatedSprite->setVisible(false);
if(defaultSprite){
defaultSprite->setVisible(true);
}
}
else {
activatedSprite->setVisible(true);
}
}
else {
defaultSprite->setVisible(false);
if(pressSprite){
pressSprite->setVisible(true);
}
}
}
}

void SneakyButtonSkinnedBase::setContentSize(CCSize s)
{
CCLayer::setContentSize(s);
//if (defaultSprite)
//{
//	defaultSprite->setContentSize(s);
//}
//button->setRadius(s.width/2);
}

void SneakyButtonSkinnedBase::setDefaultSprite(CCSprite *aSprite)
{
defaultSprite = aSprite; //Check again here
defaultSprite->retain();
if(aSprite){
this->addChild(defaultSprite, 0);

this->setContentSize(defaultSprite->getContentSize());
}
}

void SneakyButtonSkinnedBase::setActivatedSprite(CCSprite *aSprite)
{
/*if(activatedSprite){
if(activatedSprite->getParent())
activatedSprite->getParent()->removeChild(activatedSprite, true);
activatedSprite->release();
}*/
aSprite->retain();
activatedSprite = aSprite;
if(aSprite){
this->addChild(activatedSprite, 1);

this->setContentSize(activatedSprite->getContentSize());
}
}

void SneakyButtonSkinnedBase::setDisabledSprite(CCSprite *aSprite)
{
if(disabledSprite){
if(disabledSprite->getParent())
disabledSprite->getParent()->removeChild(disabledSprite, true);
disabledSprite->release();
}
aSprite->retain();
disabledSprite = aSprite;
if(aSprite){
this->addChild(disabledSprite, 2);

this->setContentSize(disabledSprite->getContentSize());
}
}

void SneakyButtonSkinnedBase::setPressSprite(CCSprite *aSprite)
{
/*if(pressSprite){
if(pressSprite->getParent())
pressSprite->getParent()->removeChild(pressSprite, true);
pressSprite->release();
}*/
aSprite->retain();
pressSprite = aSprite;
if(aSprite){
this->addChild(pressSprite, 3);

this->setContentSize(pressSprite->getContentSize());
}
}

void SneakyButtonSkinnedBase::setButton(SneakyButton *aButton)
{
/*if(button){
if(button->getParent())
button->getParent()->removeChild(button, true);
button->release();
}*/
aButton->retain();
button = aButton;
if(aButton){
this->addChild(button, 4);
if(defaultSprite)
button->setRadius(defaultSprite->boundingBox().size.width/2);
}
}

SneakyButtonSkinnedBase::SneakyButtonSkinnedBase()
{
this->schedule(schedule_selector(SneakyButtonSkinnedBase::watchSelf));
}

SneakyJoyStick.h

#ifndef __SNEAKY_JOYSTICK_H__
#define __SNEAKY_JOYSTICK_H__

#include "cocos2d.h"

class SneakyJoystick : public cocos2d::CCNode, public cocos2d::CCTargetedTouchDelegate
{
protected:
float joystickRadiusSq;
float thumbRadiusSq;
float deadRadiusSq;

//来来检测当前按钮是否被按下。
CC_SYNTHESIZE_READONLY(bool, active, IsActive);
CC_SYNTHESIZE_READONLY(cocos2d::CCPoint, stickPosition, StickPosition);
CC_SYNTHESIZE_READONLY(float, degrees, Degrees);
CC_SYNTHESIZE_READONLY(cocos2d::CCPoint, velocity, Velocity);
CC_SYNTHESIZE(bool, autoCenter, AutoCenter);
CC_SYNTHESIZE_READONLY(bool, isDPad, IsDPad);
CC_SYNTHESIZE(bool, hasDeadzone, HasDeadzone);
CC_SYNTHESIZE(int, numberOfDirections, NumberOfDirections);

CC_SYNTHESIZE_READONLY(float, joystickRadius, JoystickRadius);
CC_SYNTHESIZE_READONLY(float, thumbRadius, ThumbRadius);
CC_SYNTHESIZE_READONLY(float, deadRadius, DeadRadius);

virtual ~SneakyJoystick();

bool initWithRect(cocos2d::CCRect rect);
virtual void onEnterTransitionDidFinish();
virtual void onExit();
void setIsDPad(bool b);
void setJoystickRadius(float r);
void setThumbRadius(float r);
void setDeadRadius(float r);
virtual bool ccTouchBegan(cocos2d::CCTouch *touch, cocos2d::CCEvent *event);
virtual void ccTouchMoved(cocos2d::CCTouch *touch, cocos2d::CCEvent *event);
virtual void ccTouchEnded(cocos2d::CCTouch *touch, cocos2d::CCEvent *event);
virtual void ccTouchCancelled(cocos2d::CCTouch *touch, cocos2d::CCEvent *event);

void touchDelegateRelease();
void touchDelegateRetain();

private:
void updateVelocity(cocos2d::CCPoint point);
void setTouchRadius();
};
#endif

SnekayJoyStick.cpp

#include "SneakyJoystick.h"

using namespace cocos2d;

#define SJ_PI 3.14159265359f
#define SJ_PI_X_2 6.28318530718f
#define SJ_RAD2DEG 180.0f/SJ_PI
#define SJ_DEG2RAD SJ_PI/180.0f

SneakyJoystick::~SneakyJoystick()
{
}

bool SneakyJoystick::initWithRect(CCRect rect)
{
bool pRet = false;
//if(CCSprite::init()){
stickPosition = CCPointZero;
degrees = 0.0f;
velocity = CCPointZero;
autoCenter = true;
isDPad = false;
hasDeadzone = false;
active = false;
numberOfDirections = 4;

this->setJoystickRadius(rect.size.width/2);
this->setThumbRadius(32.0f);
this->setDeadRadius(0.0f);

//Cocos node stuff
setPosition(rect.origin);
pRet = true;
//}
return pRet;
}

void SneakyJoystick::onEnterTransitionDidFinish()
{
CCDirector::sharedDirector()->getTouchDispatcher()->addTargetedDelegate(this, 1, true);
}

void SneakyJoystick::onExit()
{
CCDirector::sharedDirector()->getTouchDispatcher()->removeDelegate(this);
}

float round(float r) {
return (r > 0.0) ? floor(r + 0.5) : ceil(r - 0.5);
}

void SneakyJoystick::updateVelocity(CCPoint point)
{
// Calculate distance and angle from the center.
float dx = point.x;
float dy = point.y;
float dSq = dx * dx + dy * dy;

if(dSq <= deadRadiusSq){
velocity = CCPointZero;
degrees = 0.0f;
stickPosition = point;
return;
}

float angle = atan2f(dy, dx); // in radians
if(angle < 0){
angle		+= SJ_PI_X_2;
}
float cosAngle;
float sinAngle;

if(isDPad){
float anglePerSector = 360.0f / numberOfDirections * SJ_DEG2RAD;
angle = round(angle/anglePerSector) * anglePerSector;
}

cosAngle = cosf(angle);
sinAngle = sinf(angle);

// NOTE: Velocity goes from -1.0 to 1.0.
if (dSq > joystickRadiusSq || isDPad) {
dx = cosAngle * joystickRadius;
dy = sinAngle * joystickRadius;
}

velocity = CCPointMake(dx/joystickRadius, dy/joystickRadius);
degrees = angle * SJ_RAD2DEG;

// Update the thumb's position
stickPosition = ccp(dx, dy);
}

void SneakyJoystick::setIsDPad(bool b)
{
isDPad = b;
if(isDPad){
hasDeadzone = true;
this->setDeadRadius(10.0f);
}
}

void SneakyJoystick::setJoystickRadius(float r)
{
joystickRadius = r;
joystickRadiusSq = r*r;
}

void SneakyJoystick::setThumbRadius(float r)
{
thumbRadius = r;
thumbRadiusSq = r*r;
}

void SneakyJoystick::setDeadRadius(float r)
{
deadRadius = r;
deadRadiusSq = r*r;
}

bool SneakyJoystick::ccTouchBegan(CCTouch *touch, CCEvent *event)
{
CCPoint location = CCDirector::sharedDirector()->convertToGL(touch->locationInView());
//if([background containsPoint:[background convertToNodeSpace:location]]){
location = this->convertToNodeSpace(location);
//Do a fast rect check before doing a circle hit check:
if(location.x < -joystickRadius || location.x > joystickRadius || location.y < -joystickRadius || location.y > joystickRadius){
return false;
}else{
float dSq = location.x*location.x + location.y*location.y;
if(joystickRadiusSq > dSq){
this->updateVelocity(location);
this->active = true;
return true;
}
}
return false;
}

void SneakyJoystick::ccTouchMoved(CCTouch *touch, CCEvent *event)
{
CCPoint location = CCDirector::sharedDirector()->convertToGL(touch->locationInView());
location = this->convertToNodeSpace(location);
this->updateVelocity(location);
}

void SneakyJoystick::ccTouchEnded(CCTouch *touch, CCEvent *event)
{
CCPoint location = CCPointZero;
if(!autoCenter){
CCPoint location = CCDirector::sharedDirector()->convertToGL(touch->locationInView());
location = this->convertToNodeSpace(location);
}
this->updateVelocity(location);
this->active = false;
}

void SneakyJoystick::ccTouchCancelled(CCTouch *touch, CCEvent *event)
{
this->ccTouchEnded(touch, event);
}

void SneakyJoystick::touchDelegateRelease()
{
this->release();
}

void SneakyJoystick::touchDelegateRetain()
{
this->retain();
}

SneakyJoyStickSkinnerBase.h

#ifndef __JOYSTICK_SKINNED_H__
#define __JOYSTICK_SKINNED_H__

#include "cocos2d.h"
#include "SneakyJoystick.h"

class SneakyJoystickSkinnedBase : public cocos2d::CCLayer
{
CC_SYNTHESIZE_READONLY(cocos2d::CCSprite *, backgroundSprite, BackgroundSprite);
//当无压住按钮时候的sprite
CC_SYNTHESIZE_READONLY(cocos2d::CCSprite *, disableThumbSprite, DisableThumbSprite);
//当出现压住按钮时候的sprite
CC_SYNTHESIZE_READONLY(cocos2d::CCSprite *, pressThumbSprite, PressThumbSprite);

CC_SYNTHESIZE_READONLY(SneakyJoystick *, joystick, Joystick);

//Public methods
LAYER_NODE_FUNC(SneakyJoystickSkinnedBase);
virtual ~SneakyJoystickSkinnedBase();
bool init();
void updatePositions(float delta);
void setContentSize(cocos2d::CCSize s);
void setBackgroundSprite(cocos2d::CCSprite *aSprite);

void setDisableThumbSprite(cocos2d::CCSprite *aSprite);
void setPressThumbSprite(cocos2d::CCSprite *aSprite);

void setJoystick(SneakyJoystick *aJoystick);
};
#endif

SneakyJoyStickSkinner.cpp

#include "SneakyJoystickSkinnedBase.h"

using namespace cocos2d;

SneakyJoystickSkinnedBase::~SneakyJoystickSkinnedBase()
{
if (backgroundSprite)
{
backgroundSprite->release();
backgroundSprite = NULL;
}
if (pressThumbSprite)
{
pressThumbSprite->release();
pressThumbSprite = NULL;
}
if (disableThumbSprite)
{
disableThumbSprite->release();
disableThumbSprite = NULL;
}
if (joystick)
{
joystick->release();
joystick = NULL;
}
}

bool SneakyJoystickSkinnedBase::init()
{
bool pRet = false;
if(CCLayer::init()){
this->backgroundSprite = NULL;

this->disableThumbSprite = NULL;
this->pressThumbSprite = NULL;
this->joystick = NULL;

this->schedule(schedule_selector(SneakyJoystickSkinnedBase::updatePositions));
pRet = true;
}
return pRet;
}

void SneakyJoystickSkinnedBase::updatePositions(float delta)
{
if(joystick)
{
pressThumbSprite->setVisible(false);
disableThumbSprite->setVisible(false);
if (joystick->getIsActive())
{
if (pressThumbSprite){
pressThumbSprite->setVisible(true);
pressThumbSprite->setPosition(joystick->getStickPosition());
}
}
else{
if(disableThumbSprite)
{
disableThumbSprite->setVisible(true);
disableThumbSprite->setPosition(joystick->getStickPosition());
}
}
}
}

void SneakyJoystickSkinnedBase::setContentSize(CCSize s)
{
CCLayer::setContentSize(s);
}

void SneakyJoystickSkinnedBase::setBackgroundSprite(CCSprite *aSprite)
{
backgroundSprite = aSprite;
backgroundSprite->retain();
if(aSprite){
this->addChild(backgroundSprite, 0);

this->setContentSize(backgroundSprite->getContentSize());
}
}

void SneakyJoystickSkinnedBase::setJoystick(SneakyJoystick *aJoystick)
{
joystick = aJoystick;
joystick->retain();
if(aJoystick){
this->addChild(aJoystick, 2);
if(disableThumbSprite)
joystick->setThumbRadius(disableThumbSprite->boundingBox().size.width/2);
else
joystick->setThumbRadius(0);

if(backgroundSprite)
joystick->setJoystickRadius(backgroundSprite->boundingBox().size.width/2);
}
}

void SneakyJoystickSkinnedBase::setDisableThumbSprite( cocos2d::CCSprite *aSprite )
{
disableThumbSprite = aSprite;
disableThumbSprite->retain();

if(aSprite){
this->addChild(disableThumbSprite, 0);

//joystick->setThumbRadius(thumbSprite->getContentSize().width/2);
}
}

void SneakyJoystickSkinnedBase::setPressThumbSprite( cocos2d::CCSprite *aSprite )
{
pressThumbSprite = aSprite;
pressThumbSprite->retain();

if(aSprite){
this->addChild(pressThumbSprite, 1);

//joystick->setThumbRadius(thumbSprite->getContentSize().width/2);
}
}

ToggleLayer.h //用来演示如何使用上面的类

#include "cocos2d.h"

#include "SneakyButton.h"
#include "SneakyButtonSkinnedBase.h"
#include "SneakyJoystick.h"
#include "SneakyJoystickSkinnedBase.h"

USING_NS_CC;
/**
*遥控层
**/
class ToggleLayer :public cocos2d::CCLayer
{
public:
ToggleLayer(void);
~ToggleLayer(void);

//加入遥控和按钮
void addToggleAndButton();

private:
//摇杆和按钮触控update更新
void update(float dt);

SneakyButton *buttonA;
SneakyJoystick *joystick;
static float fireTime;
};

ToggleLayer.cpp

#include "ToggleLayer.h"
#include "GameScene.h"

ToggleLayer::ToggleLayer(void)
{
addToggleAndButton();
}

ToggleLayer::~ToggleLayer(void)
{
}

void ToggleLayer::addToggleAndButton()
{
CCSize size = CCDirector::sharedDirector()->getWinSize();
float buttonRadius=50;

buttonA=new SneakyButton();
buttonA->initWithRect(CCRectZero);
buttonA->setIsToggleable(false);
buttonA->setIsHoldable(true);

//SneakyButtonSkinnedBase *buttonASkin=new SneakyButtonSkinnedBase();
SneakyButtonSkinnedBase *buttonASkin= new SneakyButtonSkinnedBase();//::createSkin();
buttonASkin->init();
buttonASkin->setPosition(ccp(size.width-buttonRadius,buttonRadius));
buttonASkin->setDefaultSprite(CCSprite::create("button-default.png"));//可以修改
// buttonASkin->setDisabledSprite(CCSprite::spriteWithFile("button-disabled.png"));//
buttonASkin->setPressSprite(CCSprite::create("button-pressed.png"));//可以修改
buttonASkin->setActivatedSprite(CCSprite::create("button-activated.png"));//可以修改
buttonASkin->setButton(buttonA);

this->addChild(buttonASkin);

float joystickRadius=50;

joystick=new SneakyJoystick();
joystick->initWithRect(CCRectZero);
joystick->setAutoCenter(true);
joystick->setHasDeadzone(true);
joystick->setDeadRadius(10);

SneakyJoystickSkinnedBase *joystickSkin=new SneakyJoystickSkinnedBase();
joystickSkin->init();
CCSprite *bgSprite = CCSprite::create("skeany_bg.png");
joystickSkin->setBackgroundSprite(bgSprite);
//默认的Sprite
joystickSkin->setDisableThumbSprite(CCSprite::create("skeanyCenter.png"));  //disable的状态的图片
//当出现压住按钮时候的sprite
joystickSkin->setPressThumbSprite(CCSprite::create("skeanyCenter2.png")); //press的状态时候的图片

//joystickSkin->getThumbSprite()->setScale(0.5f);
joystickSkin->setPosition(
ccp(bgSprite->getContentSize().width*0.5f+10,bgSprite->getContentSize().height*0.5+10));
joystickSkin->setJoystick(joystick);

this->addChild(joystickSkin);

this->scheduleUpdate();
}
#define FIRE_INTERVAL 0.3f
float ToggleLayer::fireTime=0;

void ToggleLayer::update( float dt )
{
CCPoint velocity=joystick->getVelocity();
if(velocity.x!=0||velocity.y!=0)
{
velocity = ccpMult(velocity,2.5);
CCLOG("joystick:[%f,%f]",velocity.x,velocity.y);
//CCPoint position = GameScene::shareGameScene()->getShip()->getPosition();
//if (GameScene::shareGameScene()->getShip())
//{
//	GameScene::shareGameScene()->getShip()->setPosition(ccpAdd(position,velocity));
//}

//这里加入你要控制方向的精灵。

}

fireTime+=dt;

if(buttonA->getIsActive()&&fireTime>=FIRE_INTERVAL)
{
CCLOG("buttonA pressed.");
//if(GameScene::shareGameScene()->getShip())
//	GameScene::shareGameScene()->getShip()->shootButtleFromToggle();
fireTime=0;
}
}

使用后的效果示意图：