分享一个完整程序的代码(消除类游戏)

AppDelegate.cpp

#include "AppDelegate.h"

#include"WelcomeScene.h"

#include "SimpleAudioEngine.h"

using namespace CocosDenshion;

USING_NS_CC;

AppDelegate::AppDelegate() {

}

AppDelegate::~AppDelegate() 

{

}

void AppDelegate::initGLContextAttrs()

{

    GLContextAttrs glContextAttrs = {8, 8, 8, 8, 24, 8};

    GLView::setGLContextAttrs(glContextAttrs);

}

bool AppDelegate::applicationDidFinishLaunching() {

auto director = Director::getInstance();

auto glview = director->getOpenGLView();

<span style="white-space:pre"></span>if (!glview)

<span style="white-space:pre"></span>{

<span style="white-space:pre"></span>glview = GLViewImpl::create("Halloween");

<span style="white-space:pre"></span>director->setOpenGLView(glview);

<span style="white-space:pre"></span>glview->setFrameSize(360, 600);<span style="white-space:pre"></span>

<span style="white-space:pre"></span>}

    director->getOpenGLView()->setDesignResolutionSize(360, 600, ResolutionPolicy::EXACT_FIT);

<span style="white-space:pre"></span>

    FileUtils::getInstance()->addSearchPath("res");

auto scene = WelcomeScene::createScene();

    director->runWithScene(scene);

return true;

}

void AppDelegate::applicationDidEnterBackground() {

    Director::getInstance()->stopAnimation();

     SimpleAudioEngine::getInstance()->pauseBackgroundMusic();

<span style="white-space:pre"></span> 

}

void AppDelegate::applicationWillEnterForeground() {

    Director::getInstance()->startAnimation();

     SimpleAudioEngine::getInstance()->resumeBackgroundMusic();

}

Define.h

#pragma once

#define Screen_Width 360

#define Screen_Height 600

#define TOTAL_SPRITE 6

#define ROW 10

#define COL 6

#define SpriteWideth 48

#define BorderWideth 5

static const char * spriteNormal[10] =

{

"1.png",

"2.png",

"3.png",

"4.png",

"5.png",

"6.png",

"7.png",

"8.png",

"9.png",

"10.png",

};

GameScene.h

#pragma once

#include"cocos2d.h"

#include "cocostudio/CocoStudio.h"

#include "ui/CocosGUI.h"

#include"Define.h"

#include"SpriteShape.h"

USING_NS_CC;

class GameScene :public cocos2d::Layer

{

public:

static Scene * createScene();

virtual bool init();

virtual void onBackItemCallback(Ref * pSender);

void initMap();

void createSprite(int r, int c);

Vec2 PositionOfItem(int r, int c);

void update(float dt);

void checkAndRemoveSprite();

void getColChain(SpriteShape * spr, std::list<SpriteShape*>&chainList);

void getRowChain(SpriteShape * spr, std::list<SpriteShape*>&chainList);

void SpriteRemoveAction(SpriteShape *spr);

void markRemove(SpriteShape* spr);

void removeSprite();

void FillSprite();

bool onTouchBegan(cocos2d::Touch* touch, cocos2d::Event* evt);

void onTouchMoved(cocos2d::Touch* touch, cocos2d::Event* evt);

SpriteShape *spriteOfPoint(Vec2 *position);

void swapSprite();

void MyClock(float dr);

void gameOverCallback(Node *node);

CREATE_FUNC(GameScene);

private:

SpriteShape * map[ROW][COL];

bool isAction;

bool isFillSprite;

bool isTouchEnable;

bool isGameOver;

SpriteShape *startShape;

SpriteShape* endShape;

int m_score;

int m_time;

};

GameScene.cpp

#include"cocos2d.h"

#include"GameScene.h"

#include"WelcomeScene.h"

#include"SpriteShape.h"

#include"Define.h"

#include"SetScene.h"

