您的位置:68399皇家赌场 > 服务器租用 > 【www.68399.com】cc.Node.坐标空间

【www.68399.com】cc.Node.坐标空间

发布时间:2019-06-07 19:55编辑:服务器租用浏览(65)

    cc.Class({
     extends: cc.Component,
    
     properties: {
      // foo: {
      // default: null,  // The default value will be used only when the component attaching
      //       to a node for the first time
      // url: cc.Texture2D, // optional, default is typeof default
      // serializable: true, // optional, default is true
      // visible: true,  // optional, default is true
      // displayName: 'Foo', // optional
      // readonly: false, // optional, default is false
      // },
      // ...
       poker:{
        default:null,
        type:cc.Node
       },
       cardMask:{
        default:null,
        type: cc.Prefab
       }
     },
    
     // use this for initialization
     onLoad: function () {
    
       //牌
       this.cards = this.poker.children;
    
       //牌初始位置
       this.cardInitY = this.cards[0].y;
    
       //触摸选择到的牌
       this.touchedCards = [];
    
       //选中的牌
       this.selectedCards = [];
    
       console.info(this.cards);
      },
    
      start: function () {
       // this.cards = this.poker.children;
       // console.info(this.cards);
    
       this.addTouchEvent();
      },
    
      /**
       * 添加事件
       */
      addTouchEvent:function(){
    
       //父节点监听touch事件(直接子节点必须注册同样的事件方能触发)
       this.poker.on(cc.Node.EventType.TOUCH_START, function (event) {
        console.log('poker TOUCH_START');
    
        //牌
        var card = event.target;
    
        //起始触摸位置(和第一张card一样,相对于poker的位置)
        this.touchStartLocation = this.cards[0].convertTouchToNodeSpace(event);
        console.log('touch start Location:'  JSON.stringify(this.touchStartLocation));
    
        //计算牌位置
        var index = 0;
        for(var i=0;i<this.cards.length;i  ){
         var c = this.cards[i];
         if(c.name == card.name){
          index = i;
          break;
         }
        }
    
        //暂存第一次触摸到的牌
        var touchedCard = {
         index:index,
         card:card
        };
        this.firstTouchedCard = touchedCard;
        //暂存
        this.pushTouchedCards(touchedCard.index,touchedCard.card);
    
       }, this);
    
       //父节点监听touch事件(直接子节点必须注册同样的事件方能触发)
       this.poker.on(cc.Node.EventType.TOUCH_MOVE, function (event) {
        console.log('poker TOUCH_MOVE');
        //先清除原先触摸到的牌
        this.clearTouchedCards();
        //保存第一张牌
        this.pushTouchedCards(this.firstTouchedCard.index,this.firstTouchedCard.card);
    
        //触摸点转换为card节点坐标
        var nodeLocation = this.cards[0].convertTouchToNodeSpace(event);
        console.log('touch nodeLocation:'  JSON.stringify(nodeLocation));
        var x = nodeLocation.x;
        var y = nodeLocation.y; 
    
        //找到当前选中的牌
        var currentCard = null;
        for(var i=0;i< this.cards.length;i  ){
         var card = this.cards[i];
         var cardX = card.x;
         var cardY = card.y;
         console.log('card x=' cardX ',y=' cardY);
    
    
         //某张牌范围包括了鼠标位置,选中此牌与触摸开头的所有牌
         var cardWidth = i==5 ? card.width:19;
         var cardHeight = card.height;
         if(cardX<=x && x <= cardX cardWidth && cardY<=y && y<= cardY cardHeight){
          currentCard = card;
    
          //暂存触摸到的牌
          this.pushTouchedCards(i,card);
    
          break;
         }
        }
    
        //添加开头与此牌直接的所有牌
        var startTouchLocation = this.touchStartLocation;
        for(var i=0;i< this.cards.length;i  ){
         var card = this.cards[i];
         var cardX = card.x;
         //框选的范围包括了的牌
         var min,max;
         if(startTouchLocation.x < nodeLocation.x){
          min = startTouchLocation.x;
          max = nodeLocation.x;
         }else{
          min = nodeLocation.x;
          max = startTouchLocation.x;
         }
         console.log('min=' min ', max=' max);
    
         if(min <= cardX && cardX <= max){
          //暂存触摸到的牌
          this.pushTouchedCards(i,card);
         }
        }
    
    
       }, this);
    
      //父节点监听touch事件(直接子节点必须注册同样的事件方能触发)
      this.poker.on(cc.Node.EventType.TOUCH_END, function (event) {
       console.log('poker TOUCH_END');
       this.doSelectCard();
      }, this);
    
      //父节点监听touch事件(直接子节点必须注册同样的事件方能触发)
      this.poker.on(cc.Node.EventType.TOUCH_CANCEL, function (event) {
       console.log('poker TOUCH_CANCEL');
       this.doSelectCard();
      }, this);
    
      //给所有的牌注册事件,会自动冒泡到poker节点
      for(var i=0;i< this.cards.length;i  ){
       var cards = this.cards;
       //闭包传递i值
       (function(i){
        var card = cards[i];
        card.on(cc.Node.EventType.TOUCH_START, function (event) {
         console.log('card TOUCH_START');
        }, card);
    
        card.on(cc.Node.EventType.TOUCH_MOVE, function (event) {
         console.log('card TOUCH_MOVE');
        }, card);
    
        card.on(cc.Node.EventType.TOUCH_END, function (event) {
         console.log('card TOUCH_END');
        }, card);
    
        card.on(cc.Node.EventType.TOUCH_CANCEL, function (event) {
         console.log('card TOUCH_CANCEL');
        }, card);
    
    
       })(i)
    
      }
    
     },
    
     /**
      * 暂存触摸到的牌
      */
     pushTouchedCards:function(index,card){
      //构造牌对象
      var cardObj = {
       index:index,
       name:card.name,
       isSelected:card.y==this.cardInitY?false:true //高度不一样,表示选中
      };
    
      //防止重复添加
      var existCard = this.touchedCards.find(function(obj){
       if(obj.name == card.name){
        return obj;
       }else{
        return null;
       }
      });
      if(!existCard){
       //添加暂存
       this.touchedCards.push(cardObj);
    
       //包含提示
       this.addCardMask(card);
      }
     },
    
     /**
      * 清除原先暂存的触摸到的牌
      */
     clearTouchedCards:function(){
      for(var i=0;i<this.touchedCards.length;i  ){
       var cardIndex = this.touchedCards[i].index;
       var card = this.cards[cardIndex];
       card.removeChild(card.children[0]);
      }
      this.touchedCards = [];
     },
    
     /**
      * 选择牌
      */
     doSelectCard:function(){
      this.selectedCards = [];
    
      console.log(this.touchedCards);
    
      //改变牌状态
      for(var i = 0; i< this.touchedCards.length;i  ){
       var cardObj = this.touchedCards[i];
       var card = this.cards[cardObj.index];
       if(cardObj.isSelected){ //如果是选中改为不选中
        card.y = card.y - 30;
       }else{ //不选中改为选中状态
        card.y = card.y   30;
       }
      }
    
      //重置
      this.clearTouchedCards();
    
      //显示选中的牌
      this.showSelectedCards();
     },
    
     /**
      * 包含牌遮罩
      */
     addCardMask:function(card){
      var cardMask = cc.instantiate(this.cardMask);
      cardMask.setPosition(cc.p(0, 0));
      card.addChild(cardMask);
      },
    
     /**
     * 显示选中的牌
     */
     showSelectedCards:function(){
      this.selectedCards = [];
      for(var i=0;i< this.cards.length;i  ){
       var card = this.cards[i];
       var isSelected = card.y==this.cardInitY?false:true;
       if(isSelected){
        this.selectedCards.push(card.name);
       }
      }
      //输出
      console.info("selected cards is: "  JSON.stringify(this.selectedCards));
     },
    
    
     // called every frame, uncomment this function to activate update callback
     // update: function (dt) {
    
     // },
    });
    

     

    1.触控事件是对准节点的

    总括下: 平日情状下,使用带A途胜的,因为creator里面

    3.父节点不响应触控事件,肯定是被儿女节点遮挡了,只要孩子节点也监听一下事件,父节点就能够响应了

    原理

    伍.触控地方是纯属坐标,相对于一体canvas,节点地方相对于父节点,相对地点能够与相对坐标相互转化

    只是她的x,y是以此减去高或宽/贰,因为他的原点也是锚点.

    二.触控事件的冒泡,是一向关联冒泡,老爹和儿子能够,外孙子不行,就是无法隔代冒泡

     

    肆.触控事件往祖先节点冒泡,祖先节点是或不是会检查测试触点是或不是在投机区域内,由子节点是不是监听了touch事件有关。子监听了,父就不会检查测试区域是不是包罗触点,始终响应触控事件,未有监听,则会检验是还是不是含有触点,包括才会响应触控事件!(那点与官方网站文书档案不一样等,我亲测出来的结果)

    new cc.Size(w,h)和cc.size(w,h)来创制大小对象.

    6.剖断是或不是框选中,依照坐标计算彼此交叉正是选中。就是说作者从触控源点->触控终点 构成的矩形区域,与节点的矩形存在重叠,正是被框选。本例中,选拔相比较简略的算法完结,根据横坐标的限定是不是含有子节点的横坐标判定是还是不是选中。

    陆.节点是或不是被触控到,touch start事件可以一定被触动到,可是3个节点触摸到必须等待其得了,另贰个节点技能响应touch事件

    www.68399.com 1

    八大家前日要把3个子节点的位置移动到相对与阿爹的地点.

    5.节点是或不是被触控到,touch start事件能够毫无疑问被触动到,可是贰个节点触摸到必须等待其得了,另二个节点才具响应touch事件

    效果

    主干代码

            box = this.node.getBoundingBoxToWorld();
            console.log(box);
    

    一.触控事件是指向节点的

    cc.Class({
        extends: cc.Component,
    
        properties: {
            // foo: {
            //    default: null,      // The default value will be used only when the component attaching
            //                           to a node for the first time
            //    url: cc.Texture2D,  // optional, default is typeof default
            //    serializable: true, // optional, default is true
            //    visible: true,      // optional, default is true
            //    displayName: 'Foo', // optional
            //    readonly: false,    // optional, default is false
            // },
            // ...
                poker:{
                    default:null,
                    type:cc.Node
                },
                cardMask:{
                    default:null,
                    type: cc.Prefab
                }
        },
    
        // use this for initialization
        onLoad: function () {
    
                //牌
                this.cards = this.poker.children;
    
                //牌初始位置
                this.cardInitY = this.cards[0].y;
    
                //触摸选择到的牌
                this.touchedCards = [];
    
                //选中的牌
                this.selectedCards = [];
    
                console.info(this.cards);
            },
    
            start: function () {
                // this.cards = this.poker.children;
                // console.info(this.cards);
    
                this.addTouchEvent();
            },
    
            /**
             * 添加事件
             */
            addTouchEvent:function(){
    
                //父节点监听touch事件(直接子节点必须注册同样的事件方能触发)
                this.poker.on(cc.Node.EventType.TOUCH_START, function (event) {
                    console.log('poker TOUCH_START');
    
                    //牌
                    var card = event.target;
    
                    //起始触摸位置(和第一张card一样,相对于poker的位置)
                    this.touchStartLocation = this.cards[0].convertTouchToNodeSpace(event);
                    console.log('touch start Location:'  JSON.stringify(this.touchStartLocation));
    
                    //计算牌位置
                    var index = 0;
                    for(var i=0;i<this.cards.length;i  ){
                        var c = this.cards[i];
                      if(c.name == card.name){
                            index = i;
                            break;
                        }
                    }
    
                    //暂存第一次触摸到的牌
                    var touchedCard = {
                        index:index,
                        card:card
                    };
                    this.firstTouchedCard = touchedCard;
                    //暂存
                    this.pushTouchedCards(touchedCard.index,touchedCard.card);
    
                }, this);
    
                //父节点监听touch事件(直接子节点必须注册同样的事件方能触发)
                this.poker.on(cc.Node.EventType.TOUCH_MOVE, function (event) {
                    console.log('poker TOUCH_MOVE');
                    //先清除原先触摸到的牌
                    this.clearTouchedCards();
                    //保存第一张牌
                    this.pushTouchedCards(this.firstTouchedCard.index,this.firstTouchedCard.card);
    
                    //触摸点转换为card节点坐标
                    var nodeLocation = this.cards[0].convertTouchToNodeSpace(event);
                    console.log('touch nodeLocation:'  JSON.stringify(nodeLocation));
                    var x = nodeLocation.x;
                    var y = nodeLocation.y; 
    
                    //找到当前选中的牌
                    var currentCard = null;
                    for(var i=0;i< this.cards.length;i  ){
                        var card = this.cards[i];
                        var cardX = card.x;
                        var cardY = card.y;
                        console.log('card x=' cardX ',y=' cardY);
    
    
                        //某张牌范围包括了鼠标位置,选中此牌与触摸开头的所有牌
                        var cardWidth = i==5 ? card.width:19;
                        var cardHeight = card.height;
                        if(cardX<=x && x <= cardX cardWidth && cardY<=y && y<= cardY cardHeight){
                            currentCard = card;
    
                            //暂存触摸到的牌
                            this.pushTouchedCards(i,card);
    
                            break;
                        }
                    }
    
                    //添加开头与此牌直接的所有牌
                    var startTouchLocation = this.touchStartLocation;
                    for(var i=0;i< this.cards.length;i  ){
                        var card = this.cards[i];
                        var cardX = card.x;
                        //框选的范围包括了的牌
                        var min,max;
                        if(startTouchLocation.x < nodeLocation.x){
                            min = startTouchLocation.x;
                            max = nodeLocation.x;
                        }else{
                            min = nodeLocation.x;
                            max = startTouchLocation.x;
                        }
                        console.log('min=' min ', max=' max);
    
                        if(min <= cardX && cardX <= max){
                            //暂存触摸到的牌
                            this.pushTouchedCards(i,card);
                        }
                    }
    
    
                }, this);
    
            //父节点监听touch事件(直接子节点必须注册同样的事件方能触发)
            this.poker.on(cc.Node.EventType.TOUCH_END, function (event) {
                console.log('poker TOUCH_END');
                this.doSelectCard();
            }, this);
    
            //父节点监听touch事件(直接子节点必须注册同样的事件方能触发)
            this.poker.on(cc.Node.EventType.TOUCH_CANCEL, function (event) {
                console.log('poker TOUCH_CANCEL');
                this.doSelectCard();
            }, this);
    
            //给所有的牌注册事件,会自动冒泡到poker节点
            for(var i=0;i< this.cards.length;i  ){
                var cards = this.cards;
                //闭包传递i值
                (function(i){
                    var card = cards[i];
                    card.on(cc.Node.EventType.TOUCH_START, function (event) {
                        console.log('card TOUCH_START');
                    }, card);
    
                    card.on(cc.Node.EventType.TOUCH_MOVE, function (event) {
                        console.log('card TOUCH_MOVE');
                    }, card);
    
                    card.on(cc.Node.EventType.TOUCH_END, function (event) {
                        console.log('card TOUCH_END');
                    }, card);
    
                    card.on(cc.Node.EventType.TOUCH_CANCEL, function (event) {
                        console.log('card TOUCH_CANCEL');
                    }, card);
    
    
                })(i)
    
            }
    
        },
    
        /**
         * 暂存触摸到的牌
         */
        pushTouchedCards:function(index,card){
            //构造牌对象
            var cardObj = {
                index:index,
                name:card.name,
                isSelected:card.y==this.cardInitY?false:true //高度不一样,表示选中
            };
    
            //防止重复添加
            var existCard = this.touchedCards.find(function(obj){
                if(obj.name == card.name){
                    return obj;
                }else{
                    return null;
                }
            });
            if(!existCard){
                //添加暂存
                this.touchedCards.push(cardObj);
    
                //包含提示
                this.addCardMask(card);
            }
        },
    
        /**
         * 清除原先暂存的触摸到的牌
         */
        clearTouchedCards:function(){
            for(var i=0;i<this.touchedCards.length;i  ){
                var cardIndex = this.touchedCards[i].index;
                var card = this.cards[cardIndex];
                card.removeChild(card.children[0]);
            }
            this.touchedCards = [];
        },
    
        /**
         * 选择牌
         */
        doSelectCard:function(){
            this.selectedCards = [];
    
            console.log(this.touchedCards);
    
            //改变牌状态
            for(var i = 0; i< this.touchedCards.length;i  ){
                var cardObj = this.touchedCards[i];
                var card = this.cards[cardObj.index];
                if(cardObj.isSelected){ //如果是选中改为不选中
                    card.y = card.y - 30;
                }else{ //不选中改为选中状态
                    card.y = card.y   30;
                }
            }
    
            //重置
            this.clearTouchedCards();
    
            //显示选中的牌
            this.showSelectedCards();
        },
    
        /**
         * 包含牌遮罩
         */
        addCardMask:function(card){
            var cardMask = cc.instantiate(this.cardMask);
            cardMask.setPosition(cc.p(0, 0));
            card.addChild(cardMask);
         },
    
        /**
        * 显示选中的牌
        */
        showSelectedCards:function(){
            this.selectedCards = [];
            for(var i=0;i< this.cards.length;i  ){
                var card = this.cards[i];
                var isSelected = card.y==this.cardInitY?false:true;
                if(isSelected){
                    this.selectedCards.push(card.name);
                }
            }
            //输出
            console.info("selected cards is: "  JSON.stringify(this.selectedCards));
        },
    
    
        // called every frame, uncomment this function to activate update callback
        // update: function (dt) {
    
        // },
    });
    

    贰.触控事件的冒泡,是一流一流往上冒泡,中间能够阻碍冒泡

    瞩目:那几个父节点坐标系原点是以锚点为参照的。

    四.触控地方是纯属坐标,相对于漫天canvas,节点地点相对于父节点,相对地点能够与绝对坐标相互转化

    2.触控事件的冒泡,是超级一流往上冒泡,中间能够阻碍冒泡

    效果

    柒.触摸事件对象世界坐标与节点坐标转变convertToNodeSpaceA智跑()

    近些日子参与了cocos creator的探究,开垦小游戏,结果被二个事变坑得十分不行的。今后终于消除了,分享给我们。

     

    三.父节点不响应触控事件,注意看父节点的职位、大小等,要是触点地点不在父节点区域内必将不可能触发touch事件了,父节点大小为0分明也不会触发touch事件了!

    坐标空间

    七.划算某些数值是还是不是在某1范围内,首先总计出范围的最大值、最小值,然后作对比就能够。

    5.触控地方是相对坐标,绝对于整个canvas,节点地方相对于父节点,相对地点能够与相对坐标互相转化

    8.测算某些数值是还是不是在某壹限制内,首先总括出范围的最大值、最小值,然后作比较就可以。

    cc.pSub向量相减

    原理

     

     

    伍.获取在父节点坐标系下的节点包围盒 getBoundingBox()

    效果

    3.父节点不响应触控事件,注意看父节点的地方、大小等,若是触点地点不在父节点区域内显然无法触发touch事件了,父节点大小为0鲜明也不会触发touch事件了!

    方今涉企了cocos creator的商量,开采小游戏,结果被3个事件坑得不得了不行的。以后到底解决了,分享给我们。

    www.68399.com 2

    上述那篇cocos creator Touch事件接纳(触控选择多少个子节点的实例)就是作者分享给咱们的全体内容了,希望能给大家三个参照,也目的在于我们多多帮助脚本之家。

    八.总计有些数值是否在某壹限制内,首先计算出范围的最大值、最小值,然后作比较就可以。

     

    诸如此类就能够得到到这么些子节点相对于老爸节点(锚点)的触动坐标啦、

    骨干代码

    一.触控事件是针对节点的

    cc.Class({
        extends: cc.Component,
    
        properties: {
            // foo: {
            //    default: null,      // The default value will be used only when the component attaching
            //                           to a node for the first time
            //    url: cc.Texture2D,  // optional, default is typeof default
            //    serializable: true, // optional, default is true
            //    visible: true,      // optional, default is true
            //    displayName: 'Foo', // optional
            //    readonly: false,    // optional, default is false
            // },
            // ...
                poker:{
                    default:null,
                    type:cc.Node
                },
                cardMask:{
                    default:null,
                    type: cc.Prefab
                }
        },
    
        // use this for initialization
        onLoad: function () {
    
                //牌
                this.cards = this.poker.children;
    
                //牌初始位置
                this.cardInitY = this.cards[0].y;
    
                //触摸选择到的牌
                this.touchedCards = [];
    
                //选中的牌
                this.selectedCards = [];
    
                console.info(this.cards);
            },
    
            start: function () {
                // this.cards = this.poker.children;
                // console.info(this.cards);
    
                this.addTouchEvent();
            },
    
            /**
             * 添加事件
             */
            addTouchEvent:function(){
    
                //父节点监听touch事件(直接子节点必须注册同样的事件方能触发)
                this.poker.on(cc.Node.EventType.TOUCH_START, function (event) {
                    console.log('poker TOUCH_START');
    
                    //牌
                    var card = event.target;
    
                    //起始触摸位置(和第一张card一样,相对于poker的位置)
                    this.touchStartLocation = this.cards[0].convertTouchToNodeSpace(event);
                    console.log('touch start Location:'  JSON.stringify(this.touchStartLocation));
    
                    //计算牌位置
                    var index = 0;
                    for(var i=0;i<this.cards.length;i  ){
                        var c = this.cards[i];
                      if(c.name == card.name){
                            index = i;
                            break;
                        }
                    }
    
                    //暂存第一次触摸到的牌
                    var touchedCard = {
                        index:index,
                        card:card
                    };
                    this.firstTouchedCard = touchedCard;
                    //暂存
                    this.pushTouchedCards(touchedCard.index,touchedCard.card);
    
                }, this);
    
                //父节点监听touch事件(直接子节点必须注册同样的事件方能触发)
                this.poker.on(cc.Node.EventType.TOUCH_MOVE, function (event) {
                    console.log('poker TOUCH_MOVE');
                    //先清除原先触摸到的牌
                    this.clearTouchedCards();
                    //保存第一张牌
                    this.pushTouchedCards(this.firstTouchedCard.index,this.firstTouchedCard.card);
    
                    //触摸点转换为card节点坐标
                    var nodeLocation = this.cards[0].convertTouchToNodeSpace(event);
                    console.log('touch nodeLocation:'  JSON.stringify(nodeLocation));
                    var x = nodeLocation.x;
                    var y = nodeLocation.y; 
    
                    //找到当前选中的牌
                    var currentCard = null;
                    for(var i=0;i< this.cards.length;i  ){
                        var card = this.cards[i];
                        var cardX = card.x;
                        var cardY = card.y;
                        console.log('card x=' cardX ',y=' cardY);
    
    
                        //某张牌范围包括了鼠标位置,选中此牌与触摸开头的所有牌
                        var cardWidth = i==5 ? card.width:19;
                        var cardHeight = card.height;
                        if(cardX<=x && x <= cardX cardWidth && cardY<=y && y<= cardY cardHeight){
                            currentCard = card;
    
                            //暂存触摸到的牌
                            this.pushTouchedCards(i,card);
    
                            break;
                        }
                    }
    
                    //添加开头与此牌直接的所有牌
                    var startTouchLocation = this.touchStartLocation;
                    for(var i=0;i< this.cards.length;i  ){
                        var card = this.cards[i];
                        var cardX = card.x;
                        //框选的范围包括了的牌
                        var min,max;
                        if(startTouchLocation.x < nodeLocation.x){
                            min = startTouchLocation.x;
                            max = nodeLocation.x;
                        }else{
                            min = nodeLocation.x;
                            max = startTouchLocation.x;
                        }
                        console.log('min=' min ', max=' max);
    
                        if(min <= cardX && cardX <= max){
                            //暂存触摸到的牌
                            this.pushTouchedCards(i,card);
                        }
                    }
    
    
                }, this);
    
            //父节点监听touch事件(直接子节点必须注册同样的事件方能触发)
            this.poker.on(cc.Node.EventType.TOUCH_END, function (event) {
                console.log('poker TOUCH_END');
                this.doSelectCard();
            }, this);
    
            //父节点监听touch事件(直接子节点必须注册同样的事件方能触发)
            this.poker.on(cc.Node.EventType.TOUCH_CANCEL, function (event) {
                console.log('poker TOUCH_CANCEL');
                this.doSelectCard();
            }, this);
    
            //给所有的牌注册事件,会自动冒泡到poker节点
            for(var i=0;i< this.cards.length;i  ){
                var cards = this.cards;
                //闭包传递i值
                (function(i){
                    var card = cards[i];
                    card.on(cc.Node.EventType.TOUCH_START, function (event) {
                        console.log('card TOUCH_START');
                    }, card);
    
                    card.on(cc.Node.EventType.TOUCH_MOVE, function (event) {
                        console.log('card TOUCH_MOVE');
                    }, card);
    
                    card.on(cc.Node.EventType.TOUCH_END, function (event) {
                        console.log('card TOUCH_END');
                    }, card);
    
                    card.on(cc.Node.EventType.TOUCH_CANCEL, function (event) {
                        console.log('card TOUCH_CANCEL');
                    }, card);
    
    
                })(i)
    
            }
    
        },
    
        /**
         * 暂存触摸到的牌
         */
        pushTouchedCards:function(index,card){
            //构造牌对象
            var cardObj = {
                index:index,
                name:card.name,
                isSelected:card.y==this.cardInitY?false:true //高度不一样,表示选中
            };
    
            //防止重复添加
            var existCard = this.touchedCards.find(function(obj){
                if(obj.name == card.name){
                    return obj;
                }else{
                    return null;
                }
            });
            if(!existCard){
                //添加暂存
                this.touchedCards.push(cardObj);
    
                //包含提示
                this.addCardMask(card);
            }
        },
    
        /**
         * 清除原先暂存的触摸到的牌
         */
        clearTouchedCards:function(){
            for(var i=0;i<this.touchedCards.length;i  ){
                var cardIndex = this.touchedCards[i].index;
                var card = this.cards[cardIndex];
                card.removeChild(card.children[0]);
            }
            this.touchedCards = [];
        },
    
        /**
         * 选择牌
         */
        doSelectCard:function(){
            this.selectedCards = [];
    
            console.log(this.touchedCards);
    
            //改变牌状态
            for(var i = 0; i< this.touchedCards.length;i  ){
                var cardObj = this.touchedCards[i];
                var card = this.cards[cardObj.index];
                if(cardObj.isSelected){ //如果是选中改为不选中
                    card.y = card.y - 30;
                }else{ //不选中改为选中状态
                    card.y = card.y   30;
                }
            }
    
            //重置
            this.clearTouchedCards();
    
            //显示选中的牌
            this.showSelectedCards();
        },
    
        /**
         * 包含牌遮罩
         */
        addCardMask:function(card){
            var cardMask = cc.instantiate(this.cardMask);
            cardMask.setPosition(cc.p(0, 0));
            card.addChild(cardMask);
         },
    
        /**
        * 显示选中的牌
        */
        showSelectedCards:function(){
            this.selectedCards = [];
            for(var i=0;i< this.cards.length;i  ){
                var card = this.cards[i];
                var isSelected = card.y==this.cardInitY?false:true;
                if(isSelected){
                    this.selectedCards.push(card.name);
                }
            }
            //输出
            console.info("selected cards is: "  JSON.stringify(this.selectedCards));
        },
    
    
        // called every frame, uncomment this function to activate update callback
        // update: function (dt) {
    
        // },
    });
    

    依照事件坐标来获得到他那是(以ACR-V锚点为原点)是480,320

    www.68399.com 3

    眼前加入了cocos creator的研商,开拓小游戏,结果被三个事变坑得要命不行的。未来终于化解了,分享给大家。

     

    黑灰的是子节点

    四.触控事件往祖先节点冒泡,祖先节点是不是会检验触点是还是不是在大团结区域内,由子节点是还是不是监听了touch事件有关。子监听了,父就不会检查评定区域是或不是含有触点,始终响应触控事件,没有监听,则会检查评定是还是不是包蕴触点,包蕴才会响应触控事件!(这一点与官方网站文书档案不相同,笔者亲测出来的结果)

    原理

    2.cc.Size/cc.Rect

    宗旨代码

    六.节点是否被触控到,touch start事件可以毫无疑问被触动到,但是三个节点触摸到必须等待其得了,另一个节点技巧响应touch事件

    //精灵的锚点 作为世界坐标
    var pos = cc.p(480,320);
    var node_pos = this.node.convertToNodeSpace(pos);
    //输出的就是50,50 因为是以节点的(0,0)作为原点等
    console.log(node_pos);
    

    本文由68399皇家赌场发布于服务器租用,转载请注明出处:【www.68399.com】cc.Node.坐标空间

    关键词: 68399皇家赌场 JavaScript Web前端 cocos creato JavaScri

上一篇:Vue原理深入分析 完结双向绑定MVVM

下一篇:没有了