使用coco2dx3.5制作游戏2048

最新推荐文章于 2023-10-09 17:11:34 发布
最新推荐文章于 2023-10-09 17:11:34 发布
阅读量1.1k 收藏 1
点赞数 1
分类专栏： python cocos2dx 文章标签： cocos2d eclipse vs2012 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/swordfishx82/article/details/45305813
版权

昨天在网上看到了一个大神在mac下写的2048算法，看后觉得很长见识，算法什么的我最头痛了，看了源码之后，自己建了了项目移植到windows的vs2012下，改的地方很少，主要就是mac和win下的转码问题，这里贴出来，并讲讲如何在windows下移植到安卓下。

先建个工程，然后

#include"MovedTiled.h"

bool MovedTiled:: init(){
	if (!Node::init())
	{
		return false;
	}
	   //背景层
    auto bk=LayerColor::create(Color4B(200, 200, 200, 255),GAME_TILED_WIDTH,GAME_TILED_HEIGHT);
    this->addChild(bk);
    bk->setTag(110);
    //数字层
    int n=rand()%10;
    this->m_number=n>2?2:4;
    auto label=Label::createWithSystemFont(StringUtils::format("%d",this->m_number), "宋体", 40);

    switch (this->m_number) {
        case 2:
            bk->setColor(Color3B(230,220,210));
        case 4:
            bk->setColor(Color3B(230,210,190));
            break;
    }
    label->setTag(10);
    label->setColor(Color3B::BLACK);
    bk->addChild(label);
    label->setPosition(Point(
                       GAME_TILED_WIDTH/2
                       ,GAME_TILED_HEIGHT/2));
    
		return true;

}
//让这个值翻倍
void MovedTiled::doubleNumber(){
	this->m_number=this->m_number*2;
	auto bk=this->getChildByTag(110);
	Label *label=(Label *)bk->getChildByTag(10);
	label->setString(StringUtils::format("%d",m_number));
	 //动画
    bk->runAction(
                Sequence::create(
                        ScaleTo::create(0.2, 0.8),
                        ScaleTo::create(0.2, 1.2),
                        ScaleTo::create(0.2, 1)
                                   , NULL));
    
    switch (this->m_number) {
        case 2:
            bk->setColor(Color3B(230,220,210));
            
        case 4:
            bk->setColor(Color3B(230,210,190));
            break;
        case 8:
            bk->setColor(Color3B(230,150,100));
            label->setColor(Color3B(255,255,255));
            break;
        case 16:
            bk->setColor(Color3B(230,120,80));
            label->setColor(Color3B(255,255,255));
            break;
        case 32:
            bk->setColor(Color3B(230,100,90));
            label->setColor(Color3B(255,255,255));
            break;
        case 64:
            bk->setColor(Color3B(230,70,60));
            label->setColor(Color3B(255,255,255));
            break;
        case 128:
            bk->setColor(Color3B(230,190,60));
            label->setColor(Color3B(255,255,255));
            break;
        case 256:
            bk->setColor(Color3B(230,190,60));
            label->setColor(Color3B(255,255,255));
            break;
        case 512:
            bk->setColor(Color3B(230,190,60));
            label->setColor(Color3B(255,255,255));
            break;
        case 1024:
        case 2048:
            label->setScale(0.5);
            bk->setColor(Color3B(210,180,30));
            label->setColor(Color3B(255,255,255));
    }
}
//在某个位置显示这个块
void  MovedTiled::showAt(int r,int c){
	   moveTo( r,c);
    //动画
    auto bk=this->getChildByTag(110);
    bk->runAction(
                  Sequence::create(
             ScaleTo::create(0.2, 0.8),
             ScaleTo::create(0.2, 1.2),
             ScaleTo::create(0.2, 1)
                                   , NULL));
        

}
	//移动到r行，c列