#include "SimpleAudioEngine.h"

#pragma execution_character_set("utf-8")

using namespace CocosDenshion;

USING_NS_CC;

Scene* GameScene::createScene()

{

auto scene = Scene::create();

auto layer = GameScene::create();

scene->addChild(layer);

return scene;

}

bool GameScene::init()

{

if (!Layer::init())

{

return false;

}

SpriteFrameCache::getInstance()->addSpriteFramesWithFile("res/sucai.plist");

auto pDirector = Director::getInstance();

auto pSprite = Sprite::create("res/GameBackground.png");

pSprite->setPosition(Vec2(Screen_Width / 2, Screen_Height / 2));

this->addChild(pSprite);

auto setItem = MenuItemImage::create("res/back1.png", "res/back2.png", CC_CALLBACK_1(GameScene::onBackItemCallback, this));

setItem->setPosition(Vec2(Screen_Width / 2 , Screen_Height / 8-30));

auto menu = Menu::create(setItem, NULL);

menu->setPosition(Vec2::ZERO);

this->addChild(menu, 1);

this->scheduleUpdate();

auto touchListener = EventListenerTouchOneByOne::create();

touchListener->onTouchBegan = CC_CALLBACK_2(GameScene::onTouchBegan, this);

touchListener->onTouchMoved = CC_CALLBACK_2(GameScene::onTouchMoved, this);

_eventDispatcher->addEventListenerWithSceneGraphPriority(touchListener, this);

isAction = false;

isFillSprite = false;

isTouchEnable = true;

isGameOver = false;

m_score = 0;

m_time = 60;

initMap();

auto ptextScore = ui::Text::create(StringUtils::format("Score: %d",0), "res/marry.ttf", 25);

ptextScore->setTag(10);

ptextScore->setPosition(Vec2(Screen_Width/4,Screen_Height-20));

this->addChild(ptextScore);

auto ptextTime = ui::Text::create(StringUtils::format("Time: %d", 0), "res/marry.ttf", 25);

ptextTime->setTag(11);

ptextTime->setPosition(Vec2(Screen_Width / 4*3, Screen_Height - 20));

this->addChild(ptextTime);

if (SetScene::isMusicPlay)

SimpleAudioEngine::getInstance()->playBackgroundMusic("res/GameBackGround.wav", true);

auto pParticle = ParticleSnow::create();

this->addChild(pParticle);

schedule(schedule_selector(GameScene::MyClock),1.0f);

return true;

}

bool GameScene::onTouchBegan(cocos2d::Touch* touch, cocos2d::Event* evt)

{

startShape = NULL;

endShape = NULL;

if (isTouchEnable)

{

auto pos = touch->getLocation();

if (pos.x > 327 || pos.x < 39 || pos.y>519 || pos.y < 69)

return false;

startShape = spriteOfPoint(&pos);

if (startShape->getImgIndex() == 8)

{

Vec2 mapPos = PositionOfItem(startShape->getRow(), startShape->getCol());

auto pParticle = ParticleSystemQuad::create("res/leftrow.plist");

pParticle->setPosition(mapPos);

this->addChild(pParticle);

pParticle = ParticleSystemQuad::create("res/rightrow.plist");

pParticle->setPosition(mapPos);

this->addChild(pParticle);

int row = startShape->getRow();

for (int c = 0; c < COL; c++)

markRemove(map[row][c]);

removeSprite();

}

}

return isTouchEnable;

}

void GameScene::onTouchMoved(cocos2d::Touch* touch, cocos2d::Event* evt)

