Cocos2dx学习笔记（13）——事件分发机制

本篇承接触摸事件2.x，将讲一讲3.x版本中的人机交互。

本文仅供个人记录和复习，不用于其他用途

3.x版本的改变

上一章我们学习了2.x的触摸事件，但是呢，事件的创建和移除都显得很繁琐。3.x版本对此作出了改变，我们不需要再重写那几种函数，仅仅只需要创建一个事件监听器用来实现各种触发后的逻辑，然后添加到事件分发器_eventDispatcher，所有事件监听器有这个分发器统一管理，即可完成事件响应。

事件监听器有以下几种：

• 触摸事件EventListenerTouch
• 键盘响应事件EventListenerKeyboard
• 鼠标响应事件EventListenerMouse
• 自定义事件EventListenerCustom
• 加速记录事件EventListenerAcceleration

_eventDispatcher的工作由三部分组成：

• 事件分发器EventDispatcher
• 事件类型EventTouch、EventKeyboard等
• 事件监听器EventListenerTouch、EventListenerKeyboard等

监听器实现了各种触发后的逻辑，在适当时候由事件分发器分发事件类型，然后调用相应类型的监听器。以上是我在官方文档搬运过来的，有什么疑问可以接着往下看。

事件分发器

_eventDispatcher是Node的属性，通过Director::getInstance()->getEventDispatcher()获得。事件监听器的添加用到的是如下方法：

_eventDispatcher->addEventListenerWithSceneGraphPriority(listener1, sprite1);
_eventDispatcher->addEventListenerWithSceneGraphPriority(listener1->clone(), sprite2);

注意，当再次使用listener1时，需要使用clone()方法复制一份，因为一个事件监听器只能添加一次。当然，这里我们还可以使用addEventListenerWithFixedPriority()方法添加监听器。这两种方法的区别在于，FixedPriority中的监听器需要我们手动移除，而SceneGraphPriority中的则会自动被移除。

另外，如果想要移除被添加的监听器，可以使用下面的方法：

// 移除一个监听器
_eventDispatcher->removeEventListener(listener);
// 移除所有监听器
_eventDispatcher->removeAllEventListeners();

建议使用第一个方法，第二种方法会移除掉所有监听器，也就是说连菜单按钮中的触摸事件都被移除了，使得用户无法退出。

class EventDispatcher : public Ref
{
/*
添加监听器
    - addEventListenerWithSceneGraphPriority
    - addEventListenerWithFixedPriority
    - addCustomEventListener
*/
    // 使用 场景图的优先级 为指定事件添加一个监听. 
    // listener : 指定要监听的事件.
    // node     : 这个节点的绘制顺序是基于监听优先级. 
    // 优先级   : 0
    void addEventListenerWithSceneGraphPriority(EventListener* listener, Node* node);
 
    // 使用 一定的优先级 为指定事件添加一个监听. 
    // listener      : 指定要监听的事件. 
    // fixedPriority : 这个监听器的固定优先级.
    // 优先级        : fixedPriority。(但是不能为0，因为他是场景图的基本优先级)
    void addEventListenerWithFixedPriority(EventListener* listener, int fixedPriority);
 
    // 用户自定义监听器
    EventListenerCustom* addCustomEventListener(const std::string &eventName, const std::function<void(EventCustom*)>& callback);
 
 
/*
删除监听器
    - removeEventListener
    - removeEventListenersForType
    - removeEventListenersForTarget
    - removeCustomEventListeners
    - removeAllEventListeners
*/
    // 删除指定监听器
    void removeEventListener(EventListener* listener);
 
    // 删除某类型对应的所有监听器
    // EventListener::Type::
    // 单点触摸 : TOUCH_ONE_BY_ONE
    // 多点触摸 : TOUCH_ALL_AT_ONCE
    // 键盘     : KEYBOARD
    // 鼠标     : MOUSE
    // 加速计   : ACCELERATION
    // 自定义   : CUSTOM
    void removeEventListenersForType(EventListener::Type listenerType);
 
    // 删除绑定在节点target上的所有监听器
    void removeEventListenersForTarget(Node* target, bool recursive = false);
 
    // 删除名字为customEventName的所有自定义监听器
    void removeCustomEventListeners(const std::string& customEventName);
 
