// XXX: deprecated
MenuItemFont * MenuItemFont::create(const char *value, Object* target, SEL_MenuHandler selector)
{
MenuItemFont *pRet = new MenuItemFont();
pRet->initWithString(value, target, selector);
pRet->autorelease();
return pRet;
}
MenuItemFont * MenuItemFont::create(const std::string& value)
{
MenuItemFont *ret = new (std::nothrow) MenuItemFont();
ret->initWithString(value, (const ccMenuCallback&)nullptr);
ret->autorelease();
return ret;
}
// Menus
void GameLevelLayer::gameOver(bool playerDidWin)
{
m_isGameOver = true;
std::string gameText;
if (playerDidWin)
{
gameText = "You Won!";
}
else
{
gameText = "You have Died!";
CocosDenshion::SimpleAudioEngine::getInstance()->playEffect("hurt.wav");
}
Menu* pMenu = CCMenu::create();
pMenu->setPosition(Vec2(240, -100));
MenuItemFont *diedLabel = MenuItemFont::create(gameText);
diedLabel->setFontName("Marker Felt");
diedLabel->setFontSize(24);
diedLabel->setPosition(Vec2(240, 200));
pMenu->addChild(diedLabel);
MoveBy *slideIn = MoveBy::create(1.0, Vec2(0,250));
MenuItemImage *replay = MenuItemImage::create("replay.png", "replay.png", "replay.png");
replay->setPosition(Point::ZERO);
replay->setCallback(CC_CALLBACK_1(GameLevelLayer::replayButtonCallback, this));
pMenu->addChild(replay);
this->addChild(pMenu, 1);
pMenu->runAction(slideIn);
}
// on "init" you need to initialize your instance
bool HelloWorld::init()
{
//////////////////////////////
// 1. super init first
if ( !Layer::init() )
{
return false;
}
Size visibleSize = Director::getInstance()->getVisibleSize();
Vec2 origin = Director::getInstance()->getVisibleOrigin();
/////////////////////////////
// 2. add a menu item with "X" image, which is clicked to quit the program
// you may modify it.
// add a "close" icon to exit the progress. it's an autorelease object
// auto closeItem = MenuItemImage::create(
// "CloseNormal.png",
// "CloseSelected.png",
// CC_CALLBACK_1(HelloWorld::menuCloseCallback, this));
//
//closeItem->setPosition(Vec2(origin.x + visibleSize.width - closeItem->getContentSize().width/2 ,
// origin.y + closeItem->getContentSize().height/2));
MenuItemFont* buttonItem = MenuItemFont::create("menu item font", CC_CALLBACK_1(HelloWorld::showNewLayer, this));
buttonItem->setPosition(visibleSize.width/2, visibleSize.height/2);
// create menu, it's an autorelease object
auto menu = Menu::create(buttonItem, NULL);
menu->setPosition(Vec2::ZERO);
this->addChild(menu, 1);
/////////////////////////////
// 3. add your codes below...
// add a label shows "Hello World"
// create and initialize a label
auto label = Label::createWithTTF("Hello World", "fonts/Marker Felt.ttf", 24);
// position the label on the center of the screen
label->setPosition(Vec2(origin.x + visibleSize.width/2,
origin.y + visibleSize.height - label->getContentSize().height));
// add the label as a child to this layer
this->addChild(label, 1);
// add "HelloWorld" splash screen"
auto sprite = Sprite::create("HelloWorld.png");
// position the sprite on the center of the screen
sprite->setPosition(Vec2(visibleSize.width/2 + origin.x, visibleSize.height/2 + origin.y));
// add the sprite as a child to this layer
this->addChild(sprite, 0);
return true;
}
MenuItemFont * MenuItemFont::create(const char *value)
{
MenuItemFont *pRet = new MenuItemFont();
pRet->initWithString(value, (const ccMenuCallback&)nullptr);
pRet->autorelease();
return pRet;
}
void TitleScene::displayBG()
{
auto wall = DrawNode::create();
wall->drawSolidRect(Vec2(0, 0), Vec2(m_visibleSize.width, m_visibleSize.height), Color4F::WHITE);
this->addChild(wall);
auto title = Sprite::create("img/title.png");
// position the sprite on the center of the screen
title->setScale(m_visibleSize.width / m_visibleSize.height);
title->setPosition(Point(m_visibleSize.width / 2, m_visibleSize.height / 1.3));
// add the sprite as a child to this layer
this->addChild(title);
MenuItemFont::setFontSize(60);
MenuItemFont* newGameItem = MenuItemFont::create("START", CC_CALLBACK_1(TitleScene::menuSceneTransition, this));
auto label1 = Label::createWithTTF("START", "fonts/arial.ttf", 55);
label1->setColor(Color3B::BLACK);
label1->enableOutline(Color4B::BLACK, 2);
newGameItem->setLabel(label1);
auto menu = Menu::create(newGameItem, NULL);
menu->setPosition(Vec2(m_visibleSize.width / 2, m_visibleSize.height / 3.7));
this->addChild(menu);
}
bool GameOver::init()
{
LayerColor::initWithColor(Color4B::WHITE);
Size size = Director::getInstance()->getVisibleSize();
auto label = LabelTTF::create("Game Over","arial",36);
label->setColor(Color3B::BLACK);
label->setPosition(size.width/2,size.height/2);
addChild(label);
MenuItemFont::setFontSize(60);
MenuItemFont::setFontName("arial");
MenuItemFont* item = MenuItemFont::create("play again", CC_CALLBACK_1(GameOver::onMenuCallBack, this));
item->setColor(Color3B::BLACK);
Menu* mu = Menu::create(item, nullptr);
mu->setPosition(size.width / 2, size.height / 2 - 60);
addChild(mu);
return true;
}
// on "init" you need to initialize your instance
bool TableViewTestLayer::init()
{
if ( !Layer::init() )
{
return false;
}
Size winSize = Director::getInstance()->getWinSize();
TableView* tableView = TableView::create(this, Size(250, 60));
tableView->setDirection(ScrollView::Direction::HORIZONTAL);
tableView->setPosition(Point(20,winSize.height/2-30));
tableView->setDelegate(this);
this->addChild(tableView);
tableView->reloadData();
tableView = TableView::create(this, Size(60, 250));
tableView->setDirection(ScrollView::Direction::VERTICAL);
tableView->setPosition(Point(winSize.width-150,winSize.height/2-120));
tableView->setDelegate(this);
tableView->setVerticalFillOrder(TableView::VerticalFillOrder::TOP_DOWN);
this->addChild(tableView);
tableView->reloadData();
// Back Menu
MenuItemFont *itemBack = MenuItemFont::create("Back", CC_CALLBACK_1(TableViewTestLayer::toExtensionsMainLayer, this));
itemBack->setPosition(Point(VisibleRect::rightBottom().x - 50, VisibleRect::rightBottom().y + 25));
Menu *menuBack = Menu::create(itemBack, NULL);
menuBack->setPosition(Point::ZERO);
addChild(menuBack);
return true;
}
void CocosGUITestScene::menuCallback(Object *pSender)
{
MenuItemFont* pItem = dynamic_cast<MenuItemFont*>(pSender);
switch (pItem->getTag())
{
case 0:
{
UISceneManager* pManager = UISceneManager::sharedUISceneManager();
Scene* pScene = pManager->currentUIScene();
CCDirector::getInstance()->replaceScene(pScene);
}
break;
/*
case 1:
{
CocosGUIExamplesRegisterScene* pScene = new CocosGUIExamplesRegisterScene();
pScene->runThisTest();
pScene->release();
}
*/
break;
default:
break;
}
}
// on "init" you need to initialize your instance
bool TableViewTestLayer::init()
{
if ( !Layer::init() )
{
return false;
}
Size winSize = Director::sharedDirector()->getWinSize();
TableView* tableView = TableView::create(this, CCSizeMake(250, 60));
tableView->setDirection(kScrollViewDirectionHorizontal);
tableView->setPosition(ccp(20,winSize.height/2-30));
tableView->setDelegate(this);
this->addChild(tableView);
tableView->reloadData();
tableView = TableView::create(this, CCSizeMake(60, 250));
tableView->setDirection(kScrollViewDirectionVertical);
tableView->setPosition(ccp(winSize.width-150,winSize.height/2-120));
tableView->setDelegate(this);
tableView->setVerticalFillOrder(kTableViewFillTopDown);
this->addChild(tableView);
tableView->reloadData();
// Back Menu
MenuItemFont *itemBack = MenuItemFont::create("Back", CC_CALLBACK_1(TableViewTestLayer::toExtensionsMainLayer, this));
itemBack->setPosition(ccp(VisibleRect::rightBottom().x - 50, VisibleRect::rightBottom().y + 25));
Menu *menuBack = Menu::create(itemBack, NULL);
menuBack->setPosition(PointZero);
addChild(menuBack);
return true;
}
// XXX: deprecated
MenuItemFont * MenuItemFont::create(const std::string& value, Ref* target, SEL_MenuHandler selector)
{
MenuItemFont *ret = new (std::nothrow) MenuItemFont();
ret->initWithString(value, target, selector);
ret->autorelease();
return ret;
}
MenuItemFont * MenuItemFont::create(const std::string& value, const ccMenuCallback& callback)
{
MenuItemFont *ret = new MenuItemFont();
ret->initWithString(value, callback);
ret->autorelease();
return ret;
}
void TutorialScene::setConfirm()
{
const int maxNumMonsters = 3;
const int maxNumEquip = 10;
if (Generic::checkSaveData())//If there is data - Display confirmation menu to reset it
{
auto confirmText = Label::createWithTTF("データを消してもよろしいですか", "fonts/ant-maru.ttf", 45);
confirmText->enableOutline(Color4B::WHITE, 2);
confirmText->setPosition(Vec2(visibleSize.width / 2, visibleSize.height / 1.5));
this->addChild(confirmText);
MenuItemFont::setFontSize(60);
MenuItemFont* yesItem = MenuItemFont::create("YES", CC_CALLBACK_1(TutorialScene::menuSceneTransition, this));
MenuItemFont* noItem = MenuItemFont::create("NO", CC_CALLBACK_1(TutorialScene::rtrnTitleScene, this));
auto label1 = Label::createWithTTF("はい", "fonts/ant-maru.ttf", 45);
auto label2 = Label::createWithTTF("いいえ", "fonts/ant-maru.ttf", 45);
label1->enableOutline(Color4B::WHITE, 2);
label2->enableOutline(Color4B::WHITE, 2);
yesItem->setLabel(label1);
noItem->setLabel(label2);
confirmMenu = Menu::create(yesItem, noItem, NULL);
confirmMenu->setPosition(Vec2(visibleSize.width / 2, visibleSize.height / 3));
confirmMenu->alignItemsVerticallyWithPadding(30);
this->addChild(confirmMenu);
}
else
{
/*
resetSaveData();
auto listener = EventListenerTouchOneByOne::create();
listener->setSwallowTouches(true);
listener->onTouchBegan = [](Touch* touch, Event* event)
{
return true;
};
listener->onTouchEnded = [](Touch* touch, Event* event)
{
auto nextScene = MenuScene::createScene();
auto pScene = TransitionFade::create(1.0f, nextScene);
Director::getInstance()->replaceScene(MenuScene::createScene());
CCLOG("Test");
};
this->getEventDispatcher()->addEventListenerWithSceneGraphPriority(listener, this);
*/
auto tmpNode = Node::create();
auto transition = CallFunc::create([this](){this->continueToMenu(); });
tmpNode->runAction(transition);
}
}
bool TMenu::init()
{
Layer::init();
Menu * menu = Menu::create();
addChild(menu);
for (int i = 0; i < sizeof(title) / sizeof(*title); ++i)
{
MenuItemFont * item = MenuItemFont::create(title[i], [](Ref * sender){
MenuItem * item = (MenuItem *)sender;
int i = item->getTag() - 1000;
Layer * l = NULL;
if (title[i] == "T01CPP11") l = T01CPP11::create();
else if (title[i] == "T02Vector") l = T02Vector::create();
else if (title[i] == "T03Map") l = T03Map::create();
else if (title[i] == "T04Label") l = T04Label::create();
else if (title[i] == "T05Touch") l = T05Touch::create();
else if (title[i] == "T06Box2D") l = T06Box2D::create();
else if (title[i] == "T07PhysicsWorld") l = T07PhysicsWorld::create();
else if (title[i] == "T08RayCast") l = T08RayCast::create();
else if (title[i] == "T09Joint") l = T09Joint::create();
else if (title[i] == "T10MultiShapes") l = T10MultiShapes::create();
else if (title[i] == "T11FlyppyBird") l = T11FlyppyBird::create();
if (l != NULL)
{
TBack * b = TBack::create();
//Scene * s = Scene::create();
Scene * s = Scene::createWithPhysics(); // 3.x ÎïÀíÊÀ½ç
PhysicsWorld * world = s->getPhysicsWorld();
world->setDebugDrawMask(PhysicsWorld::DEBUGDRAW_ALL);
s->addChild(b);
s->addChild(l);
Director::getInstance()->pushScene(s);
}
});
menu->addChild(item);
item->setTag(1000 + i);
}
menu->alignItemsVertically();
// ´¥Ãþ
auto ev = EventListenerTouchOneByOne::create();
//ev->onTouchBegan = std::bind(&TMenu::touchBegan, this, std::placeholders::_1, std::placeholders::_2);
ev->onTouchBegan = CC_CALLBACK_2(TMenu::touchBegan, this);
ev->onTouchMoved = [&](Touch * touch, Event *){
setPositionY(getPositionY() + touch->getDelta().y);
};
_eventDispatcher->addEventListenerWithSceneGraphPriority(ev, this);
return true;
}
// on "init" you need to initialize your instance
bool TestIAP::init()
{
//////////////////////////////
// 1. super init first
if ( !Layer::init() )
{
return false;
}
MyPurchase::getInstance()->loadIAPPlugin();
/////////////////////////////
// 2. add a menu item with "X" image, which is clicked to quit the program
// you may modify it.
auto pEGLView = Director::getInstance()->getOpenGLView();
Point posBR = Point(pEGLView->getVisibleOrigin().x + pEGLView->getVisibleSize().width, pEGLView->getVisibleOrigin().y);
Point posTL = Point(pEGLView->getVisibleOrigin().x, pEGLView->getVisibleOrigin().y + pEGLView->getVisibleSize().height);
// add a "close" icon to exit the progress. it's an autorelease object
MenuItemFont *pBackItem = MenuItemFont::create("Back", CC_CALLBACK_1(TestIAP::menuBackCallback, this));
Size backSize = pBackItem->getContentSize();
pBackItem->setPosition(posBR + Point(- backSize.width / 2, backSize.height / 2));
// create menu, it's an autorelease object
Menu* pMenu = Menu::create(pBackItem, NULL);
pMenu->setPosition( Point::ZERO );
this->addChild(pMenu, 1);
Point posStep = Point(220, -150);
Point beginPos = posTL + (posStep * 0.5f);
int line = 0;
int row = 0;
for (int i = 0; i < sizeof(s_EventMenuItem)/sizeof(s_EventMenuItem[0]); i++) {
MenuItemImage* pMenuItem = MenuItemImage::create(s_EventMenuItem[i].id.c_str(), s_EventMenuItem[i].id.c_str(),
CC_CALLBACK_1(TestIAP::eventMenuCallback, this));
pMenu->addChild(pMenuItem, 0, s_EventMenuItem[i].tag);
Point pos = beginPos + Point(posStep.x * row, posStep.y * line);
Size itemSize = pMenuItem->getContentSize();
if ((pos.x + itemSize.width / 2) > posBR.x)
{
line += 1;
row = 0;
pos = beginPos + Point(posStep.x * row, posStep.y * line);
}
row += 1;
pMenuItem->setPosition(pos);
}
return true;
}
void MenuScene::onClick(Ref* sender)
{
MenuItemFont* pFont = (MenuItemFont*) sender;
switch( pFont->getTag() )
{
case 1:
{
CSceneManager::getInstance()->pushScene(
CCSceneExTransitionFade::create(1.0f, LoadScene("BasicSceneTest"))
);
}
break;
}
}
// on "init" you need to initialize your instance
bool TestAnalytics::init()
{
//////////////////////////////
// 1. super init first
if ( !Layer::init() )
{
return false;
}
_pluginAnalytics = NULL;
loadPlugins();
Size visibleSize = Director::getInstance()->getVisibleSize();
Point origin = Director::getInstance()->getVisibleOrigin();
Point posBR = Point(origin.x + visibleSize.width, origin.y);
/////////////////////////////
// 2. add a menu item with "X" image, which is clicked to quit the program
// you may modify it.
// add a "close" icon to exit the progress. it's an autorelease object
MenuItemFont *pBackItem = MenuItemFont::create("Back", CC_CALLBACK_1(TestAnalytics::menuBackCallback, this));
Size backSize = pBackItem->getContentSize();
pBackItem->setPosition(posBR + Point(- backSize.width / 2, backSize.height / 2));
// create menu, it's an autorelease object
Menu* pMenu = Menu::create(pBackItem, NULL);
pMenu->setPosition( Point::ZERO );
this->addChild(pMenu, 1);
float yPos = 0;
for (int i = 0; i < sizeof(s_EventMenuItem)/sizeof(s_EventMenuItem[0]); i++) {
LabelTTF* label = LabelTTF::create(s_EventMenuItem[i].id.c_str(), "Arial", 24);
MenuItemLabel* pMenuItem = MenuItemLabel::create(label, CC_CALLBACK_1(TestAnalytics::eventMenuCallback, this));
pMenu->addChild(pMenuItem, 0, s_EventMenuItem[i].tag);
yPos = visibleSize.height - 35*i - 100;
pMenuItem->setPosition( Point(visibleSize.width / 2, yPos));
}
std::string strName = _pluginAnalytics->getPluginName();
std::string strVer = _pluginAnalytics->getSDKVersion();
char ret[256] = { 0 };
sprintf(ret, "Plugin : %s, Ver : %s", strName.c_str(), strVer.c_str());
LabelTTF* pLabel = LabelTTF::create(ret, "Arial", 18, Point(visibleSize.width, 0), Label::HAlignment::CENTER);
pLabel->setPosition(Point(visibleSize.width / 2, yPos - 80));
addChild(pLabel);
return true;
}
void StoreScene::showInGameMenuLayer() {
Size winSize = Director::getInstance()->getWinSize();
InGameMenuLayer* _inGameMenuLayer = InGameMenuLayer::create();
addChild(_inGameMenuLayer);
MenuItemFont *menuButton = MenuItemFont::create("Menu", this,menu_selector(StoreScene::menuButtonCallback));
menuButton->setColor(Color3B(0,0,0));
menuButton->setPosition(Point(winSize.width - menuButton->getContentSize().width, winSize.height - menuButton->getContentSize().height));
Menu *pMenu = Menu::create(menuButton,NULL);
pMenu->setPosition(Point::ZERO);
_inGameMenuLayer->addChild(pMenu, 1);
}
void SpriteMainScene::onAutoTest(Ref* sender)
{
SpriteMainScene::_s_autoTest = !SpriteMainScene::_s_autoTest;
MenuItemFont* menuItem = dynamic_cast<MenuItemFont*>(sender);
if (SpriteMainScene::_s_autoTest)
{
menuItem->setString("Auto Test On");
beginAutoTest();
}
else
{
menuItem->setString("Auto Test Off");
endAutoTest();
}
}
void TitleScene::displayMenu(bool loadContent)
{
MenuItemFont::setFontSize(60);
MenuItemFont* newGameItem = MenuItemFont::create("NEW GAME", CC_CALLBACK_1(TitleScene::menuSceneTransition, this, true));
MenuItemFont* continueItem = MenuItemFont::create("CONTINUE", CC_CALLBACK_1(TitleScene::menuSceneTransition, this, false));
auto label1 = Label::createWithTTF("NEW GAME", "fonts/arial.ttf", 45);
auto label2 = Label::createWithTTF("CONTINUE", "fonts/arial.ttf", 45);
label1->enableOutline(Color4B::WHITE, 2);
label2->enableOutline(Color4B::WHITE, 2);
newGameItem->setLabel(label1);
continueItem->setLabel(label2);
if (!loadContent)
{
continueItem->setEnabled(false);
}
loadMenu = Menu::create(newGameItem, continueItem, NULL);
loadMenu->setPosition(Vec2(visibleSize.width / 2, visibleSize.height / 3));
loadMenu->alignItemsVerticallyWithPadding(30);
loadMenu->setVisible(false);
this->addChild(loadMenu);
string btn = "img/UI/home/UI_T_002.png";
string pushBtn = "img/UI/home/UI_T_003.png";
auto startBtn = MenuItemImage::create(btn.c_str(),
pushBtn.c_str(),
CC_CALLBACK_1(TitleScene::showLoadMenu, this, loadMenu));
startBtn->setScale(m_Mag);
startMenu = Menu::create(startBtn, NULL);
startMenu->setPosition(Vec2(visibleSize.width / 2, visibleSize.height / 3));
this->addChild(startMenu);
//Fade in - Fade out animation
cocos2d::Vector<cocos2d::FiniteTimeAction*> fadeAnimation;
fadeAnimation.pushBack(FadeOut::create(3));
fadeAnimation.pushBack(FadeIn::create(3));
auto sequence = Sequence::create(fadeAnimation);
auto repetition = RepeatForever::create(sequence);
startMenu->runAction(repetition);
}
void LabelMainScene::onAutoTest(Ref* sender)
{
LabelMainScene::_s_autoTest = !LabelMainScene::_s_autoTest;
MenuItemFont* menuItem = dynamic_cast<MenuItemFont*>(sender);
if (nullptr != menuItem)
{
if (LabelMainScene::_s_autoTest)
{
menuItem->setString("Auto Test On");
autoShowLabelTests(0,_quantityNodes);
}
else
{
menuItem->setString("Auto Test Off");
endAutoTest();
}
}
}
bool PlayersSelectLayer::init()
{
if (!Layer::init())
return false;
//return true;
Size visibleSize = Director::sharedDirector()->getVisibleSize();
Menu* menu = Menu::create();
// Add all possibilities
int position = 0;
for(unsigned int i = 1; i <= 2; i++ )
{
std::string label = std::to_string(i);
label += (i == 1) ? " Player" : " Players";
ccMenuCallback callback = std::bind(&PlayersSelectLayer::newGame, this, this, i);
MenuItemFont *newLevel = new MenuItemFont();
newLevel->initWithString(
label.c_str(),
callback
);
newLevel->setPosition(ccp(0, position));
menu->addChild(newLevel);
position -= 50;
}
// Add menu to layer
this->addChild(menu, 1);
menu->setPosition(
ccp(
visibleSize.width/2,
visibleSize.height - 100
)
);
this->setTouchEnabled(true);
return true;
}
// on "init" you need to initialize your instance
bool HelloWorld::init()
{
//////////////////////////////
// 1. super init first
if ( !Layer::init() )
{
return false;
}
Size visibleSize = Director::getInstance()->getVisibleSize();
Point origin = Director::getInstance()->getVisibleOrigin();
/////////////////////////////
// 2. add a menu item with "X" image, which is clicked to quit the program
// you may modify it.
// add a "close" icon to exit the progress. it's an autorelease object
MenuItemImage *pCloseItem = MenuItemImage::create(
"CloseNormal.png",
"CloseSelected.png",
CC_CALLBACK_1(HelloWorld::menuCloseCallback, this));
pCloseItem->setPosition(Point(origin.x + visibleSize.width - pCloseItem->getContentSize().width/2 ,
origin.y + pCloseItem->getContentSize().height/2));
// create menu, it's an autorelease object
Menu* pMenu = Menu::create(pCloseItem, NULL);
pMenu->setPosition(Point::ZERO);
this->addChild(pMenu, 1);
Point beginPos = Point(origin.x + visibleSize.width / 2, origin.y + visibleSize.height - 50);
float step = 60.0f;
int nCaseCount = sizeof(g_testCases) / sizeof(std::string);
for (int i = 0; i < nCaseCount; ++i) {
std::string caseName = g_testCases[i];
MenuItemFont *pItem = MenuItemFont::create(caseName.c_str(), CC_CALLBACK_1(HelloWorld::menuCallback, this));
pItem->setTag(i);
pItem->setPosition(Point(beginPos.x, beginPos.y - i * step));
pMenu->addChild(pItem);
}
return true;
}
void MenuScene::onLoadScene()
{
m_vMenuItems.push_back("Basic Test");
Size tContainerSize = Size(700, 100 * m_vMenuItems.size());
Layer* pScrollViewContainer = Layer::create();
pScrollViewContainer->setPosition(Point::ZERO);
pScrollViewContainer->setContentSize(tContainerSize);
m_pScrollView = ScrollView::create(Size(700, 640));
m_pScrollView->ignoreAnchorPointForPosition(false);
m_pScrollView->setPosition(CCPoint(480, 320));
m_pScrollView->setContainer(pScrollViewContainer);
addChild(m_pScrollView);
Vector<MenuItem *> vet;
float height = tContainerSize.height;
unsigned int i = 0;
unsigned int end = m_vMenuItems.size();
for(; i < end; ++i )
{
MenuItemFont* pFont = MenuItemFont::create(m_vMenuItems[i].c_str());
pFont->setCallback(CC_CALLBACK_1(MenuScene::onClick,this));
pFont->setFontSizeObj(45.0f);
pFont->setPosition(Point(700 / 2, height - 100 / 2));
pFont->setTag(i + 1);
vet.pushBack(pFont);
height -= 100;
}
Menu* pMenu = Menu::createWithArray(vet);
pMenu->setPosition(Point(0,0));
pScrollViewContainer->addChild(pMenu);
m_pScrollView->setContentOffset(Point(0, -(tContainerSize.height - 640)));
}
void MPix::EditorMenu::BuildEditorsMenu()
{
MenuItemFont::setFontSize(64);
auto menu = Menu::create();
MenuItemFont* item = nullptr;
// New
item = MenuItemFont::create(LocalUTF8Char("New"), [&](Ref *sender) {
SelectedNewLevel();
}); menu->addChild(item);
// Last
item = MenuItemFont::create(LocalUTF8Char("Last"), [&](Ref *sender) {
SelectedLast();
}); menu->addChild(item);
auto ss = LocalUTF8Str("Export") + "\n" + LevelStorage::getInstance()->GetExportDir();
item = MenuItemFont::create(ss.c_str(), [&](Ref *sender) {
SelectedExportMap();
}); menu->addChild(item); item->setScale(0.5f); item->setColor(Color3B::GREEN);
item = MenuItemFont::create(LocalUTF8Char("Edit"), [&](Ref *sender) {
SelectedEdit();
}); menu->addChild(item);
item = MenuItemFont::create(LocalUTF8Char("Delete"), [&](Ref *sender) {
SelectedDelete();
}); menu->addChild(item); item->setColor(Color3B::RED);
item = MenuItemFont::create(LocalUTF8Char("Back"), [&](Ref *sender) {
BackToMainMenu();
}); menu->addChild(item);
menu->alignItemsVertically();
auto s = Director::getInstance()->getWinSize();
menu->setPosition(Vector2(s.width/2, s.height/2));
addChild(menu, 2);
edit_m = menu;
}
void HelloWorld::menuCallback(Ref* pSender)
{
MenuItemFont *pItem = (MenuItemFont*) pSender;
Scene* newScene = NULL;
switch (pItem->getTag()) {
case 0:
// newScene = TestAds::scene();
break;
case 1:
// newScene = TestAnalytics::scene();
break;
case 2:
// newScene = TestShare::scene();
break;
case 3:
newScene = TestFacebookUser::scene();
break;
case 4:
newScene = TestFacebookShare::scene();
break;
case 5:
// newScene = TestIAP::scene();
break;
case 6:
// newScene = TestIAPOnline::scene();
break;
case 7:
// newScene = TestUser::scene();
break;
case 8:
// newScene = TestSocial::scene();
break;
case 9:
break;
default:
break;
}
if (newScene) {
Director::getInstance()->replaceScene(newScene);
}
}
// on "init" you need to initialize your instance
bool HelloWorld::init()
{
if ( !Layer::init() )
{
return false;
}
Size visibleSize = Director::getInstance()->getVisibleSize();
MenuItemFont* pIncrease = MenuItemFont::create("increase 20",CC_CALLBACK_1(HelloWorld::increaseCallback,this));
pIncrease->setAnchorPoint(Vec2(0.0f,1.0f));
pIncrease->setPosition(0.0f,visibleSize.height - 0.0f);
MenuItemFont* pReduce = MenuItemFont::create("reduce 20",CC_CALLBACK_1(HelloWorld::reduceCallback,this));
pReduce->setAnchorPoint(Vec2(0.0f,1.0f));
pReduce->setPosition(0.0f,visibleSize.height - 40.0f);
MenuItemFont* pGoto = MenuItemFont::create("goto 100",CC_CALLBACK_1(HelloWorld::gotoCallback,this));
pGoto->setAnchorPoint(Vec2(0.0f,1.0f));
pGoto->setPosition(0.0f,visibleSize.height - 80.0f);
Menu* pMenu = Menu::create(pIncrease,pReduce,pGoto, NULL);
pMenu->setPosition(Vec2(0.0f,0.0f));
this->addChild(pMenu, 1);
LabelAtlas* pNumber = LabelAtlas::create("","number.png",55,84,'0');
pNumber->setAnchorPoint(Vec2(0.5f,0.5f));
pNumber->setPosition(Vec2(visibleSize.width/2.0f,
visibleSize.height/2.0f));
this->addChild(pNumber);
m_numberCount.setLabelAtlas(pNumber); //如果是从cocostudio导出的话请调用NumberCount::setTextAtlas
//将数字每一步的增量初始化为3
m_numberCount.setNumberDelta(3);
//将数字增加时间间隔设置为0.1秒
m_numberCount.setTimeDelta(0.1f);
//将数字初始化为100
m_numberCount.setNumber(100,false);
return true;
}
void TestPerformance::onEnter()
{
ArmatureTestLayer::onEnter();
MenuItemFont::setFontSize(65);
MenuItemFont *decrease = MenuItemFont::create(" - ", CC_CALLBACK_1(TestPerformance::onDecrease, this));
decrease->setColor(Color3B(0,200,20));
MenuItemFont *increase = MenuItemFont::create(" + ", CC_CALLBACK_1(TestPerformance::onIncrease, this));
increase->setColor(Color3B(0,200,20));
Menu *menu = Menu::create(decrease, increase, nullptr);
menu->alignItemsHorizontally();
menu->setPosition(VisibleRect::getVisibleRect().size.width/2, VisibleRect::getVisibleRect().size.height-100);
addChild(menu, 10000);
armatureCount = frames = times = lastTimes = 0;
generated = false;
addArmature(100);
}
void Picking::displayUI()
{
eventHandler();
displayHP();
for (int i = 0; i < 4; i++)
{
m_glow[i] = Sprite::create("img/UI/battle/glow.png");
m_glow[i]->setScale(m_Mag*0.5);
m_glow[i]->setPosition(Vec2(m_visibleSize.width / 8 * (((i + 1) * 1.5) + 1), m_cards[1]->getPositionY()));
m_glow[i]->setZOrder(2);
m_glow[i]->setTag(5);
m_instance->addChild(m_glow[i]);
}
//instructions to reshuffle
instructions = Label::createWithTTF("いらないカードをシャッフルしよう！", "fonts/ant-maru.ttf", 55);
instructions->enableOutline(Color4B::BLACK, 2);
instructions->setPosition(Vec2(m_visibleSize.width / 2, m_visibleSize.height /2.4));
m_instance->addChild(instructions);
auto Label = Label::createWithTTF("<< Enemy Card", "fonts/arial.ttf", 25);
Label->setColor(Color3B::RED);
Label->enableOutline(Color4B::BLACK, 2);
Label->setPosition(Vec2(m_enemyCard->getPosition().x * 0.9, m_enemyCard->getBoundingBox().getMaxY()));
Label->setName("EnemyCard");
//m_instance->addChild(Label);
MenuItemFont::setFontSize(80);
MenuItemFont* goItem = MenuItemFont::create("Go!", CC_CALLBACK_1(Picking::startBattle, this));
auto label = Label::createWithTTF("ＧＯ！", "fonts/ant-maru.ttf", 60);
label->enableOutline(Color4B::RED, 2);
goItem->setLabel(label);
goItem->setPosition(Vec2(m_visibleSize.width / 1.15, m_visibleSize.height / 2));
m_menu = Menu::create(goItem, NULL);
m_menu->setPosition(Point::ZERO);
m_instance->addChild(m_menu);
}
cocos2d::Node* SceneEditorTestLayer::createGameScene()
{
Node *pNode = SceneReader::getInstance()->createNodeWithSceneFile("scenetest/FishJoy2.json");
if (pNode == NULL)
{
return NULL;
}
_curNode = pNode;
MenuItemFont *itemBack = MenuItemFont::create("Back", CC_CALLBACK_1(SceneEditorTestLayer::toExtensionsMainLayer, this));
itemBack->setColor(Color3B(255, 255, 255));
itemBack->setPosition(Point(VisibleRect::rightBottom().x - 50, VisibleRect::rightBottom().y + 25));
Menu *menuBack = Menu::create(itemBack, NULL);
menuBack->setPosition(Point(0.0f, 0.0f));
menuBack->setZOrder(4);
pNode->addChild(menuBack);
//ui action
cocos2d::extension::ActionManagerEx::shareManager()->playActionByName("startMenu_1.json","Animation1");
return pNode;
}