{

if (!startShape || !isTouchEnable)

return;

int row = startShape->getRow();

int col = startShape->getCol();

auto pos = touch->getLocation();

auto halfSpriteWideth = SpriteWideth / 2;

auto halfSpriteHeight = SpriteWideth / 2;

auto upRect = Rect(startShape->getPositionX() - halfSpriteWideth,

startShape->getPositionY() + halfSpriteHeight + BorderWideth,

SpriteWideth, SpriteWideth);

if (upRect.containsPoint(pos))

{

++row;

if (row < ROW)

{

endShape = map[row][col];

}

swapSprite();

return;

}

auto downRect = Rect(startShape->getPositionX() - halfSpriteWideth,

startShape->getPositionY() - halfSpriteHeight*3 - BorderWideth,

SpriteWideth, SpriteWideth);

if (downRect.containsPoint(pos))

{

--row;

if (row >=0)

{

endShape = map[row][col];

}

swapSprite();

return;

}

auto leftRect = Rect(startShape->getPositionX() - halfSpriteWideth*3-BorderWideth,

startShape->getPositionY() - halfSpriteHeight,

SpriteWideth, SpriteWideth);

if (leftRect.containsPoint(pos))

{

col--;

if (col >= 0)

{

endShape = map[row][col];

}

swapSprite();

return;

}

auto rightRect = Rect(startShape->getPositionX() + halfSpriteWideth+BorderWideth,

startShape->getPositionY() - halfSpriteHeight,

SpriteWideth, SpriteWideth);

if (rightRect.containsPoint(pos))

{

++col;

if (col < COL)

{

endShape = map[row][col];

}

swapSprite();

return;

}

}

void GameScene::swapSprite()

{

isFillSprite = false;

isTouchEnable = false;

if (!startShape || !endShape)

return;

Vec2 posOfScr = startShape->getPosition();

Vec2 posOfDes = endShape->getPosition();

float time = 0.2;

SpriteShape * temp=new SpriteShape();

temp = map[startShape->getRow()][startShape->getCol()];

map[startShape->getRow()][startShape->getCol()] = map[endShape->getRow()][endShape->getCol()];

map[endShape->getRow()][endShape->getCol()] = temp;

int tempRow = startShape->getRow();

int tempCol = startShape->getCol();

startShape->setRow(endShape->getRow());

startShape->setCol(endShape->getCol());

endShape->setRow(tempRow);

endShape->setCol(tempCol);

std::list<SpriteShape *>colChainListOfFirst;

getColChain(startShape, colChainListOfFirst);

std::list<SpriteShape *>rowChainListOfFirst;

getRowChain(startShape, rowChainListOfFirst);

std::list<SpriteShape *>colChainListOfSecond;

getColChain(endShape, colChainListOfSecond);

std::list<SpriteShape *>rowChainListOfSecond;

getRowChain(endShape, rowChainListOfSecond);

if (colChainListOfFirst.size() >= 3

|| rowChainListOfFirst.size() >= 3

|| colChainListOfSecond.size() >= 3

|| rowChainListOfSecond.size() >= 3

)

{

startShape->runAction(MoveTo::create(time, posOfDes));

endShape->runAction(MoveTo::create(time, posOfScr));

return;

}

else {

map[startShape->getRow()][startShape->getCol()] = endShape;

map[endShape->getRow()][endShape->getCol()] = startShape;

tempRow = startShape->getRow();

tempCol = startShape->getCol();

startShape->setRow(endShape->getRow());

startShape->setCol(endShape->getCol());

endShape->setRow(tempRow);

endShape->setCol(tempCol);

return;

}

}

SpriteShape *GameScene::spriteOfPoint(Vec2 *position)

{

SpriteShape *spr = NULL;

Rect rect = Rect(0, 0, 0, 0);

Size sz;

sz.height = SpriteWideth;

sz.width = SpriteWideth;

for (int r = 0; r < ROW; r++)

for (int c = 0; c < COL; c++)

{

spr = map[r][c];

if (spr)

{

rect.origin.x = spr->getPositionX() - (SpriteWideth / 2);

rect.origin.y = spr->getPositionY() - (SpriteWideth / 2);

rect.size = sz;

if (rect.containsPoint(*position))

{

return spr;

}

}

}

}

