// 初始化事件系統(tǒng)
_initEvents: function () {
  var win = window, hiddenPropName;

  //_ register system events
  // 注冊(cè)系統(tǒng)事件，這里調(diào)用了CCInputManager的方法
  if (this.config.registerSystemEvent)
    _cc.inputManager.registerSystemEvent(this.canvas);

  // document.hidden表示頁面隱藏，后面的if用于處理瀏覽器兼容
  if (typeof document.hidden !== 'undefined') {
    hiddenPropName = "hidden";
  } else if (typeof document.mozHidden !== 'undefined') {
    hiddenPropName = "mozHidden";
  } else if (typeof document.msHidden !== 'undefined') {
    hiddenPropName = "msHidden";
  } else if (typeof document.webkitHidden !== 'undefined') {
    hiddenPropName = "webkitHidden";
  }

  // 當(dāng)前頁面是否隱藏
  var hidden = false;

  // 頁面隱藏時(shí)的回調(diào)，并發(fā)射game.EVENT_HIDE事件
  function onHidden () {
    if (!hidden) {
      hidden = true;
      game.emit(game.EVENT_HIDE);
    }
  }
  //_ In order to adapt the most of platforms the onshow API.
  // 為了適配大部分平臺(tái)的onshow API。應(yīng)該是指?jìng)鲄⒌牟糠?..
  // 頁面可視時(shí)的回調(diào)，并發(fā)射game.EVENT_SHOW事件
  function onShown (arg0, arg1, arg2, arg3, arg4) {
    if (hidden) {
      hidden = false;
      game.emit(game.EVENT_SHOW, arg0, arg1, arg2, arg3, arg4);
    }
  }

  // 如果瀏覽器支持隱藏屬性，則注冊(cè)頁面可視狀態(tài)變更事件
  if (hiddenPropName) {
    var changeList = [
      "visibilitychange",
      "mozvisibilitychange",
      "msvisibilitychange",
      "webkitvisibilitychange",
      "qbrowserVisibilityChange"
    ];
    // 循環(huán)注冊(cè)上面的列表里的事件，同樣是是為了兼容
    // 隱藏狀態(tài)變更后，根據(jù)可視狀態(tài)調(diào)用onHidden/onShown回調(diào)函數(shù)
    for (var i = 0; i < changeList.length; i++) {
      document.addEventListener(changeList[i], function (event) {
        var visible = document[hiddenPropName];
        //_ QQ App
        visible = visible || event["hidden"];
        if (visible)
          onHidden();
        else
          onShown();
      });
    }
  }
  // 此處省略部分關(guān)于 頁面可視狀態(tài)改變 的兼容性代碼

  // 注冊(cè)隱藏和顯示事件，暫?；蛑匦麻_始游戲主邏輯。
  this.on(game.EVENT_HIDE, function () {
    game.pause();
  });
  this.on(game.EVENT_SHOW, function () {
    game.resume();
  });
}

// 注冊(cè)系統(tǒng)事件 element是canvas
registerSystemEvent (element) {
  if(this._isRegisterEvent) return;

  // 注冊(cè)過了，直接return
  this._glView = cc.view;
  let selfPointer = this;
  let canvasBoundingRect = this._canvasBoundingRect;

  // 監(jiān)聽resize事件，修改this._canvasBoundingRect
  window.addEventListener('resize', this._updateCanvasBoundingRect.bind(this));

  let prohibition = sys.isMobile;
  let supportMouse = ('mouse' in sys.capabilities);
  // 是否支持觸摸
  let supportTouches = ('touches' in sys.capabilities);
	
  // 省略了鼠標(biāo)事件的注冊(cè)代碼
  
  //_register touch event
  // 注冊(cè)觸摸事件
  if (supportTouches) {
    // 事件map
    let _touchEventsMap = {
      "touchstart": function (touchesToHandle) {
        selfPointer.handleTouchesBegin(touchesToHandle);
        element.focus();
      },
      "touchmove": function (touchesToHandle) {
        selfPointer.handleTouchesMove(touchesToHandle);
      },
      "touchend": function (touchesToHandle) {
        selfPointer.handleTouchesEnd(touchesToHandle);
      },
      "touchcancel": function (touchesToHandle) {
        selfPointer.handleTouchesCancel(touchesToHandle);
      }
    };

    // 遍歷map注冊(cè)事件
    let registerTouchEvent = function (eventName) {
      let handler = _touchEventsMap[eventName];
      // 注冊(cè)事件到canvas上
      element.addEventListener(eventName, (function(event) {
        if (!event.changedTouches) return;
        let body = document.body;

        // 計(jì)算偏移量
        canvasBoundingRect.adjustedLeft = canvasBoundingRect.left - (body.scrollLeft || window.scrollX || 0);
        canvasBoundingRect.adjustedTop = canvasBoundingRect.top - (body.scrollTop || window.scrollY || 0);
        // 從事件中獲得觸摸點(diǎn)，并調(diào)用回調(diào)函數(shù)
        handler(selfPointer.getTouchesByEvent(event, canvasBoundingRect));
        // 停止事件冒泡
        event.stopPropagation();
        event.preventDefault();
      }), false);
    };
    for (let eventName in _touchEventsMap) {
      registerTouchEvent(eventName);
    }
  }

  // 修改屬性表示已完成事件注冊(cè)
  this._isRegisterEvent = true;
}

