cocos2dx+lua注册事件函数详解 事件

coocs2dx 版本 3.1.1

registerScriptTouchHandler             注册触屏事件

registerScriptTapHandler                  注册点击事件

registerScriptHandler                         注册基本事件 包括 触屏 层的进入 退出 事件

registerScriptKeypadHandler           注册键盘事件

registerScriptAccelerateHandler      注册加速事件

registerScriptTouchHandler 详解（可以设置单点或多点）

function gameWindow:addLayerTouchEventMethod1()
    local function onTouchEvent(eventType, x, y)
        --log("eventType = "..tostring(eventType))
        if eventType == "began" then 
            --需要返回true
            return onTouchBegan(touch, event)
        elseif eventType == "moved" then 
            onTouchMoved(touch, event)
        elseif eventType == "ended" then 
            onTouchEnded(touch, event)
        end
    end
    config.bottomLayer:setTouchEnabled(true)
    config.bottomLayer:registerScriptTouchHandler(onTouchEvent)
end

registerScriptTapHandler                  注册点击事件 

function gameWindow:addBtn()
    local btn = cc.MenuItemImage:create("white.png", "black.png", "black.png")
    btn:setPosition(320, 160)
    local function btnClick()
        log("btnClick")
    end
    btn:registerScriptTapHandler(btnClick)

    local menu = cc.Menu:create()
    config.bottomLayer:addChild(menu)
    menu:setPosition(cc.p(0,0))

    menu:addChild(btn)
end

registerScriptHandler                         注册基本事件 

注册触屏事件用法

function gameWindow:addLayerTouchEventMethod2()
    --创建一个单点触屏事件
    local listener = cc.EventListenerTouchOneByOne:create()
    --注册触屏开始事件
    listener:registerScriptHandler(onTouchBegan, cc.Handler.EVENT_TOUCH_BEGAN)
    --注册触屏移动事件
    listener:registerScriptHandler(onTouchMoved, cc.Handler.EVENT_TOUCH_MOVED)
    --注册触屏结束事件
    listener:registerScriptHandler(onTouchEnded, cc.Handler.EVENT_TOUCH_ENDED)
    --获取层的事件派发器
    local eventDispatcher = config.bottomLayer:getEventDispatcher()
    --事件派发器 注册一个node事件
    eventDispatcher:addEventListenerWithSceneGraphPriority(listener, config.bottomLayer)
end

注册layer的 进入 退出事件用法

function gameWindow:addLayerEnterAndExitEvent()
    local function onNodeEvent(eventType)
        if eventType == "enter" then
            log("enter")
        elseif eventType == "exit" then
            log("exit")
        end
    end
    config.bottomLayer:registerScriptHandler(onNodeEvent)
end

 而在3.x中由于加入了C++11的特性，而对事件的分发机制通过事件分发器EventDispatcher 来进行统一的管理。

    事件监听器主要有：

    > 触摸事件     : EventListenerTouchOneByOne、EventListenerTouchAllAtOnce

    > 鼠标响应事件 : EventListenerMouse

    > 键盘响应事件 : EventListenerKeyboard

    > 加速计事件   : EventListenerAcceleration

    > 自定义事件   : EventListenerCustom

    > 物理碰撞事件 : EventListenerPhysicsContact

    > 游戏手柄事件 : EventListenerController

【致谢】

    http://www.cnblogs.com/Richard-Core/p/3892641.html

    http://blog.csdn.net/runaying/article/details/16352879

---

【事件分发器】

    事件分发器EventDispatcher，用于统一管理事件监听器的所有事件的分发。

1、_eventDispatcher

    _eventDispatcher是Node的属性，通过Director::getInstance()->getEventDispatcher() 获得。

    _eventDispatcher的工作由三部分组成：

      （1）事件分发器 ：EventDispatcher。

      （2）事件类型   ：EventTouch, EventKeyboard 等。

      （3）事件监听器 ：EventListenerTouch, EventListenerKeyboard 等。

    监听器实现了各种触发后的逻辑，在适当时候由事件分发器分发事件类型，然后调用相应类型的监听器。

2、添加/删除监听器

    添加监听器：addEventListenerWithSceneGraphPriority ，

                addEventListenerWithFixedPriority 。

    删除监听器：removeEventListener ，

                removeAllEventListeners 。

3、主要函数

    包含监听器的添加、删除、暂停、恢复，优先级的设置，手动分发事件等。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86

// 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); } //

4、关于事件监听器的优先权

    通过 addEventListenerWithSceneGraphPriority 添加的监听器，优先权为0。

    通过 addEventListenerWithFixedPriority 添加的监听器，可以自定义优先权，但不能为0。

    > 优先级越低，越先响应事件。

    > 如果优先级相同，则上层的（z轴）先接收触摸事件。

5、使用步骤

    （1）获取事件分发器  ：dispatcher = Director::getInstance()->getEventDispatcher();

    （2）创建监听器      ：auto listener = EventListenerTouchOneByOne::create();

    （3）绑定响应事件函数：listener->onTouchBegan = CC_CALLBACK_2(callback, this);

    （4）将监听器添加到事件分发器dispatcher中：

            dispatcher->addEventListenerWithSceneGraphPriority(Listener, this);

    （5）编写回调响应函数：

            bool callback(Touch* touch, Event* event) { ... }