void  MovedTiled:: moveTo(int r,int c){
	
	 this->m_row=r;
    this->m_col=c;
    this->setPosition(Point(m_col*GAME_TILED_WIDTH+GAME_TILED_BOARD_WIDTH*(m_col+1),
                    m_row*GAME_TILED_HEIGHT+
        GAME_TILED_BOARD_WIDTH*(m_row+1)));
    CCLOG("%f,%f",this->getPositionX(),this->getPositionY());
}


#include"GameScene.h"
#include "gamedefine.h"
#include "GameOver.h"
#include "SimpleAudioEngine.h"
using namespace CocosDenshion;
bool GameScene::init(){
	if (!Layer::init())
	{
		return false;
	}
	//初始化游戏标题
	auto labelGame=Label::createWithBMFont("fonts/futura-48.fnt","2048");
	labelGame->setPosition(Point(labelGame->getContentSize().width/2,GAME_SCREEN_HEIGHT-labelGame->getContentSize().height/2));
	labelGame->setScale(0.5f);
	this->addChild(labelGame);
	//初始化网格
	int tiledmapwidth=GAME_TILED_WIDTH*GAME_COLS+GAME_TILED_BOARD_WIDTH*(GAME_COLS+1);
	int tiledmapheight=GAME_TILED_HEIGHT*GAME_ROWS+GAME_TILED_BOARD_WIDTH*(GAME_ROWS+1);
	//auto colorBack=LayerColor::create(Color4B(160,200,150,255),tiledmapwidth,tiledmapheight);
	 colorBack=LayerColor::create(Color4B(160,200,150,255),tiledmapwidth,tiledmapheight);
	//colorBack->setAnchorPoint(Point(colorBack->getContentSize().width/2,colorBack->getContentSize().height/2));
	colorBack->setPosition(Point((GAME_SCREEN_WIDTH-tiledmapwidth)/2,(GAME_SCREEN_HEIGHT-tiledmapheight)/2));
	
	this->addChild(colorBack);
	//初始化分数
	m_score=0;
		//初始化分数标题
	auto labelScore=Label::createWithBMFont("fonts/futura-48.fnt","Score:0");
    labelScore->setPosition(Point(GAME_SCREEN_WIDTH/2,GAME_SCREEN_HEIGHT-labelGame->cocos2d::Node::getContentSize().height));
    this->addChild(labelScore);
	labelScore->setTag(120);
    labelScore->setScale(0.8);
	//初始化网格的每一个块
	
	 for (int row=0; row<GAME_ROWS; row++) {
        for (int col=0; col<GAME_COLS; col++) {
            auto layerTiled=LayerColor::create(Color4B(70, 70, 70, 255),
                GAME_TILED_WIDTH,
                GAME_TILED_HEIGHT);
            layerTiled->setPosition(
                Point(GAME_TILED_WIDTH*col+
                      GAME_TILED_BOARD_WIDTH*(col+1),
                      GAME_TILED_HEIGHT*row+
                      GAME_TILED_BOARD_WIDTH*(row+1)));
            colorBack->addChild(layerTiled);
        }
    }

	//初始化逻辑网格数组
	
	  for(int i=0;i<GAME_ROWS;i++)
    {
     for(int j=0;j<GAME_COLS;j++)
        {
        map[i][j]=0; //空白
        }
    }
	//初始化数字块
	newMovedTiled();
	
	//触摸的处理
	auto event=EventListenerTouchOneByOne::create();
	event->onTouchBegan=[&](Touch*tou,Event*eve){
		m_x=tou->getLocation().x;
		m_y=tou->getLocation().y;
		m_startMove=true;
	return true;
	};
	event->onTouchMoved=[&](Touch*tou,Event*eve){
		int x=tou->getLocation().x;
		int y=tou->getLocation().y;
		if(m_startMove&&(abs(m_x-x)>10||abs(m_y-y)>10)){
			m_startMove=false;
			E_MOVE_DIR dir;
			if(abs(m_x-x)>abs(m_y-y)){
				if(m_x<x){
					dir=E_MOVE_DIR::RIGHT;
				}else
				{
					dir=E_MOVE_DIR::LEFT;
				}
			}else
			{
				if(m_y<y){
					dir=E_MOVE_DIR::UP;
				}else
				{
					dir=E_MOVE_DIR::DOWN;
				}
			}
			moveAllTiled(dir);


		}
	};
	Director::getInstance()->getEventDispatcher()->addEventListenerWithSceneGraphPriority(event,this);
	//分数
	return true;
}
void GameScene::moveAllTiled(E_MOVE_DIR dir){
	//移动所有的块
	m_sound_clear=false;
	switch (dir)
	{
	case E_MOVE_DIR::UP:
		moveup();
		break;
	case E_MOVE_DIR::DOWN:
		moveDown();
		break;
	case E_MOVE_DIR::LEFT:
		moveleft();
		break;
	case E_MOVE_DIR::RIGHT:
		moveright();
		break;
	default:
		break;
	}

	//播放音乐
	  if(m_sound_clear)
    {
     SimpleAudioEngine::getInstance()->playEffect("moveClear.wav");
    }else
    {
     SimpleAudioEngine::getInstance()->playEffect("move1.wav");
    }
	//分数变化
	 Label * labelScore=(Label *)this->getChildByTag(120);
    labelScore->setString(StringUtils::format("score:%d",m_score));
	//判定输赢
	//产生新的块
	newMovedTiled();

}
void GameScene::newMovedTiled(){
	
	auto tiled=MovedTiled::create();

    int freeCount=16-m_allTiled.size();
	 if(freeCount==0)//没有空白区域
        {//判定游戏输赢
            //上 ，下 左 右 是否还能移动
            for(int r=0;r<GAME_ROWS;r++)
                {
                for(int c=0;c<GAME_COLS;c++)
                    {  //第r行 第c列的数值
                        int num=m_allTiled.at(map[r][c]-1)->m_number;
                        int objNum=0;
                        //上
                        if(r+1<GAME_ROWS)
                            {
                            objNum=m_allTiled.at(map[r+1][c]-1)->m_number;
                            if(num==objNum)
                                {return ;}
                            }
                        //下
                        if(r-1>=0)
                            {
                            objNum=m_allTiled.at(map[r-1][c]-1)->m_number;
                            if(num==objNum)
                                {return ;}
                            }
                        //左
                        if(c-1>=0)
                            {
                            objNum=m_allTiled.at(map[r][c-1]-1)->m_number;
                            if(num==objNum)
                                {return ;}
                            }
                        //右
                        if(c+1<GAME_COLS)
                            {
                            objNum=m_allTiled.at(map[r][c+1]-1)->m_number;
                            if(num==objNum)
                                {return ;}
                            }
                        
                    }
                }
            //跳转场景
            auto scene=GameOver::createScene();
            Director::getInstance()->replaceScene(TransitionFadeDown::create(0.5, scene));
            
            return;
        }
    int num=rand()%freeCount;

    int row=0;

    int col=0;

    int count=0;

    bool find=false;

    for (; row<GAME_ROWS; row++) {

       for(col=0;col<GAME_COLS;col++)

        { if(map[row][col]==0)

          {

           count++;//记录空白的数量

           if(count>=num)

           {

            find=true;

            break;

           }

         

          }

        }

        if (find) {

           break;

        }

    }
		colorBack->addChild(tiled);
    tiled->showAt(row, col);
    m_allTiled.pushBack(tiled);
    map[row][col]=m_allTiled.getIndex(tiled)+1;
	
 


}
void GameScene::moveup(){
	CCLOG("moveup");
	//向上移动所有的块
	for (int col=0; col <GAME_COLS ;col++)
	{
		for (int row=GAME_ROWS-1;row>=0; row--)
		{
			if(map[row][col]>0){
				for (int row1 =row; row1 < GAME_ROWS-1; row1++)
				{
					if(map[row1+1][col]==0){
						map[row1+1][col]=map[row1][col];
						map[row1][col]=0;
						m_allTiled.at(map[row1+1][col]-1)->moveTo(row1+1,col);
					}else
					{//判断是否可以消除
						 int numObj=m_allTiled.at(map[row1+1][col]-1)->m_number;
                int numNow=m_allTiled.at(map[row1][col]-1)->m_number;
				if(numObj==numNow){
					//map[row1][col]=0;
					m_sound_clear=true;
					   m_score+=numObj*2;
					m_allTiled.at(map[row1+1][col]-1)->doubleNumber();
					m_allTiled.at(map[row1][col]-1)->removeFromParent();
					int index=map[row1][col];
					//消除最前面的
					m_allTiled.erase(map[row1][col]-1);
					for (int r = 0; r < GAME_ROWS; r++)
					{
						for (int c = 0; c < GAME_COLS; c++)
						{
							if(map[r][c]>index){
								map[r][c]--;
							}
						}
					}
					 map[row1][col]=0;

				}
						
						break;
					}
				}
			}
		}
	
	}

	

   
  
}
void GameScene::moveDown(){
	CCLOG("movedown");

	for (int col=0; col<GAME_COLS; col++) {
        for(int row=0;row<GAME_ROWS;row++)
            {
            if(map[row][col]>0)
                {
                for(int row1=row;row1>0;row1--)
                    {
                    if(map[row1-1][col]==0)
                        {
                        map[row1-1][col]=map[row1][col];
                        map[row1][col]=0;
                        m_allTiled.at(map[row1-1][col]-1)->moveTo(row1-1, col);
                        }
                    else
                        {//判断，是否可以消除
                            
                            int numObj=m_allTiled.at(map[row1-1][col]-1)->m_number;
                            int numNow=m_allTiled.at(map[row1][col]-1)->m_number;
                            if(numObj==numNow)
                                {
                                m_sound_clear=true;
                                m_score+=numObj*2;
                                m_allTiled.at(map[row1-1][col]-1)->doubleNumber();
                                m_allTiled.at(map[row1][col]-1)->removeFromParent();
                                int index=map[row1][col];
                                m_allTiled.erase(map[row1][col]-1);
                                for (int r=0; r<GAME_ROWS; r++)
                                    {
                                    for (int c=0; c<GAME_COLS; c++) {
                                        if(map[r][c]>index)
                                            {map[r][c]--;
                                            }
                                    }
                                    }
                                map[row1][col]=0;
                                }
                            break;
                        }
                    }
                }
            }
    }
	


}
void GameScene::moveleft(){
	CCLOG("moveleft");
	for (int row=0; row<GAME_ROWS; row++) {
        for(int col=0;col<GAME_COLS;col++)
           {
            if(map[row][col]>0)
                {
                for(int col1=col;col1>0;col1--)
                    {
                    if(map[row][col1-1]==0)
                        {
                        map[row][col1-1]=map[row][col1];
                        map[row][col1]=0;
                        m_allTiled.at(map[row][col1-1]-1)->moveTo(row, col1-1);
                        }
                    else
                        {//判断，是否可以消除
                            
                            int numObj=m_allTiled.at(map[row][col1-1]-1)->m_number;
                            int numNow=m_allTiled.at(map[row][col1]-1)->m_number;
                            if(numObj==numNow)
                                {
                                  m_sound_clear=true;
                                 m_score+=numObj*2;
                                m_allTiled.at(map[row][col1-1]-1)->doubleNumber();
                                m_allTiled.at(map[row][col1]-1)->removeFromParent();
                                int index=map[row][col1];
                                m_allTiled.erase(map[row][col1]-1);
                                for (int r=0; r<GAME_ROWS; r++)
                                    {
                                    for (int c=0; c<GAME_COLS; c++) {
                                        if(map[r][c]>index)
                                            {map[r][c]--;
                                            }
                                    }
                                    }
                                map[row][col1]=0;
                                }
                            break;
                        }
                    }
                }
            }
    }
	
}
void GameScene::moveright(){
	CCLOG("moveright");
	 for (int row=0; row<GAME_ROWS; row++) {
        for(int col=GAME_COLS-1;col>=0;col--)
            {
            if(map[row][col]>0)
                {
                for(int col1=col;col1<GAME_COLS-1;col1++)
                    {
                    if(map[row][col1+1]==0)
                        {
                        map[row][col1+1]=map[row][col1];
                        map[row][col1]=0;
                        m_allTiled.at(map[row][col1+1]-1)->moveTo(row, col1+1);
                        }
                    else
                        {//判断，是否可以消除
                            
                            int numObj=m_allTiled.at(map[row][col1+1]-1)->m_number;
                            int numNow=m_allTiled.at(map[row][col1]-1)->m_number;
                            if(numObj==numNow)
                                {
                                 m_sound_clear=true;
                                 m_score+=numObj*2;
                                m_allTiled.at(map[row][col1+1]-1)->doubleNumber();
                                m_allTiled.at(map[row][col1]-1)->removeFromParent();
                                int index=map[row][col1];
                                m_allTiled.erase(map[row][col1]-1);
                                for (int r=0; r<GAME_ROWS; r++)
                                    {
                                    for (int c=0; c<GAME_COLS; c++) {
                                        if(map[r][c]>index)
                                            {map[r][c]--;
                                            }
                                    }
                                    }
                                map[row][col1]=0;
                                }
                            break;
                        }
                    }
                }
            }
    }
	

}
Scene*GameScene::createScene(){
	auto scene=Scene::create();
	auto layer=GameScene::create();
	scene->addChild(layer);
	return scene;

}