void GameScene::initMap()

{

for (int r = 0; r < ROW; r++)

for (int c = 0; c < COL; c++)

createSprite(r, c);

}

void GameScene::createSprite(int r, int c)

{

isAction = true;

isTouchEnable = false;

SpriteShape * spr = SpriteShape::create(r, c);

Vec2 endPosition = PositionOfItem(r, c);

Vec2 startPosition = Vec2(endPosition.x, endPosition.y + Screen_Height / 2);

spr->setPosition(startPosition);

float speed = startPosition.y / (1.2*Screen_Height);

spr->runAction(MoveTo::create(speed, endPosition));

this->addChild(spr);

map[r][c] = spr;

}

void GameScene::update(float dr)

{

if (isAction)

{

isAction = false;

for (int r = 0; r < ROW; r++)

for (int c = 0; c < COL; c++)

{

SpriteShape *spr = map[r][c];

if (spr&&spr->getNumberOfRunningActions()>0)

{

isAction = true;

isTouchEnable = false;

}

}

}

if (!isAction)

{

isTouchEnable = true;

if (isFillSprite)

{

if(!isGameOver)

FillSprite();

isFillSprite = false;

}

else

checkAndRemoveSprite();

}

auto pscore = (ui::Text*)this->getChildByTag(10);

pscore->setString(StringUtils::format("Score: %d", m_score));

}

void GameScene::MyClock(float dr)

{

m_time--;

if (m_time >=0)

{

auto ptime = (ui::Text*)this->getChildByTag(11);

ptime->setString(StringUtils::format("Time: %d", m_time));

}

if (m_time == 10)

SimpleAudioEngine::getInstance()->playEffect("res/daojishi.wav");

if (m_time == 0)

{

SimpleAudioEngine::getInstance()->pauseAllEffects();

SimpleAudioEngine::getInstance()->playEffect("res/timeover.wav");

auto overSprite = Sprite::create("res/GameOver.png");

overSprite->setPosition(Vec2(Screen_Width / 2 + 10, Screen_Height - 20));

overSprite->runAction(Sequence::create(MoveTo::create(3.0f, Vec2(Screen_Width / 2 + 10, Screen_Height / 2)),

CallFuncN::create(CC_CALLBACK_1(GameScene::gameOverCallback, this)), nullptr));

this->addChild(overSprite, 1);

isTouchEnable = false;

for (int r = 0; r < ROW; r++)

for (int c = 0; c < COL; c++)

{

markRemove(map[r][c]);

}

removeSprite();

isGameOver = true;

}

}

void GameScene::gameOverCallback(Node *node)

{

auto pDirector = Director::getInstance();

auto scene = WelcomeScene::createScene();

TransitionSplitCols * ptrans = TransitionSplitCols::create(1.0f, scene);

pDirector->replaceScene(ptrans);

}

void GameScene::FillSprite()

{

int colRemoveNumber[10] = { 0 };

SpriteShape *spr = NULL;

for (int c = 0; c < COL; c++)

{

int removeSpriteOfCol = 0;

for (int r = 0; r < ROW; r++)

{

spr = map[r][c];

if (spr == NULL)

removeSpriteOfCol++;

else

{

if (removeSpriteOfCol > 0)

{

int newRow = r - removeSpriteOfCol;

map[newRow][c] = spr;

map[r][c] = NULL;

Vec2 startPostion = spr->getPosition();

Vec2 endPosition = PositionOfItem(newRow, c);

float speed = (startPostion.y - endPosition.y) / Screen_Height * 3;

spr->stopAllActions();

spr->runAction(MoveTo::create(speed, endPosition));

spr->setRow(newRow);

}

}

}

colRemoveNumber[c] = removeSpriteOfCol;

}

for (int c = 0; c < COL; c++)

{

for (int r = ROW - colRemoveNumber[c]; r < ROW; r++)

{

createSprite(r, c);

}

}

}