// 處理touchstart事件
handleTouchesBegin (touches) {
  let selTouch, index, curTouch, touchID,
      handleTouches = [], locTouchIntDict = this._touchesIntegerDict,
      now = sys.now();
  // 遍歷觸摸點(diǎn)
  for (let i = 0, len = touches.length; i < len; i ++) {
    // 當(dāng)前觸摸點(diǎn)
    selTouch = touches[i];
    // 觸摸點(diǎn)id
    touchID = selTouch.getID();
    // 觸摸點(diǎn)在觸摸點(diǎn)列表(this._touches)中的位置
    index = locTouchIntDict[touchID];

    // 如果沒有獲得index，說明是個(gè)新的觸摸點(diǎn)(剛按下去)
    if (index == null) {
      // 獲得一個(gè)沒有被使用的index
      let unusedIndex = this._getUnUsedIndex();
      // 取不到，拋出錯(cuò)誤?？赡苁浅隽酥С值淖畲笥|摸點(diǎn)數(shù)量。
      if (unusedIndex === -1) {
        cc.logID(2300, unusedIndex);
        continue;
      }
      //_curTouch = this._touches[unusedIndex] = selTouch;
      // 存儲(chǔ)觸摸點(diǎn)
      curTouch = this._touches[unusedIndex] = new cc.Touch(selTouch._point.x, selTouch._point.y, selTouch.getID());
      curTouch._lastModified = now;
      curTouch._setPrevPoint(selTouch._prevPoint);
      locTouchIntDict[touchID] = unusedIndex;
      // 加到需要處理的觸摸點(diǎn)列表中
      handleTouches.push(curTouch);
    }
  }
  // 如果有新觸點(diǎn)，生成一個(gè)觸摸事件，分發(fā)到eventManager
  if (handleTouches.length > 0) {
    // 這個(gè)方法會(huì)把觸摸點(diǎn)的位置根據(jù)scale做處理
    this._glView._convertTouchesWithScale(handleTouches);
    let touchEvent = new cc.Event.EventTouch(handleTouches);
    touchEvent._eventCode = cc.Event.EventTouch.BEGAN;
    eventManager.dispatchEvent(touchEvent);
  }
},