    // 移除所有监听器
    void removeAllEventListeners();
 
 
/*
暂停、恢复在节点target上的所有监听器
    - pauseEventListenersForTarget
    - resumeEventListenersForTarget
*/
    void pauseEventListenersForTarget(Node* target, bool recursive = false);
    void resumeEventListenersForTarget(Node* target, bool recursive = false);
 
 
/*
其他
    - setPriority
    - setEnabled
    - dispatchEvent
    - dispatchCustomEvent
*/
    // 设置某监听器的优先级
    void setPriority(EventListener* listener, int fixedPriority);
 
    // 启用事件分发器
    void setEnabled(bool isEnabled);
    bool isEnabled() const;
 
    // 手动派发自定义事件
    void dispatchEvent(Event* event);
 
    // 给名字为eventName的自定义监听器, 绑定用户数据
    void dispatchCustomEvent(const std::string &eventName, void *optionalUserData = nullptr);
}

上面是EventDispatcher类的部分源码注释，具体的已经说得很清楚了，这里就不再赘述。

触摸优先权

SceneGraphPriority使用这个函数添加事件监听器的时候，它的优先级是根据精灵的显示顺序来确定的，如果精灵的位置靠前，将首先接受到触摸。而FixedPriority是根据你传递进去的值来确定的，值越小，优先级越高。注意，SceneGraphPriority的优先权默认从0开始。

触摸事件

在2.x版本中，我们需要先注册，然后再重载多个方法才能完成触摸事件的编码。在3.x版本中，既可以重写三个方法onTouchBegan，onTouchMoved和onTouchEnded，也可以直接通过Lambda表达式完成响应逻辑。这里Lambda表达式由于还没有总结，暂时不讲，具体的可以查看C++学习笔记。

单点触摸器

static EventListenerTouchOneByOne* create();
     
std::function<bool(Touch*, Event*)> onTouchBegan; //只有这个返回值为 bool
std::function<void(Touch*, Event*)> onTouchMoved;
std::function<void(Touch*, Event*)> onTouchEnded;
std::function<void(Touch*, Event*)> onTouchCancelled;

// 使用举例
// 获取事件分发器
auto dispatcher = Director::getInstance()->getEventDispatcher();
 
// 创建单点触摸监听器 EventListenerTouchOneByOne
auto touchListener = EventListenerTouchOneByOne::create();
     
// 单点触摸响应事件绑定
touchListener->onTouchBegan     = CC_CALLBACK_2(HelloWorld::onTouchBegan, this);
touchListener->onTouchMoved     = CC_CALLBACK_2(HelloWorld::onTouchMoved, this);
touchListener->onTouchEnded     = CC_CALLBACK_2(HelloWorld::onTouchEnded, this);
touchListener->onTouchCancelled = CC_CALLBACK_2(HelloWorld::onTouchCancelled, this);
     
// 在事件分发器中，添加触摸监听器，事件响应委托给 this 处理
dispatcher->addEventListenerWithSceneGraphPriority(touchListener, this);
 
 
// 单点触摸事件响应函数
bool onTouchBegan(Touch *touch, Event *unused_event)     { CCLOG("began"); return true; }
void onTouchMoved(Touch *touch, Event *unused_event)     { CCLOG("moved"); }
void onTouchEnded(Touch *touch, Event *unused_event)     { CCLOG("ended"); }
void onTouchCancelled(Touch *touch, Event *unused_event) { CCLOG("cancelled"); }

多点触摸监听器

static EventListenerTouchAllAtOnce* create();
     
std::function<void(const std::vector<Touch*>&, Event*)> onTouchesBegan;
std::function<void(const std::vector<Touch*>&, Event*)> onTouchesMoved;
std::function<void(const std::vector<Touch*>&, Event*)> onTouchesEnded;
std::function<void(const std::vector<Touch*>&, Event*)> onTouchesCancelled;

// 使用举例
// 获取事件分发器
auto dispatcher = Director::getInstance()->getEventDispatcher();
     
// 创建多点触摸监听器 EventListenerTouchAllAtOnce
auto touchesListener = EventListenerTouchAllAtOnce::create();
     
// 多点触摸响应事件绑定
touchesListener->onTouchesBegan     = CC_CALLBACK_2(HelloWorld::onTouchesBegan, this);
touchesListener->onTouchesMoved     = CC_CALLBACK_2(HelloWorld::onTouchesMoved, this);
touchesListener->onTouchesEnded     = CC_CALLBACK_2(HelloWorld::onTouchesEnded, this);
touchesListener->onTouchesCancelled = CC_CALLBACK_2(HelloWorld::onTouchesCancelled, this);
     