void GameScene::checkAndRemoveSprite()

{

SpriteShape *spr = new SpriteShape();

for (int r = 0; r < ROW; r++)

for (int c = 0; c < COL; c++)

{

spr = map[r][c];

if (!spr)

continue;

if (spr->getIsNeedRemove())

continue;

std::list<SpriteShape*>colChainList;

getColChain(spr, colChainList);

if (colChainList.size() >= 3)

{

std::list<SpriteShape*>::iterator it;

for (it = colChainList.begin(); it != colChainList.end(); it++)

{

spr = (SpriteShape*)*it;

if (!spr)

continue;

markRemove(spr);

}

}

}

for (int c = 0; c < COL; c++)

for (int r = 0; r < ROW; r++)

{

spr = map[r][c];

if (!spr)

continue;

if (spr->getIsNeedRemove())

continue;

std::list<SpriteShape*>RowChainList;

getRowChain(spr, RowChainList);

if (RowChainList.size() >= 3)

{

std::list<SpriteShape*>::iterator rowit;

for (rowit = RowChainList.begin(); rowit != RowChainList.end(); rowit++)

{

spr = (SpriteShape*)*rowit;

if (!spr)

continue;

markRemove(spr);

}

}

}

removeSprite();

}

void GameScene::getColChain(SpriteShape * spr, std::list<SpriteShape*>&chainList)

{

chainList.push_back(spr);

int neiborRow = spr->getRow() - 1;

while (neiborRow >= 0)

{

SpriteShape * neiborSprite = map[neiborRow][spr->getCol()];

if (neiborSprite&&neiborSprite->getImgIndex() == spr->getImgIndex() && !neiborSprite->getIsNeedRemove())

{

chainList.push_back(neiborSprite);

neiborRow--;

}

else

break;

}

neiborRow = spr->getRow() + 1;

while (neiborRow <ROW)

{

SpriteShape * neiborSprite = map[neiborRow][spr->getCol()];

if (neiborSprite&&neiborSprite->getImgIndex() == spr->getImgIndex() && !neiborSprite->getIsNeedRemove())

{

chainList.push_back(neiborSprite);

neiborRow++;

}

else

break;

}

}

void GameScene::getRowChain(SpriteShape * spr, std::list<SpriteShape*>&chainList)

{

chainList.push_back(spr);

int neiborCol = spr->getCol() - 1;

while (neiborCol >= 0)

{

SpriteShape * neiborSprite = map[spr->getRow()][neiborCol];

if (neiborSprite&&neiborSprite->getImgIndex() == spr->getImgIndex() && !neiborSprite->getIsNeedRemove())

{

chainList.push_back(neiborSprite);

neiborCol--;

}

else

break;

}

neiborCol = spr->getCol() + 1;

while (neiborCol < COL)

{

SpriteShape * neiborSprite = map[spr->getRow()][neiborCol];

if (neiborSprite&&neiborSprite->getImgIndex() == spr->getImgIndex() && !neiborSprite->getIsNeedRemove())

{

chainList.push_back(neiborSprite);

neiborCol++;

}

else

break;

}

}

void GameScene::markRemove(SpriteShape* spr)

{

if (spr->getIsNeedRemove())

return;

spr->setIsNeedRemove(true);

}

void GameScene::removeSprite()

{

SpriteShape *spr = new SpriteShape();

for (int r = 0; r < ROW; r++)

for (int c = 0; c < COL; c++)

{

spr = map[r][c];

if (!spr)

continue;

if (spr->getIsNeedRemove())

{

SpriteRemoveAction(spr);

map[r][c] = NULL;

}

}

}

void GameScene::SpriteRemoveAction(SpriteShape *spr)