// 分發(fā)事件
_dispatchTouchEvent: function (event) {
  // 為觸摸監(jiān)聽器排序
  // TOUCH_ONE_BY_ONE：觸摸事件監(jiān)聽器類型，觸點(diǎn)會(huì)一個(gè)一個(gè)地分開被派發(fā)
  // TOUCH_ALL_AT_ONCE：觸點(diǎn)會(huì)被一次性全部派發(fā)
  this._sortEventListeners(ListenerID.TOUCH_ONE_BY_ONE);
  this._sortEventListeners(ListenerID.TOUCH_ALL_AT_ONCE);

  // 獲得監(jiān)聽器列表
  var oneByOneListeners = this._getListeners(ListenerID.TOUCH_ONE_BY_ONE);
  var allAtOnceListeners = this._getListeners(ListenerID.TOUCH_ALL_AT_ONCE);

  //_ If there aren't any touch listeners, return directly.
  // 如果沒有任何監(jiān)聽器，直接return。
  if (null === oneByOneListeners && null === allAtOnceListeners)
    return;

  // 存儲(chǔ)一下變量
  var originalTouches = event.getTouches(), mutableTouches = cc.js.array.copy(originalTouches);
  var oneByOneArgsObj = {event: event, needsMutableSet: (oneByOneListeners && allAtOnceListeners), touches: mutableTouches, selTouch: null};

  //
  //_ process the target handlers 1st
  //  不會(huì)翻。感覺是首先處理單個(gè)觸點(diǎn)的事件。
  if (oneByOneListeners) {
    // 遍歷觸點(diǎn)，依次分發(fā)
    for (var i = 0; i < originalTouches.length; i++) {
      event.currentTouch = originalTouches[i];
      event._propagationStopped = event._propagationImmediateStopped = false;
      this._dispatchEventToListeners(oneByOneListeners, this._onTouchEventCallback, oneByOneArgsObj);
    }
  }

  //
  //_ process standard handlers 2nd
  //  不會(huì)翻。感覺是其次處理多觸點(diǎn)事件(一次性全部派發(fā))
  if (allAtOnceListeners && mutableTouches.length > 0) {
    this._dispatchEventToListeners(allAtOnceListeners, this._onTouchesEventCallback, {event: event, touches: mutableTouches});
    if (event.isStopped())
      return;
  }
  // 更新觸摸監(jiān)聽器列表，主要是移除和新增監(jiān)聽器
  this._updateTouchListeners(event);
},

/**
* 分發(fā)事件到監(jiān)聽器列表
* @param {*} listeners     監(jiān)聽器列表
* @param {*} onEvent       事件回調(diào)
* @param {*} eventOrArgs   事件/參數(shù)
*/
_dispatchEventToListeners: function (listeners, onEvent, eventOrArgs) {
  // 是否需要停止繼續(xù)分發(fā)
  var shouldStopPropagation = false;
  // 獲得固定優(yōu)先級(jí)的監(jiān)聽器（系統(tǒng)事件）
  var fixedPriorityListeners = listeners.getFixedPriorityListeners();
  // 獲得場(chǎng)景圖優(yōu)先級(jí)別的監(jiān)聽器（我們添加的監(jiān)聽器正常都是在這里）
  var sceneGraphPriorityListeners = listeners.getSceneGraphPriorityListeners();

  /**
  * 監(jiān)聽器觸發(fā)順序：
  *      固定優(yōu)先級(jí)中優(yōu)先級(jí) < 0
  *      場(chǎng)景圖優(yōu)先級(jí)別
  *      固定優(yōu)先級(jí)中優(yōu)先級(jí) > 0
  */
  var i = 0, j, selListener;
  if (fixedPriorityListeners) {  //_ priority < 0
    if (fixedPriorityListeners.length !== 0) {
      // 遍歷監(jiān)聽器分發(fā)事件
      for (; i < listeners.gt0Index; ++i) {
        selListener = fixedPriorityListeners[i];
        // 若 監(jiān)聽器激活狀態(tài) 且 沒有被暫停 且 已被注冊(cè)到事件管理器
        // 最后一個(gè)onEvent是使用_onTouchEventCallback函數(shù)分發(fā)事件到監(jiān)聽器
        // onEvent會(huì)返回一個(gè)boolean，表示是否需要繼續(xù)向后續(xù)的監(jiān)聽器分發(fā)事件，若true，停止繼續(xù)分發(fā)
        if (selListener.isEnabled() && !selListener._isPaused() && selListener._isRegistered() && onEvent(selListener, eventOrArgs)) {
          shouldStopPropagation = true;
          break;
        }
      }
    }
  }
  // 省略另外兩個(gè)優(yōu)先級(jí)的觸發(fā)代碼
},