// 在事件分发器中，添加触摸监听器，事件响应委托给 this 处理
dispatcher->addEventListenerWithSceneGraphPriority(touchesListener, this);
 
 
// 多点触摸事件响应函数
void onTouchesBegan(const std::vector<Touch*>& touches, Event *unused_event)    { CCLOG("began"); }
void onTouchesMoved(const std::vector<Touch*>& touches, Event *unused_event)    { CCLOG("moved"); }
void onTouchesEnded(const std::vector<Touch*>& touches, Event *unused_event)    { CCLOG("ended"); }
void onTouchesCancelled(const std::vector<Touch*>&touches, Event *unused_event) { CCLOG("cancelled"); }

鼠标响应事件

鼠标事件监听器相关：

static EventListenerMouse* create();
 
std::function<void(Event* event)> onMouseDown;     //按下鼠标, 单击鼠标
std::function<void(Event* event)> onMouseUp;   //松开鼠标, 按下的状态下松开
std::function<void(Event* event)> onMouseMove;  //移动鼠标, 在屏幕中移动
std::function<void(Event* event)> onMouseScroll;//滚动鼠标, 滚动鼠标的滚轮

// 使用举例
// 获取事件分发器
auto dispatcher = Director::getInstance()->getEventDispatcher();
     
// 创建鼠标事件监听器 EventListenerMouse
EventListenerMouse* mouseListenter = EventListenerMouse::create();
     
// 鼠标事件响应函数
mouseListenter->onMouseDown   = CC_CALLBACK_1(HelloWorld::onMouseDown,   this);
mouseListenter->onMouseUp     = CC_CALLBACK_1(HelloWorld::onMouseUp,     this);
mouseListenter->onMouseMove   = CC_CALLBACK_1(HelloWorld::onMouseMove,   this);
mouseListenter->onMouseScroll = CC_CALLBACK_1(HelloWorld::onMouseScroll, this);
     
// 添加鼠标事件监听器，事件响应处理委托给this
dispatcher->addEventListenerWithSceneGraphPriority(mouseListenter, this);
     
     
// 事件响应函数
void onMouseDown(Event* event)   { CCLOG("Down"); }
void onMouseUp(Event* event)     { CCLOG("UP"); }
void onMouseMove(Event* event)   { CCLOG("MOVE"); }
void onMouseScroll(Event* event) { CCLOG("Scroll"); }

键盘事件

键盘事件监听器相关：

static EventListenerKeyboard* create();
 
std::function<void(EventKeyboard::KeyCode, Event*)> onKeyPressed;  //按下某键
std::function<void(EventKeyboard::KeyCode, Event*)> onKeyReleased; //松开某键
 
     
// 键盘按键枚举类型 EventKeyboard::KeyCode
// KeyCode的值对应的不是键盘的键值、也不是ASCII码，只是纯粹的枚举类型  
// 例如:
// EventKeyboard::KeyCode::KEY_A
// EventKeyboard::KeyCode::KEY_1
// EventKeyboard::KeyCode::KEY_F1
// EventKeyboard::KeyCode::KEY_SPACE
// EventKeyboard::KeyCode::KEY_ALT
// EventKeyboard::KeyCode::KEY_SHIFT

// 使用举例
// 获取事件分发器
auto dispatcher = Director::getInstance()->getEventDispatcher();
 
// 创建键盘按键事件监听器
EventListenerKeyboard* keyboardListener = EventListenerKeyboard::create();
     
// 绑定事件响应函数
keyboardListener->onKeyPressed = CC_CALLBACK_2(HelloWorld::onKeyPressed, this);
keyboardListener->onKeyReleased = CC_CALLBACK_2(HelloWorld::onKeyReleased, this);
     
// 添加监听器
dispatcher->addEventListenerWithSceneGraphPriority(keyboardListener, this);
     
     
// 事件响应函数
void onKeyPressed(EventKeyboard::KeyCode keyCode, Event* event)
{
    if (EventKeyboard::KeyCode::KEY_J == keyCode)
    {
        CCLOG("Pressed: J");
    }
}
void onKeyReleased(EventKeyboard::KeyCode keyCode, Event* event)
{
    if (EventKeyboard::KeyCode::KEY_SPACE == keyCode)
    {
        CCLOG("Released: SPACE");
    }
}

加速计事件