{

if(SetScene::isEffectPlay)

SimpleAudioEngine::getInstance()->playEffect("res/xiaochu.mp3");

m_score += 30;

isAction = true;

isTouchEnable = false;

auto pFadeIn = FadeOut::create(0.6);

auto pRotateBy = RotateBy::create(0.6f, 180);

auto pScaleBy = ScaleBy::create(0.6f, 0.5f);

spr->runAction(Spawn::create(pFadeIn, pRotateBy, pScaleBy, nullptr));

if (!isAction)

spr->removeFromParent();

isFillSprite = true;

}

Vec2 GameScene::PositionOfItem(int r,int c)

{

float x = (c + 1) * SpriteWideth + BorderWideth+10;

float y = (r + 1) * SpriteWideth + BorderWideth+40;

return Vec2(x, y);

}

void GameScene::onBackItemCallback(Ref * pSender)

{

auto pDirector = Director::getInstance();

auto scene = WelcomeScene::createScene();

TransitionSplitCols * ptrans = TransitionSplitCols::create(1.0f, scene);

pDirector->replaceScene(ptrans);

}

SetScene.h

#pragma once

#include"cocos2d.h"

#include "cocostudio/CocoStudio.h"

#include "ui/CocosGUI.h"

class SetScene :public cocos2d::Layer

{

public:

static cocos2d::Scene * createScene();

virtual bool init();

void onOpenMusicCallback(Ref * pSender);

void onCloseMusicCallback(Ref * pSender);

void onOpenEffectCallback(Ref * pSender);

void onCloseEffectCallback(Ref * pSender);

void onBackItemCallback(Ref * pSender);

static bool isEffectPlay;

static bool isMusicPlay;

CREATE_FUNC(SetScene);

};

SetScene.cpp

#include"cocos2d.h"

#include"SetScene.h"

#include"Define.h"

#include"WelcomeScene.h"

#include "SimpleAudioEngine.h"

using namespace CocosDenshion;

USING_NS_CC;

bool SetScene::isEffectPlay = true;

bool SetScene::isMusicPlay = true;

Scene* SetScene::createScene()

{

auto scene = Scene::create();

auto layer = SetScene::create();

scene->addChild(layer);

return scene;

}

bool SetScene::init()

{

if (!Layer::init())

{

return false;

}

cocos2d::Menu *menu;

auto pDirector = Director::getInstance();

auto pSprite = Sprite::create("res/Set.png");

pSprite->setPosition(Vec2(Screen_Width / 2, Screen_Height / 2));

this->addChild(pSprite);

auto openMusicItem = MenuItemImage::create("res/openMusic.png", "res/openMusic2.png", CC_CALLBACK_1(SetScene::onOpenMusicCallback, this));

openMusicItem->setPosition(Vec2(Screen_Width / 3 -20, Screen_Height / 3*2));

menu = Menu::create(openMusicItem, NULL);

menu->setPosition(Vec2::ZERO);

this->addChild(menu, 1);

auto closeMusicItem = MenuItemImage::create("res/closeMusic.png", "res/closeMusic2.png", CC_CALLBACK_1(SetScene::onCloseMusicCallback, this));

closeMusicItem->setPosition(Vec2(Screen_Width /3*2+20 , Screen_Height / 3*2));

menu = Menu::create(closeMusicItem, NULL);

menu->setPosition(Vec2::ZERO);

this->addChild(menu, 1);

auto openEffectItem = MenuItemImage::create("res/openEffect.png", "res/openEffect2.png", CC_CALLBACK_1(SetScene::onOpenEffectCallback, this));

openEffectItem->setPosition(Vec2(Screen_Width / 3-20 , Screen_Height / 3));

menu = Menu::create(openEffectItem, NULL);

menu->setPosition(Vec2::ZERO);

this->addChild(menu, 1);

auto closeEffectItem = MenuItemImage::create("res/closeEffect.png", "res/closeEffect2.png", CC_CALLBACK_1(SetScene::onCloseEffectCallback, this));

closeEffectItem->setPosition(Vec2(Screen_Width / 3*2+20, Screen_Height / 3));

menu = Menu::create(closeEffectItem, NULL);

menu->setPosition(Vec2::ZERO);

this->addChild(menu, 1);

auto bakcItem = MenuItemImage::create("res/back1.png", "res/back2.png", CC_CALLBACK_1(SetScene::onBackItemCallback, this));

bakcItem->setPosition(Vec2(Screen_Width / 2 + 10, Screen_Height / 8 - 30));

menu = Menu::create(bakcItem, NULL);

menu->setPosition(Vec2::ZERO);

this->addChild(menu, 1);

return true;

}