// 觸摸事件回調(diào)。分發(fā)事件到監(jiān)聽器
_onTouchEventCallback: function (listener, argsObj) {
  //_ Skip if the listener was removed.
  // 若 監(jiān)聽器已被移除，跳過。
  if (!listener._isRegistered())
    return false;

  var event = argsObj.event, selTouch = event.currentTouch;
  event.currentTarget = listener._node;

  // isClaimed：監(jiān)聽器是否認(rèn)領(lǐng)事件
  var isClaimed = false, removedIdx;
  var getCode = event.getEventCode(), EventTouch = cc.Event.EventTouch;
  // 若 事件為觸摸開始事件
  if (getCode === EventTouch.BEGAN) {
    // 若 不支持多點(diǎn)觸摸 且 當(dāng)前已經(jīng)有一個(gè)觸點(diǎn)了
    if (!cc.macro.ENABLE_MULTI_TOUCH && eventManager._currentTouch) {
      // 若 該觸點(diǎn)已被節(jié)點(diǎn)認(rèn)領(lǐng) 且 該節(jié)點(diǎn)在節(jié)點(diǎn)樹中是激活的，則不處理事件
      let node = eventManager._currentTouchListener._node;
      if (node && node.activeInHierarchy) {
        return false;
      }
    }

    // 若 監(jiān)聽器有對(duì)應(yīng)事件
    if (listener.onTouchBegan) {
      // 嘗試分發(fā)給監(jiān)聽器，會(huì)返回一個(gè)boolean，表示監(jiān)聽器是否認(rèn)領(lǐng)該事件
      isClaimed = listener.onTouchBegan(selTouch, event);
      // 若 事件被認(rèn)領(lǐng) 且 監(jiān)聽器是已被注冊(cè)的，保存一些數(shù)據(jù)
      if (isClaimed && listener._registered) {
        listener._claimedTouches.push(selTouch);
        eventManager._currentTouchListener = listener;
        eventManager._currentTouch = selTouch;
      }
    }
  } 
  // 若 監(jiān)聽器已有認(rèn)領(lǐng)的觸點(diǎn) 且 當(dāng)前觸點(diǎn)正是被當(dāng)前監(jiān)聽器認(rèn)領(lǐng)
  else if (listener._claimedTouches.length > 0
           && ((removedIdx = listener._claimedTouches.indexOf(selTouch)) !== -1)) {
    // 直接領(lǐng)回家
    isClaimed = true;

    // 若 不支持多點(diǎn)觸摸 且 已有觸點(diǎn) 且 已有觸點(diǎn)還不是當(dāng)前觸點(diǎn)，不處理事件
    if (!cc.macro.ENABLE_MULTI_TOUCH && eventManager._currentTouch && eventManager._currentTouch !== selTouch) {
      return false;
    }

    // 分發(fā)事件給監(jiān)聽器
    // ENDED或CANCELED的時(shí)候，需要清理監(jiān)聽器和事件管理器中的觸點(diǎn)
    if (getCode === EventTouch.MOVED && listener.onTouchMoved) {
      listener.onTouchMoved(selTouch, event);
    } else if (getCode === EventTouch.ENDED) {
      if (listener.onTouchEnded)
        listener.onTouchEnded(selTouch, event);
      if (listener._registered)
        listener._claimedTouches.splice(removedIdx, 1);
      eventManager._clearCurTouch();
    } else if (getCode === EventTouch.CANCELED) {
      if (listener.onTouchCancelled)
        listener.onTouchCancelled(selTouch, event);
      if (listener._registered)
        listener._claimedTouches.splice(removedIdx, 1);
      eventManager._clearCurTouch();
    }
  }

  //_ If the event was stopped, return directly.
  // 若事件已經(jīng)被停止傳遞，直接return（對(duì)事件調(diào)用stopPropagationImmediate()等情況）
  if (event.isStopped()) {
    eventManager._updateTouchListeners(event);
    return true;
  }

  // 若 事件被認(rèn)領(lǐng) 且 監(jiān)聽器把事件吃掉了(x)（指不需要再繼續(xù)傳遞，默認(rèn)為false，但在Node的touch系列事件中為true）
  if (isClaimed && listener.swallowTouches) {
    if (argsObj.needsMutableSet)
      argsObj.touches.splice(selTouch, 1);
    return true;
  }
  return false;
},

/**
* 在節(jié)點(diǎn)上注冊(cè)指定類型的回調(diào)函數(shù)
* @param {*} type          事件類型
* @param {*} callback      回調(diào)函數(shù)
* @param {*} target        目標(biāo)(用于綁定this)
* @param {*} useCapture    注冊(cè)在捕獲階段
*/
on (type, callback, target, useCapture) {
  // 是否是系統(tǒng)事件（鼠標(biāo)、觸摸）
  let forDispatch = this._checknSetupSysEvent(type);
  if (forDispatch) {
    // 注冊(cè)事件
    return this._onDispatch(type, callback, target, useCapture);
  }
  // 省略掉非系統(tǒng)事件的部分，其中包括了位置改變、尺寸改變等。
},