所谓的加速计，也就是计算重力加速度的。简单点来说，手机上的赛车游戏，一般都是通过左右摇晃手机来控制赛车方向。那么这里呢，重力感应来自移动设备的加速计，通常支持(X, Y, Z)三个方向的加速度感应，所以又称为三向加速计。在实际应用中，可以根据3个方向的力度大小来计算手机倾斜的角度或方向。

// 加速计用到的是Acceleration类
class Acceleration
{
    double x; double y; double z;
};

// 在使用前，必须先要开启设备的加速度计
Device::setAccelerometerEnabled(true);

加速计监听器相关：

static EventListenerAcceleration* create(const std::function<void(Acceleration*, Event*)>& callback);
 
std::function<void(Acceleration*, Event*)> onAccelerationEvent;

// 使用举例
// 标签: 显示加速计信息
label = Label::createWithTTF("no used", "Marker Felt.ttf", 12);
label->setPosition(visibleSize / 2);
this->addChild(label);
     
 
// 小球: 可视化加速计
ball = Sprite::create("ball.png");
ball->setPosition(visibleSize / 2);
this->addChild(ball);
 
 
// 获取事件分发器
auto dispatcher = Director::getInstance()->getEventDispatcher();
 
// 需要开启移动设备的加速计
Device::setAccelerometerEnabled(true);
     
// 创建加速计事件监听器
auto accelerationListener = EventListenerAcceleration::create(CC_CALLBACK_2(HelloWorld::onAccelerationEvent, this));
     
// 添加加速计监听器
dispatcher->addEventListenerWithSceneGraphPriority(accelerationListener, this);
     
     
// 事件响应函数
void HelloWorld::onAccelerationEvent(Acceleration* acceleration, Event* event)
{
    char s[100];
    sprintf(s, "X: %f; Y: %f; Z:%f; ", acceleration->x, acceleration->y, acceleration->z);
    label->setString(s);
 
    // 改变小球ball的位置
    float x = ball->getPositionX() + acceleration->x * 10;
    float y = ball->getPositionY() + acceleration->y * 10;
    Vec2 pos = Vec2(x, y);
    pos.clamp(ball->getContentSize() / 2, Vec2(288, 512) - ball->getContentSize() / 2);
    ball->setPosition(pos); // 设置位置
}

具体代码展示

bool HelloWorld::init()
{
    if ( !Layer::init() )
    {
        return false;
    }

    auto size = Director::getInstance()->getWinSize();

    auto sprite = Sprite::create("sprite.png");
    sprite->setPosition(CCPoint(size.width / 2, size.height / 2));
    this->addChild(sprite);

    // 创建一个单点触摸的事件监听器，用来监听单点触摸事件
    auto listener = EventListenerTouchOneByOne::create();
    // 指定触摸的回调函数
    listener->onTouchBegan = CC_CALLBACK_2(HelloWorld::onTouchBegan, this);
    listener->onTouchMoved = CC_CALLBACK_2(HelloWorld::onTouchMoved, this);
    listener->onTouchEnded = CC_CALLBACK_2(HelloWorld::onTouchEnded, this);
    // 设置是否吞噬触摸
    // 比如A在上B在下，如果onTouchBegan返回true，那么我们点击A之后B就不会有反应
    // 如果返回false，那么点击了A之后B也会执行回调事件
    listener->setSwallowTouches(true);
    // _eventDispatcher是事件分发器，用来分发不同类型的事件，这些类型包括触摸、键盘响应、加速度计、鼠标响应
    // _eventDispatcher是Node的一个属性，属于保护成员，用来管理节点的事件分发，是一个单例对象，可以通过如下的方法获取
    // Director::getInstance()->getEventDispatcher();
    // 将接受触摸的精灵和监听对象绑定起来，在node的析构函数中移除监听器，如果是fixedPriority因为没有绑定，需要手动移除
    // _eventDispatcher->addEventListenerWithSceneGraphPriority(listener, sprite);
    // 这里是固定优先级，而上边是显示优先级，显示优先级就是根据显示的顺序分发触摸事件，比如精灵1在精灵2的上面，则
    // 精灵1将首先接受到触摸消息，固定优先级的值越小优先级越高
    _eventDispatcher->addEventListenerWithFixedPriority(listener, 100);

    return true;
}

bool HelloWorld::onTouchBegan(Touch * touch, Event * pEvent)
{
    CCLOG("began");
    return true;
}

void HelloWorld::onTouchMoved(Touch * touch, Event * pEvent)
{
    CCLOG("moved");
}