void SetScene::onOpenMusicCallback(Ref * pSender)

{

SimpleAudioEngine::getInstance()->resumeBackgroundMusic();

isMusicPlay = true;

}

void SetScene::onCloseMusicCallback(Ref * pSender)

{

SimpleAudioEngine::getInstance()->stopBackgroundMusic();

isMusicPlay = false;

}

void SetScene::onOpenEffectCallback(Ref * pSender)

{

isEffectPlay = true;

}

void SetScene::onCloseEffectCallback(Ref * pSender)

{

isEffectPlay = false;

}

void SetScene::onBackItemCallback(Ref * pSender)

{

auto pDirector = Director::getInstance();

auto scene = WelcomeScene::createScene();

TransitionTurnOffTiles * ptrans = TransitionTurnOffTiles::create(1.0f, scene);

pDirector->replaceScene(ptrans);

}

SpriteShape.h

#pragma once

#include"cocos2d.h"

#include "cocostudio/CocoStudio.h"

#include "ui/CocosGUI.h"

class SpriteShape :public cocos2d::Sprite

{

public:

SpriteShape();

static SpriteShape * create(int row, int col);

CC_SYNTHESIZE(int, m_row, Row);

CC_SYNTHESIZE(int, m_col, Col);

CC_SYNTHESIZE(int, m_imgIndex, ImgIndex);

CC_SYNTHESIZE(bool, m_isNeedRemove, IsNeedRemove);

CREATE_FUNC(SpriteShape);

};

SpriteShape.cpp

#include"cocos2d.h"

#include"SpriteShape.h"

#include"Define.h"

USING_NS_CC;

SpriteShape::SpriteShape() :m_isNeedRemove(false)

{

}

SpriteShape* SpriteShape::create(int row, int col)

{

SpriteShape *spr = new SpriteShape();

int randNum = rand() % 20;

spr->m_row = row;

spr->m_col = col;

if (randNum == 0)

{

spr->m_imgIndex = 8;

spr->initWithSpriteFrameName(spriteNormal[8]);

}

else

{

spr->m_imgIndex = rand() % TOTAL_SPRITE;

spr->initWithSpriteFrameName(spriteNormal[spr->m_imgIndex]);

}

spr->m_isNeedRemove = false;

spr->setRow(row);

spr->setCol(col);

spr->autorelease();

return spr;

}

WelcomeScene.h

#pragma once

#include"cocos2d.h"

#include "cocostudio/CocoStudio.h"

#include "ui/CocosGUI.h"

class WelcomeScene:public cocos2d::Layer

{

public:

static cocos2d::Scene * createScene();

virtual bool init();

virtual void onStartItemCallback(Ref * pSender);

virtual void onExitItemCallback(Ref * pSender);

virtual void onSetItemCallback(Ref * pSender);

CREATE_FUNC(WelcomeScene);

};

WelcomeScene.cpp

#include"cocos2d.h"

#include"WelcomeScene.h"

#include"GameScene.h"

#include"Define.h"

#include "SimpleAudioEngine.h"

#include"SetScene.h"

using namespace CocosDenshion;

USING_NS_CC;

Scene* WelcomeScene::createScene()

{

auto scene = Scene::create();

auto layer = WelcomeScene::create();

scene->addChild(layer);

return scene;

}