// 注冊(cè)分發(fā)事件
_onDispatch (type, callback, target, useCapture) {
  //_ Accept also patameters like: (type, callback, useCapture)
  // 也可以接收這樣的參數(shù)：(type, callback, useCapture)
  // 參數(shù)兼容性處理
  if (typeof target === 'boolean') {
    useCapture = target;
    target = undefined;
  }
  else useCapture = !!useCapture;
  // 若 沒有回調(diào)函數(shù)，報(bào)錯(cuò)，return。
  if (!callback) {
    cc.errorID(6800);
    return;
  }

  // 根據(jù)useCapture獲得不同的監(jiān)聽器。
  var listeners = null;
  if (useCapture) {
    listeners = this._capturingListeners = this._capturingListeners || new EventTarget();
  }
  else {
    listeners = this._bubblingListeners = this._bubblingListeners || new EventTarget();
  }

  // 若 已注冊(cè)了相同的回調(diào)事件，則不做處理
  if ( !listeners.hasEventListener(type, callback, target) ) {
    // 注冊(cè)事件到監(jiān)聽器
    listeners.on(type, callback, target);

    // 保存this到target的__eventTargets數(shù)組里，用于從target中調(diào)用targetOff函數(shù)來清除監(jiān)聽器。
    if (target && target.__eventTargets) {
      target.__eventTargets.push(this);
    }
  }

  return callback;
},

//_注冊(cè)事件目標(biāo)的特定事件類型回調(diào)。這種類型的事件應(yīng)該被 `emit` 觸發(fā)。
proto.on = function (type, callback, target, once) {
    // 若 沒有傳遞回調(diào)函數(shù)，報(bào)錯(cuò)，return
    if (!callback) {
        cc.errorID(6800);
        return;
    }

    // 若 已存在該回調(diào)，不處理
    if ( !this.hasEventListener(type, callback, target) ) {
        // 注冊(cè)事件
        this.__on(type, callback, target, once);

        if (target && target.__eventTargets) {
            target.__eventTargets.push(this);
        }
    }
    return callback;
};

//_ 事件添加管理
proto.on = function (key, callback, target, once) {
    // 獲得事件對(duì)應(yīng)的回調(diào)列表
    let list = this._callbackTable[key];
    // 若 不存在，到池子里取一個(gè)
    if (!list) {
        list = this._callbackTable[key] = callbackListPool.get();
    }
    // 把回調(diào)相關(guān)信息存起來
    let info = callbackInfoPool.get();
    info.set(callback, target, once);
    list.callbackInfos.push(info);
};

// 檢查是否是系統(tǒng)事件
_checknSetupSysEvent (type) {
  // 是否需要新增監(jiān)聽器
  let newAdded = false;
  // 是否需要分發(fā)（系統(tǒng)事件需要）
  let forDispatch = false;
  // 若 事件是觸摸事件
  if (_touchEvents.indexOf(type) !== -1) {
    // 若 當(dāng)前沒有觸摸事件監(jiān)聽器 新建一個(gè)
    if (!this._touchListener) {
      this._touchListener = cc.EventListener.create({
        event: cc.EventListener.TOUCH_ONE_BY_ONE,
        swallowTouches: true,
        owner: this,
        mask: _searchComponentsInParent(this, cc.Mask),
        onTouchBegan: _touchStartHandler,
        onTouchMoved: _touchMoveHandler,
        onTouchEnded: _touchEndHandler,
        onTouchCancelled: _touchCancelHandler
      });
      // 將監(jiān)聽器添加到eventManager
      eventManager.addListener(this._touchListener, this);
      newAdded = true;
    }
    forDispatch = true;
  }
  // 省略事件是鼠標(biāo)事件的代碼，和觸摸事件差不多
  
  // 若 新增了監(jiān)聽器 且 當(dāng)前節(jié)點(diǎn)不是活躍狀態(tài)
  if (newAdded && !this._activeInHierarchy) {
    // 稍后一小會(huì)，若節(jié)點(diǎn)仍不是活躍狀態(tài)，暫停節(jié)點(diǎn)的事件傳遞，
    cc.director.getScheduler().schedule(function () {
      if (!this._activeInHierarchy) {
        eventManager.pauseTarget(this);
      }
    }, this, 0, 0, 0, false);
  }
  return forDispatch;
},