---

【触摸事件】

1、单点触摸：EventListenerTouchOneByOne

    单点触摸监听器相关：

1 2 3 4 5 6 7 8

//     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; //

    使用举例：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

//     //获取事件分发器     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"); } //

2、多点触摸：EventListenerTouchAllAtOnce

    多点触摸监听器相关：

1 2 3 4 5 6 7 8

//     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; //

    使用举例：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

//     //获取事件分发器     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"); } //

---

【鼠标事件】

    EventListenerMouse，主要用于监听鼠标的点击、松开、移动、滚轮的事件。

    鼠标事件监听器相关：

1 2 3 4 5 6 7 8

//     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;//滚动鼠标, 滚动鼠标的滚轮 //

    使用举例：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

//     //获取事件分发器     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"); } //

---

【键盘事件】

    EventListenerKeyboard，主要用于监听键盘某个键的按下、松开的事件。

    键盘事件监听器相关：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

//     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 //

    使用举例：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

//     //获取事件分发器     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");         }     } //

---

【加速计事件】

    EventListenerAcceleration，主要用于监听移动设备的所受重力方向感应事件。

    重力感应来自移动设备的加速计，通常支持 (X, Y, Z) 三个方向的加速度感应，所以又称为三向加速计。在实际应用中，可以根据3个方向的力度大小来计算手机倾斜的角度或方向。

1、加速计信息类Acceleration

    该类中每个方向的加速度，大小都为一个重力加速度大小。

1 2 3 4 5 6

//加速计信息     class Acceleration     {         double x; double y; double z;     }; //

2、开启加速计感应

    在使用加速计事件监听器之前，需要先启用此硬件设备：

        Device::setAccelerometerEnabled(true);

3、加速计监听器相关

1 2 3 4 5

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

4、使用举例

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

//     //标签: 显示加速计信息     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); //设置位置     } //

5、实际效果

    在电脑上看不出效果，需要移植到手机上，才能看到加速计的效果。

---

【自定义事件】

    以上是系统自带的事件类型，事件由系统内部自动触发，如 触摸屏幕，键盘响应等。

    EventListenerCustom 自定义事件，它不是由系统自动触发，而是人为的干涉。

    它的出现，使得2.x中的 观察者模式 NotificationCenter（订阅发布消息） 被无情的遗弃了。

    在 3.x 中，使用EventListenerCustom来实现消息的订阅与发布。

    学习它之前，最好了解一下 NotificationCenter 这个类的用法。

    NotificationCenter 的用法参见：http://shahdza.blog.51cto.com/2410787/1611575

1、创建自定义监听器

    该监听器，就相当于是订阅消息。即与NotificationCenter的 addObserver 类似。

1 2 3 4 5

//     //eventName : 监听器名字，即消息的名称     //callback  : 监听器函数，即消息的回调函数     static EventListenerCustom* create(const std::string& eventName, const std::function<void(EventCustom*)>& callback); //

2、分发自定义事件

    自定义的事件监听器，需要通过手动的方式，将事件分发出去。

    > 通过 EventCustom(string eventName);       来设置需要发布消息的数据信息，eventName为消息名称。

        其中EventCustom可以通过setUserData来绑定想要传递的消息数据。

    > 通过 dispatcher->dispatchEvent(&event); 来手动将事件分发出去。即发布消息。

        这与NotificationCenter的 postNotification 类似。

1 2 3 4 5

//     EventCustom event("custom_event");     event->setUserData((void*)123); // 绑定消息传递的数据，可以为任意类型void。     dispatcher->dispatchEvent(&event); // 发布名称为"custom_event"的消息。 //

3、使用举例

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

//     //获取事件分发器     auto dispatcher = Director::getInstance()->getEventDispatcher();       //创建自定义事件监听器     //监听器名字  : "custom_event"     //事件响应函数: HelloWorld::onCustomEvent     auto customListener = EventListenerCustom::create("custom_event", CC_CALLBACK_1(HelloWorld::onCustomEvent, this));           //添加自定义事件监听器，优先权为1     dispatcher->addEventListenerWithFixedPriority(customListener, 1);             //手动分发监听器的事件，通过dispatchEvent发布名称为custom_event的消息。     EventCustom event = EventCustom("custom_event");     event->setUserData((void*)123); // 绑定消息传递的数据，可以为任意类型void。     dispatcher->dispatchEvent(&event);                 //消息事件回调函数     void HelloWorld::onCustomEvent(EventCustom* event)     {         // 获取消息传递的数据         int* data = (int*)event->getUserData()         CCLOG("onCustomEvent data = %d", data);     } //

4、说明

    > 每个自定义的事件监听器，都有一个监听器名字eventName。即为订阅的消息名称。

    > 需要通过 dispatcher->dispatchEvent(&event); 来手动将事件分发出去。即为发布消息。

    > 可以通过 dispatcher->dispatchCustomEvent(,); 来给自定义事件监听器绑定一个用户数据。

---

【物理碰撞事件】

    有待研究。。。

1 2 3 4 5 6

//     EventListenerPhysicsContact;     EventListenerPhysicsContactWithBodies;     EventListenerPhysicsContactWithGroup;     EventListenerPhysicsContactWithShapes; //

---

【游戏手柄】

    有待研究。。。

1 2 3

//     EventListenerController; //