bool WelcomeScene::init()

{

if (!Layer::init())

{

return false;

}

cocos2d::Menu *menu;

auto pDirector = Director::getInstance();

auto pSprite = Sprite::create("res/Welcome.png");

pSprite->setPosition(Vec2(Screen_Width/2,Screen_Height/2));

this->addChild(pSprite);

auto pNormalSprite = Sprite::create("res/start.png");

auto pSelectedSprite = Sprite::create("res/start2.png");

pNormalSprite->setOpacity(220);

pNormalSprite->setScale(0.8f);

pSelectedSprite->setScale(0.8f);

auto StartItem = MenuItemSprite::create(pNormalSprite, pSelectedSprite, nullptr,

CC_CALLBACK_1(WelcomeScene::onStartItemCallback, this));

StartItem->setPosition(Vec2(Screen_Width/2 + 15,Screen_Height/6));

menu = Menu::create(StartItem, NULL);

menu->setPosition(Vec2::ZERO);

this->addChild(menu, 1);

auto exitItem = MenuItemImage::create("res/EXIT1.png", "res/EXIT2.png", CC_CALLBACK_1(WelcomeScene::onExitItemCallback, this));

exitItem->setPosition(Vec2(Screen_Width / 6*5+25, Screen_Height / 8));

menu = Menu::create(exitItem, NULL);

menu->setPosition(Vec2::ZERO);

this->addChild(menu, 1);

auto setItem = MenuItemImage::create("res/SET1.png", "res/SET2.png", CC_CALLBACK_1(WelcomeScene::onSetItemCallback, this));

setItem->setPosition(Vec2(Screen_Width / 8 -20, Screen_Height /8));

menu = Menu::create(setItem, NULL);

menu->setPosition(Vec2::ZERO);

this->addChild(menu, 1);

if(SetScene::isMusicPlay)

SimpleAudioEngine::getInstance()->playBackgroundMusic("WelcomeBackground.mp3", true);

auto pParticle = ParticleSystemQuad::create("res/fire.plist");

pParticle->setPosition(Vec2(Screen_Width / 2, 0));

this->addChild(pParticle);

return true;

}

void WelcomeScene::onStartItemCallback(Ref * pSender)

{

auto pDirector = Director::getInstance();

auto scene = GameScene::createScene();

TransitionPageTurn * ptrans = TransitionPageTurn::create(1.0f, scene, true);

pDirector->replaceScene(ptrans);

SimpleAudioEngine::getInstance()->playEffect("res/WelcomeToGame.wav");

}

void WelcomeScene::onSetItemCallback(Ref * pSender)

{

auto pDirector = Director::getInstance();

auto scene =SetScene::createScene();

TransitionPageTurn * ptrans = TransitionPageTurn::create(1.0f, scene, true);

pDirector->replaceScene(ptrans);

}

void WelcomeScene::onExitItemCallback(Ref * pSender)

{

Director::getInstance()->end();

}

ok!!! 

复制粘贴都很多啊~~自己慢慢研究把，图片声音资源似乎不能上传啊，需要的留言把

主界面：

游戏界面：

相关知识

分享一个完整程序的代码(消除类游戏)
Scratch实现植物大战僵尸游戏：完整代码与素材包分享
卡片消除游戏 java版（代码+讲解）
消花朵的游戏都有哪些 热门的花朵消除游戏分享2025
【挑战一天一个程序】生日祝福代码
JAVA表白浪漫烟花效果代码
绽放花朵消除类的游戏有哪些 热门的消除游戏大全2023
从基本游戏设计的角度浅析消除类游戏
趣味插花消除游戏下载2024 热门的插花消除游戏合集
【Python表白系列】制作一个无法拒绝的表白界面（完整代码）

网址: 分享一个完整程序的代码(消除类游戏) https://www.huajiangbk.com/newsview1752962.html