核心代码就这些，虽然少但却不算简单，其他地方很简单就不贴了，后面我会贴出代码。下载地址

这里就不多说编译的事了，我这里讲讲如何移植到安卓下，首先环境变量设置运行coco2dx下的setup.py

打开eclipse

导入项目，如图打开之后选择安卓版本，拷贝这个目录下的java文件到

拷贝之后，修改mk文件用ecplise开发过c++的小伙伴应该很熟悉这种方法，当然可以在命令行下输入编译命令，但没有这种方法简单，编译成功了

刷新一下修改一下横竖屏



因为手机屏幕分辨率尺寸跟游戏代码的设定尺寸差好多，需要的自己编译修改下吧。


简雨
关注
专栏目录
cocos2d制作的2048游戏源码及素材
10-23
用cocos2d制作的2048游戏源码，用的版本是3.x版本，加压后直接加载进去Classes中的代码，替换掉原来的资源文件，然后自己冲洗编译一下就可以了
试用Cocostudio制作游戏UI
u011698816的专栏
04-20 1112
UI的可视化制作可以大大减少游戏开发
Cocos2d-x 3.x制作2048
04-21
详细介绍 基于coco2d-x 3.0开发的2048，内容详细，代码整洁，适合学习。
【CocoStudio游戏开发之一】制作多分辨率UI布局
Teng's world
04-08 3745
如何快速地制作UI, 是开发游戏时不得不面临的问题. Cocos2d-x 经历了1.0时代的固定位置, 2.0时代的相对位置, 在3.0时代引入了全新的GUI机制. 新的GUI机制, 类似于Android的GUI系统, 功能强大但如果手动编码来实现就很繁琐. CocoStudio对Cocos2d-x的新的GUI系统进行了全面的支持, 可以让大家在快速开发UI的同时也享受到Cocos2d-x强大
cocos-js小游戏2048游戏源码以及素材
03-18
cocos-js原生小游戏2048游戏源码以及全套素材资源，可以查看预览运行效果。
coco2dx跑酷游戏源码-paoKu2
12-07
coco2dx跑酷游戏源码-paoKu2 cocos精品小游戏源码 , 完整项目源码 是整个项目的压缩包 , 新建空项目直接导入到项目里面就可以运行了,无需其他操作。 适合二次开发和学习使用,都是经典游戏,需要其他游戏源码包可以...
基于COCO2DX的高仿消除游戏Dots
07-11
《基于COCO2DX的高仿消除游戏Dots》是一款使用Cocos2d-x框架开发的、模仿经典消除玩法的游戏。Cocos2d-x是一个跨平台的2D游戏开发框架，广泛应用于Android、iOS以及其他操作系统，以C++为核心语言，同时也支持Lua和...
coco2dx跑酷游戏源码
09-22
《coco2dx跑酷游戏源码》是一个基于Cocos2d-x框架...通过分析和学习这个coco2dx跑酷游戏源码，开发者不仅可以提升Cocos2d-x的使用技能，还能对游戏开发流程和设计原则有更深入的理解，为自己的游戏项目打下坚实的基础。
vscode-coco2dx-lua-api.7z
07-27
《使用VSCode高效开发Cocos2d-x Lua项目——基于"vscode-coco2dx-lua-api.7z"的工具解析与应用》 在现代游戏开发领域，Cocos2d-x作为一款广泛使用的跨平台游戏引擎，为开发者提供了丰富的功能和高效的性能。而在...
coco2dx游戏源码 50多种
10-22
coco2dx游戏源码 50多种
cocos2d-x 2048小游戏源码+素材
05-25
cocos2d-x 2048小游戏源码+素材
cocos2d-x-3.5旧版引擎下载
09-17
cocos2d-x-3.5下载，不多说。或者可以下载另一个资源 cocos引擎老版本集合（cocos2d-x-2.2.1 - 3.5） http://download.csdn.net/download/crazymagicdc/9982656
基于cocos2dx平台的2048游戏
06-13
基于cocos2dx平台的2048游戏，可以更改Resource里面的xml文件来定义想要显示的文字，可以自定义声音
coco2d-X 游戏资源合集。
12-11
coco2d-X 游戏资源合集 适合新手练手学习之用，不可以做商业用途。 coco2d-X 游戏资源合集 适合新手练手学习之用，不可以做商业用途。
Cocos2djs-2048:基于cocos2djs 引擎实现的2048小游戏
07-12
Cocos2djs-2048 基于cocos2djs 引擎实现的2048小游戏 由于cocos2djs 的framework代码太大，这里只放我编写的源码部分，可下载源码后放到cocos的环境下即可运行。 License Cocos2djs-2048 is licensed under the
cocos2d-x 3.2 之 2048——前言
继续激情，继续奋斗。
09-28 2432
cocos2d-x 3.2 2048开发教程
Coco2d-x 塔防游戏“贼来了”之开发简档 之 三（完结）
weixin_34252686的博客
05-28 120
原来的教程为《塔防游戏之贼来了》（这是我之前学习Cocos2d-x时候，看到的一个比较好的教程）原文地址目前只在泰然网看到，http://www.tairan.com/archives/6413 ，原作者为任珊。本文是基于这个教程，而编写的游戏开发简档，有了这些图表，你就可以轻松的开发出这款游戏了。最后，如果你能画出类图的话，写代码就不成问题了。不过在写代码的时候，可...
用Cocos2d编写一个简单的2048游戏
最新发布
WeCapture的博客
10-09 262
通过Cocos2d强大的图形渲染和动画效果，我们可以轻松实现一个具有可玩性的2048游戏。当然，以上代码只是一个简单的示例，实际的游戏逻辑和界面设计还需要根据需求进行进一步的开发和完善。这部分的代码比较复杂，涉及到判断方块是否可以移动和合并，以及更新方块的位置和数字等。接下来，我们创建一个新的场景，并初始化游戏的一些基本元素，比如游戏面板、方块等。2048游戏是一款非常受欢迎的数字拼图游戏，目标是通过合并相同的数字方块，最终达到2048这个数字。在场景的初始化方法中，我们初始化了游戏面板和方块精灵。
Cocos2d-x 3.x版2048游戏开发
热门推荐
巫山老妖
07-27 1万+
Cocos2d-x 3.x版2048游戏开发 本篇博客给大家介绍如何快速开发2048这样一款休闲游戏，理解整个2048游戏的开发流程，从本篇博客你将可以学习到以下内容：2048游戏的逻辑Cocos2d-x中上下左右手势的识别游戏中卡片类的创建添加卡片到游戏中游戏中的逻辑实现游戏中随机卡片的生成游戏结束判断游戏分数的添加游戏美化笔者的开发环境：Cocos2d-x 3.1.1（开发引擎）Visual
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值