void HelloWorld::onTouchEnded(Touch * touch, Event * pEvent)
{
    CCLOG("ended");
}

上面的代码只是实现了在你点击之后，在控制台输出相应的信息。那么，我们来实现一点更复杂的：

// 实现点击精灵移动的效果
bool HelloWorld::init()
{
    if ( !Layer::init() )
    {
        return false;
    }

    auto size = Director::getInstance()->getWinSize();

    // 创建一个精灵
    auto sprite = Sprite::create("sprite.png");
    sprite->setPosition(CCPoint(size.width / 2, size.height / 2));
    this->addChild(sprite);

    // 创建一个单点触摸事件的监听器，和回调函数绑定
    auto listener = EventListenerTouchOneByOne::create();
    listener->onTouchBegan = CC_CALLBACK_2(HelloWorld::onTouchBegan, this);
    listener->onTouchMoved = CC_CALLBACK_2(HelloWorld::onTouchMoved, this);
    listener->onTouchEnded = CC_CALLBACK_2(HelloWorld::onTouchEnded, this);
    // 设置吞噬
    listener->setSwallowTouches(true);

    // 添加到分发器中，第二个参数代表希望得到触摸的节点
    _eventDispatcher->addEventListenerWithSceneGraphPriority(listener, sprite);

    return true;
}

bool HelloWorld::onTouchBegan(Touch * touch, Event * pEvent)
{
    // getCurrentTarget获取当前的触摸目标
    // static_cast < type-id > ( expression )将表达式转化为type-id类型
    auto sprite = static_cast<Sprite *>(pEvent->getCurrentTarget());
    auto rect = sprite->getBoundingBox();
    auto point = touch->getLocation();
    // 判断点击点是否在精灵上
    if(rect.containsPoint(point))
    {
        return true;
    }

    return false;
}

void HelloWorld::onTouchMoved(Touch * touch, Event * pEvent)
{
    auto sprite = static_cast<Sprite *>(pEvent->getCurrentTarget());
    // getDelta返回触摸的坐标的增量，有了这个函数处理起来方便多了
    sprite->setPosition(sprite->getPosition() + touch->getDelta());
}

void HelloWorld::onTouchEnded(Touch * touch, Event * pEvent)
{
    CCLOG("end!");
}

上述的代码可以实现精灵的拖动，我们再来看看优先级有关的用法：

bool HelloWorld::init()
{
    if ( !Layer::init() )
    {
        return false;
    }

    auto size = Director::getInstance()->getWinSize();

    // 创建精灵
    auto sprite = Sprite::create("sprite.png");
    sprite->setPosition(CCPoint(size.width / 2, size.height / 2));
    this->addChild(sprite);

    auto sprite2 = Sprite::create("sprite2.png");
    sprite2->setPosition(CCPoint(size.width / 2, size.height * 0.6));
    this->addChild(sprite2);

    auto sprite3 = Sprite::create("sprite.png");
    sprite3->setPosition(CCPoint(size.width / 3, size.height / 3));
    this->addChild(sprite3);

    // 创建一个单点触摸事件的监听器，和回调函数绑定
    auto listener = EventListenerTouchOneByOne::create();
    listener->onTouchBegan = CC_CALLBACK_2(HelloWorld::onTouchBegan, this);
    listener->onTouchMoved = CC_CALLBACK_2(HelloWorld::onTouchMoved, this);
    listener->onTouchEnded = CC_CALLBACK_2(HelloWorld::onTouchEnded, this);
    // 设置吞噬
    listener->setSwallowTouches(true);

    // 添加到分发器中，第二个参数代表希望得到触摸的节点
    _eventDispatcher->addEventListenerWithSceneGraphPriority(listener, sprite);
    // 一个事件监听器只能被添加一次，我们要想使用一个事件监听器，就得使用它的clone方法，这个方法是克隆一个一模一样
    // 的监听器，这里传入的第二个参数变为了sprite2，代表sprite2希望得到触摸事件
    _eventDispatcher->addEventListenerWithSceneGraphPriority(listener->clone(), sprite2);

    return true;
}

回调函数没有发生改变。我们创建了三个精灵，sprite、sprite2、sprite3，前俩个精灵在将触摸监听器添加到事件分发器中的时候传入了自己，作为第二个参数，所以在回调函数的处理中，获得的就是自己了，然后就实现了拖动的效果，sprite3拖动是没有效果的。在2.x的时候我们一般将希望接受触摸的精灵作为成员函数，然后在回调函数中去判断。