精华内容
下载资源
问答
  • cocos creator 消灭星星

    2018-08-28 15:15:01
    消灭星星小游戏,cocos creator + javascript,关卡类型。与市面上的消灭星星差不多,比较简单,适合初学者学习
  • CocosCreator 消灭星星

    2018-03-08 10:42:13
    Cocos Creator 版消灭星星,方便学习Creator 的同学参考
  • cocos2dX消灭星星,资源共分成2部分,代码简单易学。
  • 消灭星星cocos2dx

    2017-09-11 18:51:30
    基于cocos2dx3.10 和 vs2013完美运行,点击星星会消除,还有道具可以使用,666666666666666666666666666666666666666666666666666666
  • cocos2dx 消灭星星

    2017-07-13 19:56:55
    bool GamePopStar::touchBegan(cocos2d::Touch* touch, cocos2d::Event*) { auto pos = touch->getLocation(); if (pos.x * WIDTH && pos.y * HEIGH) { int x = pos.x / 40; int y = pos.y / 40; if (stars...

    #include "GamePopStar.h"
    #include "StarSprite.h"
    
    USING_NS_CC;
    
    Scene* GamePopStar::createScene()
    {
    	auto scene = Scene::create();
    	auto layer = GamePopStar::create();
    	scene->addChild(layer);
    	return scene;
    }
    
    bool GamePopStar::init()
    {
    	if (!Layer::init())
    		return false;
    
    	addStars();
    	auto listener = EventListenerTouchOneByOne::create();
    	listener->onTouchBegan = CC_CALLBACK_2(GamePopStar::touchBegan, this);
    	Director::getInstance()->getEventDispatcher()->addEventListenerWithSceneGraphPriority(listener, this);
    	scheduleUpdate();
    
    	return true;
    }
    
    void GamePopStar::addStars()
    {
    	srand(time(NULL));
    	for (int w = 0; w < WIDTH; ++w)
    	{
    		for (int h = 0; h < HEIGH; ++h)
    		{
    			stars[w][h] = StarSprite::createStar(rand() % 5 + 1, w, h);
    			addChild(stars[w][h]);
    		}
    	}
    }
    
    bool GamePopStar::touchBegan(cocos2d::Touch* touch, cocos2d::Event*)
    {
    	auto pos = touch->getLocation();
    	if (pos.x < 40 * WIDTH && pos.y < 40 * HEIGH)
    	{
    		int x = pos.x / 40;
    		int y = pos.y / 40;
    		if (stars[x][y]->getType() != 0)
    		{
    			//stars[x][y]->deleStar();
    			delStarsFrom(stars[x][y]->getType(), x, y);
    			starsDrop();
    			if (isOver())
    				exit(-1);
    		}
    	}
    	return false;
    }
    
    void GamePopStar::delStarsFrom(int type, int w, int h)
    {
    	if (type == 0)
    		return;
    	
    	bool canDel = false;
    	
    	if (w - 1 >= 0 && stars[w - 1][h]->getType() == type)
    	{
    		delStarsFromRight(type, w - 1, h);
    		canDel = true;
    	}
    	if (w + 1 < WIDTH && stars[w + 1][h]->getType() == type)
    	{
    		delStarsFromLeft(type, w + 1, h);
    		canDel = true;
    	}
    	if (h - 1 >= 0 && stars[w][h - 1]->getType() == type)
    	{
    		delStarsFromUp(type, w, h - 1);
    		canDel = true;
    	}
    	if (h + 1 < HEIGH && stars[w][h + 1]->getType() == type)
    	{
    		delStarsFromDown(type, w, h + 1);
    		canDel = true;
    	}
    
    	if (canDel)
    		stars[w][h]->deleStar();
    }
    
    void GamePopStar::delStarsFromUp(int type, int w, int h)
    {
    	stars[w][h]->deleStar();
    	if (w - 1 >= 0 && stars[w - 1][h]->getType() == type)
    		delStarsFromRight(type, w - 1, h);
    	if (w + 1 < WIDTH && stars[w + 1][h]->getType() == type)
    		delStarsFromLeft(type, w + 1, h);
    	if (h - 1 >= 0 && stars[w][h - 1]->getType() == type)
    		delStarsFromUp(type, w, h - 1);
    }
    void GamePopStar::delStarsFromDown(int type, int w, int h)
    {
    	stars[w][h]->deleStar();
    	if (w - 1 >= 0 && stars[w - 1][h]->getType() == type)
    		delStarsFromRight(type, w - 1, h);
    	if (w + 1 < WIDTH && stars[w + 1][h]->getType() == type)
    		delStarsFromLeft(type, w + 1, h);
    	if (h + 1 < HEIGH && stars[w][h + 1]->getType() == type)
    		delStarsFromDown(type, w, h + 1);
    }
    void GamePopStar::delStarsFromLeft(int type, int w, int h)
    {
    	stars[w][h]->deleStar();
    	if (w + 1 < WIDTH && stars[w + 1][h]->getType() == type)
    		delStarsFromLeft(type, w + 1, h);
    	if (h - 1 >= 0 && stars[w][h - 1]->getType() == type)
    		delStarsFromUp(type, w, h - 1);
    	if (h + 1 < HEIGH && stars[w][h + 1]->getType() == type)
    		delStarsFromDown(type, w, h + 1);
    }
    void GamePopStar::delStarsFromRight(int type, int w, int h)
    {
    	stars[w][h]->deleStar();
    	if (w - 1 >= 0 && stars[w - 1][h]->getType() == type)
    		delStarsFromRight(type, w - 1, h);
    	if (h - 1 >= 0 && stars[w][h - 1]->getType() == type)
    		delStarsFromUp(type, w, h - 1);
    	if (h + 1 < HEIGH && stars[w][h + 1]->getType() == type)
    		delStarsFromDown(type, w, h + 1);
    }
    
    void GamePopStar::starsDrop()
    {
    	//下落
    	for (int w = 0; w < WIDTH; ++w)
    	{
    		for (int h = 1; h < HEIGH; ++h)
    		{
    			int num = 0;
    			for (int i=0; i < h; ++i)
    			{
    				/*if (stars[w][i]->getType() == 0)
    				{
    					auto temp = stars[w][i];
    					stars[w][i] = stars[w][h];
    					stars[w][h] = temp;
    					break;
    				}*/
    				if (stars[w][i]->getType() == 0)
    					++num;
    			}
    			auto temp = stars[w][h];
    			stars[w][h] = stars[w][h - num];
    			stars[w][h - num] = temp;
    			//stars[w][h]->move(1, w, h);
    		}
    	}
    	//左移
    	for (int w = 1; w < WIDTH; ++w)
    	{
    		for (int i = 0; i < w; ++i)
    		{
    			if (stars[i][0]->getType() == 0)
    			{
    				for (int h = 0; h < HEIGH; ++h)
    				{
    					auto temp = stars[i][h];
    					stars[i][h] = stars[w][h];
    					stars[w][h] = temp;
    				}
    				break;
    			}
    		}
    	}
    
    	for (int w = 0; w < WIDTH; ++w)
    	{
    		for (int h = 0; h < HEIGH; ++h)
    		{
    			stars[w][h]->move(0.5,w,h);
    		}
    	}
    }
    
    bool GamePopStar::isOver()
    {
    	for (int w = 0; w < WIDTH; ++w)
    	{
    		for (int h = 0; h < HEIGH; ++h)
    		{
    			auto type = stars[w][h]->getType();
    			if (type == 0)
    				continue;
    			if (w - 1 >= 0 && stars[w - 1][h]->getType() == type)
    			{
    				return false;
    			}
    			if (w + 1 < WIDTH && stars[w + 1][h]->getType() == type)
    			{
    				return false;
    			}
    			if (h - 1 >= 0 && stars[w][h - 1]->getType() == type)
    			{
    				return false;
    			}
    			if (h + 1 < HEIGH && stars[w][h + 1]->getType() == type)
    			{
    				return false;
    			}
    		}
    	}
    	return true;
    }
    
    void GamePopStar::update(float dt)
    {
    	static int w = 0;
    	static int h = 0;
    
    	if (w < WIDTH && h < HEIGH)
    	{
    		stars[w][h]->move(0.1*(w+1)/(h+1), w, h);
    		++w;
    	}
    	else if (h < HEIGH)
    	{
    		w = 0;
    		++h;
    	}
    	else
    	{
    		unscheduleUpdate();
    	}
    }
    #include "StarSprite.h"
    
    USING_NS_CC;
    
    StarSprite* StarSprite::createStar(int type, float x, float y)
    {
    	auto star = new StarSprite();
    	if (star && star->init())
    	{
    		star->autorelease();
    		star->initStar(type, x, y);
    	}
    	else
    	{
    		delete star;
    		star = NULL;
    	}
    	return star;
    }
    
    bool StarSprite::init()
    {
    	if (!Layer::init())
    		return false;
    	return true;
    }
    
    void StarSprite::initStar(int type, float x, float y)
    {
    	this->type = type;
    	star = Sprite::create(String::createWithFormat("card%d.png", type)->getCString());
    	//star->setPosition(20 + 40 * x, 20 + 40 * y);
    	star->setPosition(20 + 40 * x, 20 + 40 * 16);
    	addChild(star);
    }
    
    void StarSprite::deleStar()
    {
    	this->type = 0;
    	star->setSpriteFrame(SpriteFrame::create("card0.png", Rect(0, 0, 40, 40)));
    }
    
    void StarSprite::move(float dt, int w, int h)
    {
    	auto move = MoveTo::create(dt, Vec2(w * 40 + 20, h * 40 + 20));
    	star->runAction(move);
    }
    代码下载

    展开全文
  • Cocos2d x 消灭星星源码 PopStar @更多@ http: cleopard download csdn net 13份WPF经典开发教程 http: download csdn net album detail 1115 C#资料合辑二[C#桌面编程入门篇] ...C#资料合辑一[C#入门篇] ...
  • cocos2d-x实现的消灭星星小游戏复刻: 实现了: 1.完整的UI界面和跳转 2.游戏逻辑的模仿和实现 3.加入粒子特效等实现炫酷的效果
  • 2 * 本层拥有处理星星的实例化以及对星星的操作 3 * 1/排列星星 4 * 2/移动和删除星星 5 */ 6 var GameStarLayout = ccui.Layout.extend( 7 { 8 size:null, 9 starArr:[],//存放点击与被点击状态的...
      1 /*
      2  * 本层拥有处理星星的实例化以及对星星的操作
      3  * 1/排列星星
      4  * 2/移动和删除星星
      5  */
      6 var GameStarLayout = ccui.Layout.extend(
      7 {
      8     size:null,
      9     starArr:[],//存放点击与被点击状态的星星资源
     10     starObjArr:[],//存放游戏中星星的二位数组
     11     firstTouchStar:null,//第一次选择的星星,用于判断两次选择的星星颜色是否一致
     12     isSelected:false,//是否选择星星,如果已选择则再次点击将星星消灭
     13     starList:[],//相连同色星星列表
     14     ctor:function()
     15     {
     16         this._super();
     17         this.zinit();
     18         this.layoutStar();
     19     },
     20     //将星星按10*10的矩阵排列出来
     21     layoutStar:function()
     22     {
     23         for(var i = 0; i < 10; i++)
     24         {
     25             for(var j = 0; j < 10; j++)    
     26             {
     27                 //随机从5种不同颜色的星星中选择一个
     28                 var randomNumber = Math.floor(Math.random()*this.starArr.length);
     29                 var starResource = this.starArr[randomNumber];
     30                 var star = new GameCreateStar(starResource.normal, starResource.id,starResource.selected, i, j);
     31                 this.addChild(star, 0);
     32                 //星星出现的动画
     33                 var moveTo = cc.moveTo(i/10, cc.p(star.width*i, star.height*j));
     34                 star.runAction(moveTo);
     35                 //将星星装到数组中
     36                 this.starObjArr[i][j] = star;
     37                 //给每一个星星注册侦听器
     38                 star.addTouchEventListener(this.onTouchStarFunc, this);
     39             }
     40         }
     41     },
     42     //星星触摸侦听函数
     43     onTouchStarFunc:function(target, state)
     44     {
     45         if(state == ccui.Widget.TOUCH_ENDED)    //松开
     46         {
     47             if(!this.firstTouchStar)    //如果第一次选择的星星为空,则将当前星星赋给它
     48             {
     49                 this.firstTouchStar = target;
     50                 this.findSameColorStar(target);
     51             }
     52             else 
     53             {
     54                 if(this.starList.length <1){return;} //确保相连同色星星列表不为空,代码才会向下执行
     55                 if(this.starList[0].count != target.count) //第二次点击的不是上一次选择的星星
     56                 {
     57                     //将列表中的星星type还原
     58                     this.setStarListItemToNomal(this.starList);
     59                     this.findSameColorStar(target);
     60                 }
     61                 else    //第二次点击相连同色星星列表中的星星
     62                 {
     63                     this.firstTouchStar = null;
     64                     this.removeSameColorStar();
     65                 }
     66             }
     67         }
     68     },
     69     //消灭相连在一起的同色星星
     70     removeSameColorStar:function()
     71     {
     72         for(var i = 0; i < this.starList.length; i++)
     73         {
     74             //this.starObjArr是二维数组
     75             for(var j = 0; j < this.starObjArr.length; j++)
     76             {
     77                 for(var k = 0; k < this.starObjArr.length; k++)
     78                 {
     79                     if(this.starObjArr[j][k].col == this.starList[i].col && this.starObjArr[j][k].row == this.starList[i].row)
     80                     {
     81                         this.starObjArr[j][k].removeFromParent();
     82                     }
     83                 }
     84             }
     85         }
     86         this.starList.splice(0);
     87     },
     88     //寻找相连在一起同色的星星
     89     findSameColorStar:function(target)
     90     {
     91         //相连同色星星列表
     92         this.starList.splice(0);    //将列表清空
     93         this.starList = this.getSameColorStar(target.col, target.row, target.type);
     94         //将满足条件的相连同色星星设为选中状态,玩家能对消除星星数量一幕了然
     95         this.showCurrentSameStarSelectedState(this.starList);
     96     },
     97     //如果两次选择的不是同种颜色的星星,则将之前选择的星星设为初始状态
     98     setStarListItemToNomal:function(starList)
     99     {
    100         for(var i = 0; i < starList.length; i++)
    101         {
    102             //还原列表中星星的初始type值
    103             starList[i].type = starList[i].normalType;
    104             starList[i].isSelected = false;
    105             starList[i].updateTexture();
    106             starList[i].count = 0;
    107         }
    108     },
    109     //将满足条件的相连同色星星设为选中状态
    110     showCurrentSameStarSelectedState:function(starList)
    111     {
    112         for(var i = 0; i < starList.length; i++)
    113         {
    114             starList[i].isSelected = true;
    115             starList[i].updateTexture();
    116             starList[i].count++;
    117         }
    118     },
    119     //获得相连同色星星列表
    120     getSameColorStar:function(col, row, type)
    121     {
    122         var starList = [];
    123         //星星必须在矩阵范围内(9X9)
    124         if(this.jugementStarPostion(col, row) == -1)
    125         {
    126             return starList;    
    127         }
    128         if(this.starObjArr[col][row].type == type)
    129         {
    130             starList.push(this.starObjArr[col][row]);
    131             this.starObjArr[col][row].type = -1;
    132             //递归调用,寻找当前星星四周的同色星星
    133             starList = starList.concat(this.getSameColorStar(col+1, row, type));//右边
    134             starList = starList.concat(this.getSameColorStar(col - 1, row, type));//左边
    135             starList = starList.concat(this.getSameColorStar(col, row + 1, type));//上方
    136             starList = starList.concat(this.getSameColorStar(col, row - 1, type));//下方
    137         }
    138         return starList;
    139     },
    140     //判断col,row值是否在矩阵范围内,
    141     jugementStarPostion:function(col, row)
    142     {
    143         if(col < 0 ||col >9)    //超出水平范围
    144         {
    145             return -1;
    146         }
    147         if(row < 0 || row > 9) //超出垂直范围
    148         {
    149             return -1;
    150         }
    151         if(this.starObjArr[col][row] == null || this.starObjArr[col][row] == undefined)    //该对象不存在
    152         {
    153             return -1;
    154         }
    155         return this.starObjArr[col][row].type;
    156     },
    157     //初始化
    158     zinit:function()
    159     {
    160         this.size = cc.size(480, 500);
    161         //设置层的大小
    162         this.setSize(this.size);
    163         //将星星资源存放到数字中
    164         this.starArr = [
    165                         {id:1, normal:res.star1, selected:res.star1s},
    166                         {id:2, normal:res.star2, selected:res.star2s},
    167                         {id:3, normal:res.star3, selected:res.star3s},
    168                         {id:4, normal:res.star4, selected:res.star4s},
    169                         {id:5, normal:res.star5, selected:res.star5s}
    170                         ];
    171         for(var i = 0; i < 10; i++)
    172         {
    173             this.starObjArr.push([]);
    174         }
    175     }
    176 });
    177 //实例化
    178 GameStarLayout.createLayout = function()
    179 {
    180     var starLayout = new GameStarLayout();
    181     return starLayout;
    182 };
    /***************************effect image****************************/
     
     

     

    转载于:https://www.cnblogs.com/zfsSuperDream/p/4065311.html

    展开全文
  • 小游戏开发 之 消灭星星cocos-creator) 最近开始搞小游戏,只是算练练手,消灭星星太经典了,非常适合拿来练手,核心流程就是《创建方块》、《消除》、《移动》、《结算》。这里只挑消除和结算讲一下。 方块消除 ...

    小游戏开发 之 消灭星星(cocos-creator)

    最近开始搞小游戏,消灭星星太经典了,非常适合拿来练手,核心流程就是《创建方块》、《消除》、《移动》、《结算》。这里只挑重要的讲一下。

    方块消除

    消除是在发生触摸的时候,只需监听 “touchend” 就好,根据触摸信息得到点击的方块的行和列,之后通过递归得到此次可消除的全部方块,代码如下:

        retrieval(row, col){
            if(row < 0 || row >= this.rowNum || col < 0 || col >= this.colNum) return;//越界
            const cubeNode = this.allCube[row][col];
            if(cubeNode == null) return;//为空
            var com = cubeNode.getComponent('wss_ps_Cube');
            if(com.alreadyRet) return;//已遍历过的位置
            com.alreadyRet = true;//初次遍历到,也只会遍历一次
            if(com.cubeType!=this.curType){
            	return;//颜色不同
            }
            else{
                com.willRemove = true;//即将消除
                this.removeCount++;//消除数量加1
    
                //遍历四周
                this.retrieval(row, col - 1);
                this.retrieval(row, col + 1);
                this.retrieval(row + 1, col);
                this.retrieval(row - 1, col);
            }
        },
    

    方块移动

    移动分为垂直移动和水平移动,如果当次消除导致有空列产生,那么会发生水平方向上的移动,否则只会进行垂直方向的方块移动,代码如下:

        //垂直降落
        moveDown(){
            for(let i = 0; i < this.rowNum; i++){
                for(let j = 0; j < this.colNum; j++){
                    var tempRow = i;
                    var cubeNode = this.allCube[i][j];
                    //脚下为空就会向下移动
                    if(cubeNode == null){
                        //确定向下移动的位置
                        while(tempRow < this.rowNum){
                            cubeNode = this.allCube[tempRow][j];
                            if(cubeNode != null) break;
                            tempRow++;
                        }
                        if(cubeNode != null)
                        {
                            //数据交换
                            this.allCube[i][j] = this.allCube[tempRow][j];
                            this.allCube[tempRow][j] = null;
                            this.allCube[i][j].getComponent('wss_ps_Cube').resetRowCol(i, j);
                        }
                    }
                }
            }
        },
    
        //向底部中间靠齐
        moveBottomCenter(){
            for(let i = 0; i < this.colNum; i++){
                var cubeNode = this.allCube[0][i];
                //发现空列
                if(cubeNode == null){
                    for(let col = (i+1); col < this.colNum; col++){
                        //整列移动
                        for(let row = 0; row < this.rowNum; row++){
                            var cubeNode = this.allCube[row][col];
                            if(cubeNode != null){
                                //数据交换
                                this.allCube[row][col - 1] = this.allCube[row][col];
                                this.allCube[row][col] = null;
                                this.allCube[row][col - 1].getComponent('wss_ps_Cube').resetRowCol(row, col - 1);
                            }
                        }
                    }
                }
            }
    
            if(this.haveSpace()){
                //还有空列的话则继续递归
                this.moveBottomCenter();
            }
        },
        
    	//开始移动
        realMove(){
            //所有方块在x轴方向的偏移(列数减少导致的)
            const offsetX = (this.colNum - this.getLeftCol()) * this.cubeWidth * 0.5;
    
            for(let i = 0; i < this.rowNum; i++){
                for(let j = 0; j < this.colNum; j++){
                    var cubeNode = this.allCube[i][j];
                    if(cubeNode != null){
                        //0.1秒移动到位
                        cc.tween(this.allCube[i][j])
                            .to(0.1, {position: cc.v2(this.posMatrix[i][j].x + offsetX, this.posMatrix[i][j].y)})
                            .start();
                    }
                }
            }
        },
    

    游戏结束

    判断结束的方法主意是遍历剩下的方块,如果方块上方或右方有同色方块,则游戏继续,否则游戏结束,代码如下:

    	//判断游戏是否结束
    	gameOver(){
            for(let i = 0; i < this.rowNum; i++){
                for(let j = 0; j < this.colNum; j++){
                    var cubeNode = this.allCube[i][j];
                    if(cubeNode != null){
                        var comSrc = cubeNode.getComponent('wss_ps_Cube');
    
                        var checkRow = i + 1;
                        if(checkRow < this.rowNum){
                            var cubeUp = this.allCube[checkRow][j];
                            if(cubeUp != null){
                                var comUp = cubeUp.getComponent('wss_ps_Cube');
                                if(comSrc.cubeType == comUp.cubeType)
                                    return;     //垂直方向还有可以消除的
                            }
                        }
    
                        var checkCol = j + 1;
                        if(checkCol < this.colNum){
                            var cubeRight = this.allCube[i][checkCol];
                            if(cubeRight != null){
                                var comRight = cubeRight.getComponent('wss_ps_Cube');
                                if(comSrc.cubeType == comRight.cubeType)
                                    return;     //水平方向还有可以消除的
                            }
                        }
                    }
                }
            }
    
            //游戏结束处理
        },
    

    好了,很好玩的小游戏基本就完成了,稍后附上项目源码。

    下载地址

    https://download.csdn.net/download/wss_xiaotiaowa/11342892

    展开全文
  • 2 * 本层拥有处理星星的实例化以及对星星的操作 3 * 1/排列星星 4 * 2/移动和删除星星 5 */ 6 var GAMESTARLAYOUT; 7 var GameStarLayout = ccui.Layout.extend( 8 { 9 size:null, 10 starArr:[],/...
      1 /*
      2  * 本层拥有处理星星的实例化以及对星星的操作
      3  * 1/排列星星
      4  * 2/移动和删除星星
      5  */
      6 var GAMESTARLAYOUT;
      7 var GameStarLayout = ccui.Layout.extend(
      8 {
      9     size:null,
     10     starArr:[],//存放点击与被点击状态的星星资源
     11     starObjArr:[],//存放游戏中星星的二位数组
     12     firstTouchStar:null,//第一次选择的星星,用于判断两次选择的星星颜色是否一致
     13     isSelected:false,//是否选择星星,如果已选择则再次点击将星星消灭
     14     starList:[],//相连同色星星列表
     15     starNum:0,//当前关卡星星个数
     16     ctor:function()
     17     {
     18         this._super();
     19         this.zinit();
     20         this.layoutStar();
     21     },
     22     //将星星按10*10的矩阵排列出来
     23     layoutStar:function()
     24     {
     25         for(var i = 0; i < 10; i++)
     26         {
     27             for(var j = 0; j < 10; j++)    
     28             {
     29                 //随机从5种不同颜色的星星中选择一个
     30                 var randomNumber = Math.floor(Math.random()*this.starNum);
     31                 var starResource = this.starArr[randomNumber];
     32                 var star = new GameCreateStar(starResource.normal, starResource.id,starResource.selected, i, j);
     33                 this.addChild(star, 0);
     34                 //星星出现的动画
     35                 var moveTo = cc.moveTo(i/10, cc.p(star.width*i, star.height*j));
     36                 star.runAction(moveTo);
     37                 //将星星装到数组中
     38                 this.starObjArr[i][j] = star;
     39                 //给每一个星星注册侦听器
     40                 star.addTouchEventListener(this.onTouchStarFunc, this);
     41             }
     42         }
     43     },
     44     //星星触摸侦听函数
     45     onTouchStarFunc:function(target, state)
     46     {
     47         if(state == ccui.Widget.TOUCH_ENDED)    //松开
     48         {
     49             if(!this.firstTouchStar)    //如果第一次选择的星星为空,则将当前星星赋给它
     50             {
     51                 this.firstTouchStar = target;
     52                 this.findSameColorStar(target);
     53                 //如果计分动作未完成则结束动作,取消定时器
     54                 GAMETOP.cancelSchedule();
     55             }
     56             else     
     57             {
     58                 if(this.starList.length <1){return;} //确保相连同色星星列表不为空,代码才会向下执行
     59                 if(this.starList[0].count != target.count) //第二次点击的不是上一次选择的星星
     60                 {
     61                     //将列表中的星星type还原
     62                     this.setStarListItemToNomal(this.starList);
     63                     this.findSameColorStar(target);
     64                 }
     65                 else    //第二次点击相连同色星星列表中的星星
     66                 {
     67                     if(this.starList.length >1)
     68                     {
     69                         this.firstTouchStar = null;
     70                         this.getScore();
     71                         this.resetStarRow();
     72                     }
     73                 }
     74             }
     75         }
     76     },
     77     //消灭信息获得积分
     78     getScore:function()
     79     {
     80         //GAMETOP对象为GameTopInformation的实例;
     81         GAMETOP.updateGameScore(this.starList);
     82     },
     83     //当消灭星星后,如果上方还有星星存在,则要重新设置他们的row值,用于向下移动星星
     84     resetStarRow:function()
     85     {
     86         for(var i = 0; i < this.starList.length; i++)
     87         {
     88             this.starList[i].type = -1;
     89             this.starList[i].removeFromParent();
     90             for(var j = this.starList[i].row+1; j< 10; j++)
     91             {
     92                 if(!this.starObjArr[this.starList[i].col][j]){continue;} 
     93                 this.starObjArr[this.starList[i].col][j].row--;
     94                 this.starObjArr[this.starList[i].col][j-1] = this.starObjArr[this.starList[i].col][j];
     95                 this.starObjArr[this.starList[i].col][j] = null;
     96             }
     97         }
     98     },
     99     //消灭相连在一起的同色星星
    100     removeSameColorStar:function()
    101     {
    102         for(var i = 0; i < this.starList.length; i++)
    103         {
    104             //this.starObjArr是二维数组
    105             for(var j = 0; j < this.starObjArr.length; j++)
    106             {
    107                 for(var k = 0; k < this.starObjArr.length; k++)
    108                 {
    109                     if(!this.starObjArr[j][k]){continue;} 
    110                     if(this.starObjArr[j][k].col == this.starList[i].col && this.starObjArr[j][k].row == this.starList[i].row)
    111                     {
    112                         this.starObjArr[j][k].removeFromParent();
    113                     }
    114                 }
    115             }
    116         }
    117         this.starList.splice(0);
    118     },
    119     //逐帧监听器,在游戏过程中一直执行
    120     update:function()
    121     {
    122         //检测是否有需要移动的星星(上边的向下移动,右边的向左边移动
    123         this.checkMove();
    124     },
    125     //检测是否有需要移动的星星,如果被消除的星星上方还有星星,则上方的需要掉下来,如果这一列为空了且右边还有星星,则右边的需要往做移动
    126     checkMove:function()    
    127     {
    128         //检测上方
    129         this.checkTop();
    130     },
    131     //检测被移除星星上方是否还有星星,如果有则下移
    132     checkTop:function()
    133     {
    134         var needMove = false;
    135         for(var i = 0; i < 10; i++)
    136         {
    137             for(var j = 0; j < 10; j++)
    138             {
    139                 if(this.starObjArr[i][j] !=null && this.starObjArr[i][j].type != -1)
    140                 {
    141                     //向下移动
    142                     if(this.starObjArr[i][j].y > this.starObjArr[i][j].row*48)
    143                     {
    144                         this.starObjArr[i][j].y -= 8;
    145                         needMove = true;
    146                     }
    147                     //向左移动
    148                     if(this.starObjArr[i][j].x > this.starObjArr[i][j].col*48)
    149                     {
    150                         this.starObjArr[i][j].x -= 8;
    151                         needMove = true;
    152                     }
    153                 }
    154             }
    155         }
    156         //当有星星向下移动时,不能移动列
    157         if(!needMove)
    158         {
    159             //检测是否有空列,如果有则把其右边的列向左移动
    160             this.checkEmptyColums();
    161         }
    162     },
    163     //检测空列
    164     checkEmptyColums:function()
    165     {
    166         var existEmptyCol = false;
    167         for(var i = 0; i < 10; i++)
    168         {
    169             if(!existEmptyCol)
    170             {
    171                 //只有在消灭星星后才能检测空列
    172                 if(this.firstTouchStar == null)
    173                 {
    174                     //当列的最下面元素为空时,说明该列为空
    175                     if(this.starObjArr[i][0] == null || this.starObjArr[i][0].type == -1)
    176                     {
    177                         existEmptyCol = true;
    178                     }
    179                 }
    180             }
    181             //当有空列时,处理列的移动和col属性的设置
    182             else if(existEmptyCol)
    183             {
    184                 for(var j = 0; j < 10; j++)
    185                 {
    186                     if(this.starObjArr[i][j] != null )
    187                     {
    188                         this.starObjArr[i][j].col--;
    189                         this.starObjArr[i-1][j] = this.starObjArr[i][j];
    190                         this.starObjArr[i][j] = null;
    191                     }
    192                 }
    193             }
    194         }
    195     },
    196     //寻找相连在一起同色的星星
    197     findSameColorStar:function(target)
    198     {
    199         //相连同色星星列表
    200         this.starList.splice(0);    //将列表清空
    201         this.starList = this.getSameColorStar(target.col, target.row, target.type);
    202         //将满足条件的相连同色星星设为选中状态,玩家能对消除星星数量一幕了然
    203         this.showCurrentSameStarSelectedState(this.starList);
    204     },
    205     //如果两次选择的不是同种颜色的星星,则将之前选择的星星设为初始状态
    206     setStarListItemToNomal:function(starList)
    207     {
    208         for(var i = 0; i < starList.length; i++)
    209         {
    210             //还原列表中星星的初始type值
    211             starList[i].type = starList[i].normalType;
    212             starList[i].isSelected = false;
    213             starList[i].updateTexture();
    214             starList[i].count = 0;
    215         }
    216     },
    217     //将满足条件的相连同色星星设为选中状态
    218     showCurrentSameStarSelectedState:function(starList)
    219     {
    220         for(var i = 0; i < starList.length; i++)
    221         {
    222             starList[i].isSelected = true;
    223             starList[i].updateTexture();
    224             starList[i].count++;
    225         }
    226     },
    227     //获得相连同色星星列表
    228     getSameColorStar:function(col, row, type)
    229     {
    230         var starList = [];
    231         //星星必须在矩阵范围内(9X9)
    232         if(this.jugementStarPostion(col, row) == -1)
    233         {
    234             return starList;    
    235         }
    236         if(this.starObjArr[col][row].type == type)
    237         {
    238             starList.push(this.starObjArr[col][row]);
    239             this.starObjArr[col][row].type = -1;
    240             //递归调用,寻找当前星星四周的同色星星
    241             starList = starList.concat(this.getSameColorStar(col+1, row, type));//右边
    242             starList = starList.concat(this.getSameColorStar(col - 1, row, type));//左边
    243             starList = starList.concat(this.getSameColorStar(col, row + 1, type));//上方
    244             starList = starList.concat(this.getSameColorStar(col, row - 1, type));//下方
    245         }
    246         return starList;
    247     },
    248     //判断col,row值是否在矩阵范围内,
    249     jugementStarPostion:function(col, row)
    250     {
    251         if(col < 0 ||col >9)    //超出水平范围
    252         {
    253             return -1;
    254         }
    255         if(row < 0 || row > 9) //超出垂直范围
    256         {
    257             return -1;
    258         }
    259         if(this.starObjArr[col][row] == null || this.starObjArr[col][row] == undefined)    //该对象不存在
    260         {
    261             return -1;
    262         }
    263         return this.starObjArr[col][row].type;
    264     },
    265     //检测游戏结束当没有可以消除的星星时游戏宣布结束
    266     checkGameOver:function()
    267     {
    268         //遍历所有的星星
    269         for(var i = 0; i < 10; i++)
    270         {
    271             for(var j = 0; j < 10; j++)
    272             {
    273                 var starType = this.jugementStarPostion(i, j);
    274                 if(starType == -1){continue;}//不存在星星,则继续下一次循环(当starType =-1时表示该位置没有星星)
    275                 if(starType == this.jugementStarPostion(i, j+1)){return;}//同理
    276                 if(starType == this.jugementStarPostion(i+1, j)){return;}//当相邻有相同颜色星星时还回(因为是遍历每一个星星,所以水平方向只需要检测星星相邻右侧是否有相同颜色的就可以了)
    277             }
    278         }
    279         //当没有相同颜色的星星时,宣布游戏结束
    280         this.endGame();
    281     },
    282     //游戏结束
    283     endGame:function()
    284     {
    285         //未通关,还回游戏初始界面
    286         if(GAMETOP.intermediaryScore < GAMETOP.standardScore)
    287         {
    288             GAMETOP.passedLevelEffect(res.fail);
    289             var delayTime = cc.DelayTime.create(2.2);
    290             var callFunc = cc.CallFunc.create(function()
    291             {
    292                 PlayerLocalData.deleteItem();//删除游戏纪录
    293                 var newGameScene = GameInitializeScene.createScene();
    294                 cc.director.runScene(cc.TransitionFade.create(1, newGameScene));
    295             }, this);
    296             this.runAction(cc.Sequence.create(delayTime, callFunc));
    297         }
    298         else//通过,弹出继续游戏和保存退出按钮
    299         {
    300             var endX = 240;
    301             var endY = 850;
    302             var b = 400;
    303             var c = 330;
    304             //继续游戏
    305             var continueGameBtn = new myButton(res.resume);
    306             continueGameBtn.setAnchorPoint(0.5, 0.5);
    307             continueGameBtn.name = "continueGame";
    308             continueGameBtn.x = endX;
    309             continueGameBtn.y = endY
    310             this.addChild(continueGameBtn, 1);
    311             //action2
    312             var moveTo2 = cc.MoveTo.create(4, cc.p(endX, b));
    313             var easeOut2 = moveTo2.clone().easing(cc.easeElasticOut());
    314             continueGameBtn.runAction(easeOut2);
    315             //保存退出
    316             var saveAndOut = new myButton("img/saveexit.png");
    317             saveAndOut.setAnchorPoint(0.5, 0.5);
    318             saveAndOut.name = "save";
    319             saveAndOut.x = endX;
    320             saveAndOut.y = endY;
    321             this.addChild(saveAndOut, 1);
    322             //action3
    323             var moveTo3 = cc.MoveTo.create(3, cc.p(endX, c));
    324             var easeOut3 = moveTo3.clone().easing(cc.easeElasticOut());
    325             saveAndOut.runAction(easeOut3);
    326             
    327             continueGameBtn.addTouchEventListener(this.btnControlGameFunc, this);
    328             saveAndOut.addTouchEventListener(this.btnControlGameFunc, this);
    329         }
    330         cc.log("endGame "+"  **********************************************************")
    331     },
    332     //按钮侦听函数
    333     btnControlGameFunc:function(target, state)
    334     {
    335         if(state == ccui.Widget.TOUCH_ENDED)//松开
    336         {
    337             switch (target.name)
    338             {
    339                 case "continueGame"://继续游戏
    340                     var newGameScene = TransitionScene.createScene(false);
    341                     cc.director.runScene(cc.TransitionFade.create(1, newGameScene));
    342                     cc.log("newGame");
    343                     break;
    344                         
    345                 case "save"://保存退出
    346                     var newGameScene = GameInitializeScene.createScene();
    347                     cc.director.runScene(cc.TransitionFade.create(1, newGameScene));
    348                     break;
    349                     
    350                 default:
    351                     break;
    352             }
    353         }
    354     },
    355     //初始化
    356     zinit:function()
    357     {
    358         this.size = cc.size(480, 500);
    359         GAMESTARLAYOUT = this;//对本类的引用对象
    360         //设置层的大小
    361         this.setSize(this.size);
    362         //将星星资源存放到数字中
    363         this.starArr = [
    364                         {id:1, normal:res.star1, selected:res.star1s},
    365                         {id:2, normal:res.star2, selected:res.star2s},
    366                         {id:3, normal:res.star3, selected:res.star3s},
    367                         {id:4, normal:res.star4, selected:res.star4s},
    368                         {id:5, normal:res.star5, selected:res.star5s},
    369                         {id:5, normal:res.star5, selected:res.star5s},
    370                         {id:5, normal:res.star5, selected:res.star5s},
    371                         {id:5, normal:res.star5, selected:res.star5s},
    372                         {id:5, normal:res.star5, selected:res.star5s},
    373                         {id:5, normal:res.star5, selected:res.star5s},
    374                         {id:5, normal:res.star5, selected:res.star5s},
    375                         {id:5, normal:res.star5, selected:res.star5s},
    376                         {id:5, normal:res.star5, selected:res.star5s},
    377                         {id:5, normal:res.star5, selected:res.star5s}
    378                         ];
    379         for(var i = 0; i < 10; i++)
    380         {
    381             this.starObjArr.push([]);
    382         }
    383         //开启侦听器,逐侦监听
    384         this.scheduleUpdate();
    385         this.playerGameData = playerGameData;//给玩家信息定义一个新的实例
    386         this.levelNumber = this.playerGameData.currentLevel;//玩家达到的关卡数
    387         //获得当前关卡的星星个数
    388         for(var i = 0; i < levelData.length; i++)
    389         {
    390             if(this.levelNumber == levelData[i].level)
    391             {
    392                 this.starNum = levelData[i].starNumber;
    393                 break;
    394             }
    395         }
    396     }
    397 });
    398 //实例化
    399 GameStarLayout.createLayout = function()
    400 {
    401     var starLayout = new GameStarLayout();
    402     return starLayout;
    403 };

     

    转载于:https://www.cnblogs.com/zfsSuperDream/p/4080947.html

    展开全文
  • 基于cocos2dx 2.2实现的《消灭星星》源代码,仅用于学习,请勿用于商业用途,否则后果自负。
  • 先来说下要实现的功能 根据一定规则生成关卡 ...StarRoot是一个空节点,后面创建的星星方块都会加到这个节点上 ActionRoot是一些做动作、动画节点的父节点,像comb特效就在这个节点上 UIRoot,就是用...
  • 引擎版本 Cocos2d-X v3.3 Cocos2d-X游戏源码 简易消灭星星游戏源码
  • Cocos2d-x 3.4 之 消灭星星 > 第二篇

    千次阅读 2015-05-24 22:42:13
    Cocos2d-x 3.4 之 消灭星星 > 第二篇 < > 星星 高亮状态 再次点击,消除 > 星星消除后,剩下的星星整合(下落或左移) > 检测是否有可消除的星星,没有则跳转到 游戏结束界面
  • Cocos2d-x 3.4 之 消灭星星 >前言+第一篇< > 游戏场景:星星地图 > 点击星星,处于选中状态
  • 这是在何自建博客上下载的源文件,稍加修改适应cocos2d-x 3.8.1后的。 http://blog.csdn.net/hezijian22/article/details/39137487这是他的博客地址
  • 一个游戏,声音也是非常的重要,其实cocos2dx里面的简单音效引擎的使用是非常简单的。我这里只不过是用一个类对所有的音效进行管理罢了。 Audio.h ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 #...
  • cocos2d-x 仿 消灭星星(满天星) 源码+解析

    千次阅读 多人点赞 2014-10-15 22:28:04
    cocos2d-x 仿 消灭星星(满天星) 源码+解析
  • 利用cocos2dx 3.2开发消灭星星(二)菜单(附素材)-附件资源
  • Cocos2d-x 3.4 之 消灭星星 >前言+第一篇附件资源
  • Cocos2d-x 3.4 之 消灭星星 > 第三篇(终) < > 粒子 > 音乐音效 > 漂浮文字 > combo特效 及 每关结束后星星的消除(小于等于10个的一个个消除,剩余的一齐消除) > 最高分存储、场景的简单存储 > 消除星星的Hint
  • 2 * 创建星星类(所有的星星都在这里创建,星星拥有的所有性都在这里实现) 3 */ 4 var GameCreateStar = ccui.ImageView.extend( 5 { 6 type:0,//星星的类型(不同数字代表不同颜色的星星); 7 normalType:...
  • cocos2dx小游戏源码(消灭星星

    万次阅读 热门讨论 2014-03-28 15:46:41
    才开始了解cocos2dx,为了练手,开发了一下消灭星星这款游戏,游戏资源在网上下载的,游戏也是参考自android平台消灭星星这款游戏。现提供游戏源码,已在android平台测试过,有兴趣的同学可以下载下来自己看看,欢迎...
  • 本课程以实战为主,游戏中需要什么功能,我们就讲解相应的知识点,这样学到的知识会马上用起来也就不会枯燥。 本课程讲解相当完整,从最基础的软件安装开始,到打出游戏安装包,到接入头条穿山甲广告SDK,一套完整的...
  • 2 * 本层拥有处理星星的实例化以及对星星的操作 3 */ 4 var GameStarLayout = ccui.Layout.extend( 5 { 6 size:null, 7 starArr:[],//存放点击与被点击状态的星星资源 8 starObjArr:[],//存放游戏中...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 163
精华内容 65
关键字:

cocos消灭星星