示例#1
0
bool GamePlay::init() {
	if (!Layer::init()) {
		return false;
	}

	gameState = Ready;
	visibleSize = Director::getInstance()->getVisibleSize();
	getSoundMusic();

	//load game AI
	//init array number and computation
	int ARRAY_NUMBER[9] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	arrNum = gameAI->randomNumber(ARRAY_NUMBER, SUM_NUM);
	for (int i = 0; i < SUM_NUM; i++) {
		arrNUM[i] = arrNum[i];
	}
	char s[SUM_COM] = "";
	//TODO change level
//	arrCOM = gameAI->randomComputation(s, SUM_COM,
//			GamePlay::instance()->getLevel() >= 2 ? 2 : 3);
	arrCOM = gameAI->randomComputation(s, SUM_COM, 2);
	for (int i = 0; i < SUM_COM; i++) {
		arrCOMPUTATE[i] = arrCOM[i];
	}
	for (int i = 0; i < SUM_COM / 2; i++) {
		tempResult[i] = INIT_FRAME;
	}

	int arr[GamePlay::instance()->getLevel()];
	int* arrayLevel = gameAI->randomLessNumber(arr,
			GamePlay::instance()->getLevel());

	//load background
	auto bg = Sprite::create("background.png");
	bg->setAnchorPoint(Vec2(0, 0));
	bg->setPosition(Vec2(0, 0));
	this->addChild(bg, -1);
	float rX = visibleSize.width / bg->getContentSize().width;
	float rY = visibleSize.height / bg->getContentSize().height;
	bg->setScaleX(rX);
	bg->setScaleY(rY);

	//show logo game
	Sprite *logoGame = Sprite::create("smalllogo.png");
	logoGame->setAnchorPoint(Vec2(0.0, 1.0));
	logoGame->setPosition(Vec2(PADDING, visibleSize.height - PADDING));
	logoGame->setTag(TAG_LOGO);
	logoGame->setScale(0.6f);
	this->addChild(logoGame);

	//load frame ready
	float baseY = logoGame->getPositionY()
			- logoGame->getBoundingBox().size.height - PADDING;
	float baseX = PADDING / 2;
	for (int i = 0; i < SUM_NUM; i++) {
		frameReady[i] = Sprite::create("frame.png");
		float width = frameReady[i]->getContentSize().width;
		float height = frameReady[i]->getContentSize().height;
		frameReady[i]->setTag(TAG_START_READY_POINT + i);
		frameReady[i]->setPositionX(baseX + 5.0 / 8.0 * i * width + width / 2);
		if (i % 2 == 0) {
			frameReady[i]->setPositionY(baseY - height / 2);
		} else {
			frameReady[i]->setPositionY(baseY - height);
		}
		this->addChild(frameReady[i]);
	}

	//create frame play
	float paddingY = 0;
	float paddingX = 0;
	for (int i = 0; i < SUM_NUM; i++) {
		float baseX = PADDING;
		framePlay[i] = TouchSprite::create("frame.png");
		framePlay[i]->setTag(TAG_FRAME_PLAY + i);
		paddingX = (visibleSize.width - PADDING * 4
				- framePlay[i]->getContentSize().width) / 3.0;
		framePlay[i]->setPositionX(
				PADDING + framePlay[i]->getContentSize().width / 2
						+ paddingX * (i % 3));

		float baseY = frameReady[0]->getPositionY();
		if (i % 3 == 0)
			paddingY = paddingX * ((int) i / 3 + 1);
		framePlay[i]->setPositionY(baseY - paddingY);
		framePlay[i]->score = 0;
		framePlay[i]->isFixed = false;
		for (int j = 0; j < GamePlay::instance()->getLevel(); j++) {
			if (arrNum[i] == arrayLevel[j]) {
				framePlay[i]->score = arrNum[i];
				//TODO
				framePlay[i]->isFixed = true;
				framePlay[i]->setDisplayFrame(
						SpriteFrame::create(
								"frame" + std::to_string(arrNum[i]) + ".png",
								framePlay[i]->getTextureRect()));
			}
		}
//		CCLog("frameplay[%d] = %d", i, framePlay[i]->score);
		this->addChild(framePlay[i]);
	}

	//load number button
	//TODO
	std::string name = "number";
	MoveTo* actionBy;
	int k = 0;
	for (int i = 0; i < SUM_NUM; i++) {
		numberBtn[i] = TouchSprite::create(
				name + std::to_string(i + 1) + ".png");
		numberBtn[i]->setTag(TAG_NUMBER + i);
		numberBtn[i]->setPositionY(visibleSize.height + 3 * PADDING);
		numberBtn[i]->setPositionX(frameReady[i]->getPositionX());
		numberBtn[i]->setZOrder(10);
		numberBtn[i]->isHidden = false;
		this->addChild(numberBtn[i]);
		actionBy = MoveTo::create(0.4, frameReady[i]->getPosition());
		auto easeAction = EaseBounceInOut::create(actionBy);

		for (int j = 0; j < GamePlay::instance()->getLevel(); j++) {
			if ((i + 1) == arrayLevel[j]) {
				numberBtn[i]->isHidden = true;
				numberBtn[i]->setVisible(false);
			}
		}

		if (numberBtn[i]->isHidden == false) {
			auto delay = DelayTime::create(0.2 * (k + 1));
			auto sequence = Sequence::create(delay, easeAction, nullptr);
			numberBtn[i]->runAction(sequence);
			k++;
		}
	}

	if (frameReady != NULL) {
		for (int i = 0; i < SUM_NUM; i++)
			frameReady[i]->setVisible(false);
	}

	//create result frame and equal character
	Sprite* frameEqual[SUM_COM / 2];
	Sprite* characterEqual[SUM_COM / 2];
	for (int i = 0; i < SUM_COM / 2; i++) {
		characterEqual[i] = Sprite::create("icon_equal.png");
		frameEqual[i] = Sprite::createWithTexture(frameReady[i]->getTexture());
		frameEqual[i]->setTag(TAG_FRAME_EQUAL + i);
		if (i % 2 == 0) {
			//frame equal
			frameEqual[i]->setPositionY(
					framePlay[SUM_NUM - 1]->getPositionY()
							+ paddingX * (2 - (int) i / 2));
			frameEqual[i]->setPositionX(
					framePlay[SUM_NUM - 1]->getPositionX() + paddingX);
			//character equal
			characterEqual[i]->setPositionY(
					framePlay[SUM_NUM - 1]->getPositionY()
							+ paddingX * ((int) i / 2));
			characterEqual[i]->setPositionX(
					framePlay[SUM_NUM - 1]->getPositionX() + paddingX / 2);
		} else {
			//frame equal
			frameEqual[i]->setPositionY(
					framePlay[SUM_NUM - 1]->getPositionY() - paddingX);
			frameEqual[i]->setPositionX(
					framePlay[SUM_NUM - 1]->getPositionX()
							- paddingX * (2 - (int) i / 2));
			//character equal
			characterEqual[i]->setPositionY(
					framePlay[SUM_NUM - 1]->getPositionY() - paddingX / 2);
			characterEqual[i]->setPositionX(
					framePlay[SUM_NUM - 1]->getPositionX()
							- paddingX * (2 - (int) i / 2));
		}
		this->addChild(frameEqual[i]);
		this->addChild(characterEqual[i]);
	}

	//position of character computation
	Sprite* plusSprite = Sprite::create("icon_plus.png");
	Sprite* minusSrite = Sprite::create("icon_minus.png");
	Sprite* mutiplySprite = Sprite::create("icon_multiply.png");
	Sprite* divideSprite = Sprite::create("icon_divide.png");

	for (int i = 0; i < SUM_COM; i++) {
		if (arrCOM[i] == '+')
			comBtn[i] = Sprite::createWithTexture(plusSprite->getTexture());
		else if (arrCOM[i] == '-')
			comBtn[i] = Sprite::createWithTexture(minusSrite->getTexture());
		else if (arrCOM[i] == '*')
			comBtn[i] = Sprite::createWithTexture(mutiplySprite->getTexture());
		else if (arrCOM[i] == '/')
			comBtn[i] = Sprite::createWithTexture(divideSprite->getTexture());
		this->addChild(comBtn[i]);
	}
	setPosCharacterBtn(comBtn, framePlay, paddingX);

	//calculate result
	result[0] = gameAI->calculate(arrNum[0], arrNum[1], arrNum[2], arrCOM[0],
			arrCOM[1]);
	result[1] = gameAI->calculate(arrNum[0], arrNum[3], arrNum[6], arrCOM[2],
			arrCOM[7]);
	result[2] = gameAI->calculate(arrNum[3], arrNum[4], arrNum[5], arrCOM[5],
			arrCOM[6]);
	result[3] = gameAI->calculate(arrNum[1], arrNum[4], arrNum[7], arrCOM[3],
			arrCOM[8]);
	result[4] = gameAI->calculate(arrNum[6], arrNum[7], arrNum[8], arrCOM[10],
			arrCOM[11]);
	result[5] = gameAI->calculate(arrNum[2], arrNum[5], arrNum[8], arrCOM[4],
			arrCOM[9]);
	gameAI->printArray(result, SUM_COM / 2);

	//set result to frameEqual
	for (int i = 0; i < SUM_COM / 2; i++) {
		resultLabel[i] = LabelTTF::create("00:00", "fonts/hlvgchac.ttf", 48);
		resultLabel[i]->setColor(Color3B(Color3B::RED));
		resultLabel[i]->setString(std::to_string(result[i]));
		resultLabel[i]->setPosition(frameEqual[i]->getPosition());
		this->addChild(resultLabel[i]);
	}

	//button pause
	Sprite* pauseGame = Sprite::create("pauseBtn.png");
	Sprite* pauseGame_press = Sprite::create("pauseBtn_press.png");
	MenuItemSprite* pauseBtn = MenuItemSprite::create(pauseGame,
			pauseGame_press, NULL, CC_CALLBACK_0(GamePlay::gamePause, this));
	Menu *menuPause = Menu::create(pauseBtn, nullptr);
	menuPause->setPosition(
			Vec2(
					visibleSize.width - PADDING
							- pauseBtn->getContentSize().width / 2,
					visibleSize.height - PADDING
							- pauseBtn->getContentSize().height / 2));
	menuPause->setTag(TAG_PAUSE_BTN);
	this->addChild(menuPause);

	//time in pause button
	LabelTTF *currenttime = LabelTTF::create("00:00", "fonts/hlvgchac.ttf", 40);
	Point timePoint = menuPause->getPosition();
	currenttime->setPosition(
			Vec2(timePoint.x - PADDING * 2, timePoint.y + 7.0 / 4.0 * PADDING));
	currenttime->setZOrder(10);
	currenttime->setColor(Color3B(Color3B::RED));
	currenttime->setTag(TAG_LABEL_COUNT_TIME);
	this->addChild(currenttime);

	std::string miniModeSprite = getLevelString(
			GamePlay::instance()->getLevel());
	Sprite* miniMode = Sprite::create("mini" + miniModeSprite + ".png");
	miniMode->setScale(0.5);
	miniMode->setPosition(
			Vec2(currenttime->getPositionX(),
					currenttime->getPositionY()
							- currenttime->getContentSize().height
							- PADDING / 2));
	this->addChild(miniMode);

	//board menu pause
	boardMenuPause = Sprite::create("board.png");
	boardMenuPause->setPosition(
			Vec2(visibleSize.width / 2,
					visibleSize.height
							+ boardMenuPause->getContentSize().height / 2
							+ PADDING));
	boardMenuPause->setZOrder(30);
	this->addChild(boardMenuPause);

	//button help of menu
	Sprite* helpbtn = Sprite::create("help1.png");
	Sprite* helpbtn_press = Sprite::create("help2.png");
	MenuItemSprite* helpBtn = MenuItemSprite::create(helpbtn, helpbtn_press,
	NULL, CC_CALLBACK_0(GamePlay::gameHelp, this));
	Menu *menuHelp = Menu::create(helpBtn, nullptr);
	menuHelp->setPosition(
			Vec2(boardMenuPause->getContentSize().width / 2,
					boardMenuPause->getContentSize().height
							- helpbtn->getContentSize().height));
	boardMenuPause->addChild(menuHelp);

	//button setting of menu
	Sprite* setbtn = Sprite::create("settings1.png");
	Sprite* setbtn_press = Sprite::create("settings2.png");
	MenuItemSprite* setBtn = MenuItemSprite::create(setbtn, setbtn_press, NULL,
			CC_CALLBACK_0(GamePlay::gameSetting, this));
	Menu *menuSetting = Menu::create(setBtn, nullptr);
	menuSetting->setPosition(
			Vec2(boardMenuPause->getContentSize().width / 2,
					menuHelp->getPositionY() - setbtn->getContentSize().height
							- PADDING));
	menuSetting->setTag(TAG_SETTING);
	boardMenuPause->addChild(menuSetting);

	//button quit of menu
	Sprite* quitbtn = Sprite::create("quit1.png");
	Sprite* quitbtn_press = Sprite::create("quit2.png");
	MenuItemSprite* quitBtn = MenuItemSprite::create(quitbtn, quitbtn_press,
	NULL, CC_CALLBACK_0(GamePlay::gameQuit, this));
	Menu *menuQuit = Menu::create(quitBtn, nullptr);
	menuQuit->setPosition(
			Vec2(menuSetting->getPositionX(),
					menuSetting->getPositionY()
							- quitbtn->getContentSize().height - PADDING));
	menuQuit->setTag(TAG_QUIT);
	boardMenuPause->addChild(menuQuit);

	//button replay, resume, share
	MenuItemImage* resumeBtn = MenuItemImage::create("menu_resume.png",
			"menu_resume.png", CC_CALLBACK_0(GamePlay::gameResume, this));
	auto menuResume = Menu::create(resumeBtn, nullptr);
	menuResume->setPosition(
			Vec2(menuSetting->getPositionX(),
					menuQuit->getPositionY()
							- resumeBtn->getContentSize().height - PADDING));
	boardMenuPause->addChild(menuResume);

	MenuItemImage* replayBtn = MenuItemImage::create("menu_replay.png",
			"menu_replay.png", CC_CALLBACK_0(GamePlay::gameReplay, this));
	auto menuReplay = Menu::create(replayBtn, nullptr);
	menuReplay->setPosition(
			Vec2(
					menuResume->getPositionX()
							- resumeBtn->getContentSize().width - PADDING,
					menuResume->getPositionY()));
	boardMenuPause->addChild(menuReplay);

	MenuItemImage* shareBtn = MenuItemImage::create("menu_share.png",
			"menu_share.png",
			CC_CALLBACK_0(GamePlay::gameShareCloseMenuPause, this));
	auto menuShare = Menu::create(shareBtn, nullptr);
	menuShare->setPosition(
			Vec2(
					menuResume->getPositionX()
							+ resumeBtn->getContentSize().width + PADDING,
					menuResume->getPositionY()));
	boardMenuPause->addChild(menuShare);

	auto event_listener = EventListenerTouchOneByOne::create();
	auto dispatcher = Director::getInstance()->getEventDispatcher();
	event_listener->setSwallowTouches(true);
	event_listener->onTouchBegan = CC_CALLBACK_2(GamePlay::onTouchBegan, this);
	event_listener->onTouchMoved = CC_CALLBACK_2(GamePlay::onTouchMoved, this);
	event_listener->onTouchEnded = CC_CALLBACK_2(GamePlay::onTouchEnded, this);
	dispatcher->addEventListenerWithSceneGraphPriority(event_listener, this);
	this->setKeypadEnabled(true);
	this->scheduleUpdate();
//	this->schedule(schedule_selector(GamePlay::update), 1.0f);
	gameState = Playing;
	return true;
}
示例#2
0
FailScene::FailScene(void)
{
	Vec2 points[] = {	Vec2(0, 0), 
						Vec2(0, 140),
						Vec2(400, 140),
						Vec2(400, 0) };
	DrawNode* draw = DrawNode::create();
	//±³¾°
	draw->drawPolygon(points, 4, ColorUtil::getColor4F(0x00 , 0xAD , 0xFF, 0xFF),
								0, ColorUtil::getColor4F(0x00, 0xDA, 0xFF, 0xFF));

	this->addChild(draw);
	draw->setAnchorPoint(Point(.5, .5));
	draw->setPositionX(ScreenUtil::getCenter().x - 200);
	draw->setPositionY(ScreenUtil::getCenter().y - 140);

	Vec2 points2[] = {	Vec2(0, 0), 
						Vec2(0, 150),
						Vec2(230, 150),
						Vec2(230, 0) };
	DrawNode* draw2 = DrawNode::create();
	//±³¾°
	draw2->drawPolygon(points2, 4, ColorUtil::getColor4F(0x00 , 0xAD , 0xFF, 0xFF),
								0, ColorUtil::getColor4F(0x00, 0xDA, 0xFF, 0xFF));

	this->addChild(draw2);
	draw2->setAnchorPoint(Point(.5, .5));
	draw2->setPositionX(ScreenUtil::getCenter().x - 115);
	draw2->setPositionY(ScreenUtil::getCenter().y + 40);

	LabelTTF* scoreTxt = LabelTTF::create("Score:", "Arial", 45);
	scoreTxt->setAnchorPoint(Point(0, .5));
	scoreTxt->setPosition(Point(draw2->getPositionX() + 10, 
								draw2->getPositionY() + 110));
	this->addChild(scoreTxt);

	LabelTTF* bestScoreTxt = LabelTTF::create("Best:", "Arial", 45);
	bestScoreTxt->setAnchorPoint(Point(0, .5));
	bestScoreTxt->setPosition(Point(scoreTxt->getPositionX(), 
									draw2->getPositionY() + 50));
	this->addChild(bestScoreTxt);

	LabelTTF* scoreValTxt = LabelTTF::create("0", "Arial", 45);
	scoreValTxt->setPositionX(scoreTxt->getPositionX() + scoreTxt->getContentSize().width + 25);
	scoreValTxt->setPositionY(scoreTxt->getPositionY());
	scoreValTxt->setTag(scoreValTxtTag);
	this->addChild(scoreValTxt);

	LabelTTF* bestScoreValTxt = LabelTTF::create("0", "Arial", 45);
	bestScoreValTxt->setPositionX(scoreValTxt->getPositionX());
	bestScoreValTxt->setPositionY(bestScoreTxt->getPositionY());
	bestScoreValTxt->setTag(bestScoreValTxtTag);
	this->addChild(bestScoreValTxt);

	LabelTTF* replayTxt = LabelTTF::create("Replay", "Arial", 45);
	MenuItemLabel* replayBtn = MenuItemLabel::create(replayTxt);
	replayBtn->setTag(replayBtnTag);

	LabelTTF* shareTxt = LabelTTF::create("Share", "Arial", 45);
	MenuItemLabel* shareBtn = MenuItemLabel::create(shareTxt);

	Menu* menu = Menu::create(replayBtn, shareBtn,  NULL);
	menu->setPositionX(ScreenUtil::getCenter().x);
	menu->setPositionY(ScreenUtil::getCenter().y - 70);
	menu->alignItemsHorizontallyWithPadding(50);
	menu->setTag(menuTag);
	this->addChild(menu);
}