// 觸摸開始事件處理器
var _touchStartHandler = function (touch, event) {
    var pos = touch.getLocation();
    var node = this.owner;

    // 若 觸點(diǎn)在節(jié)點(diǎn)范圍內(nèi)，則觸發(fā)事件，并返回true，表示這事件我領(lǐng)走啦！
    if (node._hitTest(pos, this)) {
        event.type = EventType.TOUCH_START;
        event.touch = touch;
        event.bubbles = true;
        // 分發(fā)到本節(jié)點(diǎn)內(nèi)
        node.dispatchEvent(event);
        return true;
    }
    return false;
};

//_ 分發(fā)事件到事件流中。
dispatchEvent (event) {
  _doDispatchEvent(this, event);
  _cachedArray.length = 0;
},
// 分發(fā)事件
function _doDispatchEvent (owner, event) {
    var target, i;
    event.target = owner;

    //_ Event.CAPTURING_PHASE
    // 捕獲階段
    _cachedArray.length = 0;
    // 獲得捕獲階段的節(jié)點(diǎn)，儲(chǔ)存在_cachedArray
    owner._getCapturingTargets(event.type, _cachedArray);
    //_ capturing
    event.eventPhase = 1;
    // 從尾到頭遍歷(即從根節(jié)點(diǎn)到目標(biāo)節(jié)點(diǎn)的父節(jié)點(diǎn))
    for (i = _cachedArray.length - 1; i >= 0; --i) {
        target = _cachedArray[i];
        // 若 目標(biāo)節(jié)點(diǎn)注冊(cè)了捕獲階段的監(jiān)聽器
        if (target._capturingListeners) {
            event.currentTarget = target;
            //_ fire event
            // 在目標(biāo)節(jié)點(diǎn)上處理事件
            target._capturingListeners.emit(event.type, event, _cachedArray);
            //_ check if propagation stopped
            // 若 事件已經(jīng)停止傳遞了，return
            if (event._propagationStopped) {
                _cachedArray.length = 0;
                return;
            }
        }
    }
    // 清空_cachedArray
    _cachedArray.length = 0;

    //_ Event.AT_TARGET
    //_ checks if destroyed in capturing callbacks
    // 目標(biāo)節(jié)點(diǎn)本身階段
    event.eventPhase = 2;
    event.currentTarget = owner;
    // 若 自身注冊(cè)了捕獲階段的監(jiān)聽器，則處理事件
    if (owner._capturingListeners) {
        owner._capturingListeners.emit(event.type, event);
    }
    // 若 事件沒有被停止 且 自身注冊(cè)了冒泡階段的監(jiān)聽器，則處理事件
    if (!event._propagationImmediateStopped && owner._bubblingListeners) {
        owner._bubblingListeners.emit(event.type, event);
    }

    // 若 事件沒有被停止 且 事件需要冒泡處理(默認(rèn)true)
    if (!event._propagationStopped && event.bubbles) {
        //_ Event.BUBBLING_PHASE
        // 冒泡階段
        // 獲得冒泡階段的節(jié)點(diǎn)
        owner._getBubblingTargets(event.type, _cachedArray);
        //_ propagate
        event.eventPhase = 3;
        // 從頭到尾遍歷(實(shí)現(xiàn)從父節(jié)點(diǎn)到根節(jié)點(diǎn))，觸發(fā)邏輯和捕獲階段一致
        for (i = 0; i < _cachedArray.length; ++i) {
            target = _cachedArray[i];
            if (target._bubblingListeners) {
                event.currentTarget = target;
                //_ fire event
                target._bubblingListeners.emit(event.type, event);
                //_ check if propagation stopped
                if (event._propagationStopped) {
                    _cachedArray.length = 0;
                    return;
                }
            }
        }
    }
    // 清空_cachedArray
    _cachedArray.length = 0;
}

_getCapturingTargets (type, array) {
  // 從父節(jié)點(diǎn)開始
  var parent = this.parent;
  // 若 父節(jié)點(diǎn)不為空(根節(jié)點(diǎn)的父節(jié)點(diǎn)為空)
  while (parent) {
    // 若 節(jié)點(diǎn)有捕獲階段的監(jiān)聽器 且 有對(duì)應(yīng)類型的監(jiān)聽事件，則把節(jié)點(diǎn)加到array數(shù)組中
    if (parent._capturingListeners && parent._capturingListeners.hasEventListener(type)) {
      array.push(parent);
    }
    // 設(shè)置節(jié)點(diǎn)為其父節(jié)點(diǎn)
    parent = parent.parent;
  }
},

proto.emit = function (key, arg1, arg2, arg3, arg4, arg5) {
    // 獲得事件列表
    const list = this._callbackTable[key];
    // 若 事件列表存在
    if (list) {
        // list.isInvoking 事件是否正在觸發(fā)
        const rootInvoker = !list.isInvoking;
        list.isInvoking = true;

        // 獲得回調(diào)列表，遍歷
        const infos = list.callbackInfos;
        for (let i = 0, len = infos.length; i < len; ++i) {
            const info = infos[i];
            if (info) {
                let target = info.target;
                let callback = info.callback;
                // 若 回調(diào)函數(shù)是用once注冊(cè)的，那先把這個(gè)函數(shù)取消掉
                if (info.once) {
                    this.off(key, callback, target);
                }

                // 若 傳遞了target，則使用call保證this的指向是正確的
                if (target) {
                    callback.call(target, arg1, arg2, arg3, arg4, arg5);
                }
                else {
                    callback(arg1, arg2, arg3, arg4, arg5);
                }
            }
        }
        // 若 當(dāng)前事件沒有在被觸發(fā)
        if (rootInvoker) {
            list.isInvoking = false;
            // 若 含有被取消的回調(diào)，則調(diào)用purgeCanceled函數(shù)，過濾已被移除的回調(diào)并壓縮數(shù)組
            if (list.containCanceled) {
                list.purgeCanceled();
            }
        }
    }
};

// 場(chǎng)景圖級(jí)優(yōu)先級(jí)監(jiān)聽器的排序算法
// 返回-1(負(fù)數(shù))表示l1優(yōu)先于l2，返回正數(shù)則相反，0表示相等
_sortEventListenersOfSceneGraphPriorityDes: function (l1, l2) {
  // 獲得監(jiān)聽器所在的節(jié)點(diǎn)
  let node1 = l1._getSceneGraphPriority(),
      node2 = l2._getSceneGraphPriority();

  // 若 監(jiān)聽器2為空 或 節(jié)點(diǎn)2為空 或 節(jié)點(diǎn)2不是活躍狀態(tài) 或 節(jié)點(diǎn)2是根節(jié)點(diǎn) 則l1優(yōu)先
  if (!l2 || !node2 || !node2._activeInHierarchy || node2._parent === null)
    return -1;
  // 和上面的一樣
  else if (!l1 || !node1 || !node1._activeInHierarchy || node1._parent === null)
    return 1;

  // 使用p1 p2暫存節(jié)點(diǎn)1 節(jié)點(diǎn)2
  // ex：我推測(cè)是 是否發(fā)生交換的意思(exchange)
  let p1 = node1, p2 = node2, ex = false;
  // 若 p1 p2的父節(jié)不相等 則向上朔源
  while (p1._parent._id !== p2._parent._id) {
    // 若 p1的爺爺節(jié)點(diǎn)是空(p1的父節(jié)點(diǎn)是根節(jié)點(diǎn)) 則ex置為true，p1指向節(jié)點(diǎn)2。否則p1指向其父節(jié)點(diǎn)
    p1 = p1._parent._parent === null ? (ex = true) && node2 : p1._parent;
    p2 = p2._parent._parent === null ? (ex = true) && node1 : p2._parent;
  }

  // 若 p1和p2指向同一個(gè)節(jié)點(diǎn)，即節(jié)點(diǎn)1、2存在某種父子關(guān)系，即情況3
  if (p1._id === p2._id) {
    // 若 p1指向節(jié)點(diǎn)2 則l1優(yōu)先。反之l2優(yōu)先
    if (p1._id === node2._id) 
      return -1;
    if (p1._id === node1._id)
      return 1;
  }

  // 注：此時(shí)p1 p2的父節(jié)點(diǎn)相同
  // 若ex為true 則節(jié)點(diǎn)1、2沒有父子關(guān)系，即情況2
  // 若ex為false 則節(jié)點(diǎn)1、2父節(jié)點(diǎn)相同，即情況1
  return ex ? p1._localZOrder - p2._localZOrder : p2._localZOrder - p1._localZOrder;
},