コード例 #1
0
// Worker thread
void HttpClient::networkThread()
{    
    HttpRequest *request = nullptr;
    
    auto scheduler = Director::getInstance()->getScheduler();
    
    while (true) 
    {
        if (s_need_quit)
        {
            break;
        }
        
        // step 1: send http request if the requestQueue isn't empty
        request = nullptr;
        
        s_requestQueueMutex.lock();
        
        //Get request task from queue
        
        if (!s_requestQueue->empty())
        {
            request = s_requestQueue->at(0);
            s_requestQueue->erase(0);
        }
        
        s_requestQueueMutex.unlock();
        
        if (nullptr == request)
        {
            // Wait for http request tasks from main thread
            std::unique_lock<std::mutex> lk(s_SleepMutex); 
            s_SleepCondition.wait(lk);
            continue;
        }
        
        // step 2: libcurl sync access
        
        // Create a HttpResponse object, the default setting is http access failed
        HttpResponse *response = new HttpResponse(request);
        
        processResponse(response, s_errorBuffer);
        

        // add response packet into queue
        s_responseQueueMutex.lock();
        s_responseQueue->pushBack(response);
        s_responseQueueMutex.unlock();
        
        if (nullptr != s_pHttpClient) {
            scheduler->performFunctionInCocosThread(CC_CALLBACK_0(HttpClient::dispatchResponseCallbacks, this));
        }
    }
    
    // cleanup: if worker thread received quit signal, clean up un-completed request queue
    s_requestQueueMutex.lock();
    s_requestQueue->clear();
    s_requestQueueMutex.unlock();
    
    
    if (s_requestQueue != nullptr) {
        delete s_requestQueue;
        s_requestQueue = nullptr;
        delete s_responseQueue;
        s_responseQueue = nullptr;
    }
    
}
コード例 #2
0
ファイル: CCLabel.cpp プロジェクト: 12white/CocoStudioSamples
void Label::draw()
{
    _customCommand.init(_globalZOrder);
    _customCommand.func = CC_CALLBACK_0(Label::onDraw, this);
    Director::getInstance()->getRenderer()->addCommand(&_customCommand);
}
コード例 #3
0
ファイル: CCClippingNode.cpp プロジェクト: 2276225819/Game
void ClippingNode::visit(Renderer *renderer, const Mat4 &parentTransform, bool parentTransformUpdated)
{
    if(!_visible)
        return;
    
    bool dirty = parentTransformUpdated || _transformUpdated;
    if(dirty)
        _modelViewTransform = transform(parentTransform);
    _transformUpdated = false;

    // IMPORTANT:
    // To ease the migration to v3.0, we still support the Mat4 stack,
    // but it is deprecated and your code should not rely on it
    Director* director = Director::getInstance();
    CCASSERT(nullptr != director, "Director is null when seting matrix stack");
    director->pushMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_MODELVIEW);
    director->loadMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_MODELVIEW, _modelViewTransform);

    //Add group command
        
    _groupCommand.init(_globalZOrder);
    renderer->addCommand(&_groupCommand);

    renderer->pushGroup(_groupCommand.getRenderQueueID());

    _beforeVisitCmd.init(_globalZOrder);
    _beforeVisitCmd.func = CC_CALLBACK_0(ClippingNode::onBeforeVisit, this);
    renderer->addCommand(&_beforeVisitCmd);
    if (_alphaThreshold < 1)
    {
#if (CC_TARGET_PLATFORM == CC_PLATFORM_MAC || CC_TARGET_PLATFORM == CC_PLATFORM_WINDOWS || CC_TARGET_PLATFORM == CC_PLATFORM_LINUX)
#else
        // since glAlphaTest do not exists in OES, use a shader that writes
        // pixel only if greater than an alpha threshold
        GLProgram *program = GLProgramCache::getInstance()->getGLProgram(GLProgram::SHADER_NAME_POSITION_TEXTURE_ALPHA_TEST_NO_MV);
        GLint alphaValueLocation = glGetUniformLocation(program->getProgram(), GLProgram::UNIFORM_NAME_ALPHA_TEST_VALUE);
        // set our alphaThreshold
        program->use();
        program->setUniformLocationWith1f(alphaValueLocation, _alphaThreshold);
        // we need to recursively apply this shader to all the nodes in the stencil node
        // XXX: we should have a way to apply shader to all nodes without having to do this
        setProgram(_stencil, program);
        
#endif

    }
    _stencil->visit(renderer, _modelViewTransform, dirty);

    _afterDrawStencilCmd.init(_globalZOrder);
    _afterDrawStencilCmd.func = CC_CALLBACK_0(ClippingNode::onAfterDrawStencil, this);
    renderer->addCommand(&_afterDrawStencilCmd);

    int i = 0;
    
    if(!_children.empty())
    {
        sortAllChildren();
        // draw children zOrder < 0
        for( ; i < _children.size(); i++ )
        {
            auto node = _children.at(i);
            
            if ( node && node->getLocalZOrder() < 0 )
                node->visit(renderer, _modelViewTransform, dirty);
            else
                break;
        }
        // self draw
        this->draw(renderer, _modelViewTransform, dirty);
        
        for(auto it=_children.cbegin()+i; it != _children.cend(); ++it)
            (*it)->visit(renderer, _modelViewTransform, dirty);
    }
    else
    {
        this->draw(renderer, _modelViewTransform, dirty);
    }

    _afterVisitCmd.init(_globalZOrder);
    _afterVisitCmd.func = CC_CALLBACK_0(ClippingNode::onAfterVisit, this);
    renderer->addCommand(&_afterVisitCmd);

    renderer->popGroup();
    
    director->popMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_MODELVIEW);
}
コード例 #4
0
void GamePromptCenter::popPromptText()
{
	if ( m_promptText.empty() )
	{
		return ;
	}

	RichTextEx* pText = m_promptText[0].first;
	if ( pText )
	{
		float deltaX = 0.0f;
		float deltaY = 100.0f;

		pText->runAction(FadeOut::create(0.5f));
		pText->runAction(Sequence::create(MoveBy::create(0.5f,Point(deltaX,deltaY)),CallFunc::create( CC_CALLBACK_0(GamePromptCenter::onPromptTextPoped,this,pText)),NULL));
	}

	m_promptText.erase(m_promptText.begin());

 	// 所有提示信息往上顶
 	for ( size_t i = 0; i<m_promptText.size(); ++i )
 	{
		RichTextEx* pTextReady = m_promptText[i].first;
		if ( pTextReady )
		{
			ActionInterval* pAction = MoveBy::create(0.2f,Point(0,pText->getSize().height+3));
			pTextReady->runAction(pAction);
		}
 	}
}
コード例 #5
0
ファイル: ShaderNode.cpp プロジェクト: drjiro/WSSample
/**
 * Draw node.
 *
 * @param renderer Renderer object
 * @param transform Transform matrix
 * @param flags Flags to draw
 */
void ShaderNode::draw(Renderer *renderer, const Mat4 &transform, uint32_t flags)
{
	_customCommand.init(_globalZOrder);
	_customCommand.func = CC_CALLBACK_0(ShaderNode::onDraw, this, transform, flags);
	renderer->addCommand(&_customCommand);
}
コード例 #6
0
ファイル: SkillItem.cpp プロジェクト: duongbadu/FightGame
void SkillItem::onSkillStarted()
{
    this->setEnabled(false);
    
    ProgressTo *to1 = ProgressTo::create(getSkillCDTime(), 100);
    ProgressTimer *sprite = ProgressTimer::create(Sprite::create(this->getDisableIcon().c_str()));
    sprite->setType(ProgressTimer::Type::RADIAL);
    
    auto tint = Sequence::create(TintTo::create(getSkillCDTime(), 60, 255, 180),
                                 NULL);

    
    sprite->setPosition(Point(getContentSize().width / 2, getContentSize().height / 2));
    sprite->setBarChangeRate(Point(0, 1));
    addChild(sprite, 0, SKILL_ITEM_CHILD_TAG);
    sprite->runAction(Sequence::create(Spawn::create(to1, tint, NULL),CallFunc::create( CC_CALLBACK_0( SkillItem::onSkillCDFinished, this)) ,NULL) );


}
コード例 #7
0
ファイル: Gameboard.cpp プロジェクト: antidotcb/match3
    void Gameboard::afterSwap(Node* _Node) {
        if (firstArrived_ == nullptr) {
            CCLOG("checkSwapValid: First arrived, proceed further.");
            firstArrived_ = _Node;
            return;
        }

        firstArrived_ = nullptr;

        CCLOG("checkSwapValid: Second arrived, finally can check.");

        std::set<IPiece*> removal;
        score_->newSequence(checkResults_.size());
        for (auto vec : checkResults_) {
            uint32_t size = vec.size();
            CCLOG("Found %d pieces in row", size);

            uint32_t scoreValue = score_->addGroup(vec.size());
            for (IPiece* piece : vec) {

                board_->remove(piece->getCoords());

                Vec2 pos = coord2world(piece->getCoords());

                Sprite* sprite = piece->sprite();
                addScoreLabel(scoreValue, sprite->getPosition());
                addSomeEffects(sprite->getPosition());

                dissapear(piece);
            }
            removal.insert(vec.begin(), vec.end());

            CocosDenshion::SimpleAudioEngine::getInstance()->playEffect("remove.wav");
        }

        for (auto it = removal.begin(); it != removal.end(); ++it) {
            delete *it;
        }

        float longestAnimationTime = refill() * FalldownSpeed;
        float waitFalldownToComplete = longestAnimationTime + FastSpeed;

        if (!check()) {
            auto waitToUnlock = Sequence::create(
                    DelayTime::create(waitFalldownToComplete),
                    CallFunc::create(CC_CALLBACK_0(Gameboard::unlock, this)),
                    nullptr);
            runAction(waitToUnlock);
        } else {
            std::function<void(Node*)> cb;
            cb = CC_CALLBACK_1(Gameboard::afterSwap, this);

            // Hack - need to call it twice to make it do the job
            auto waitToRecheck = Sequence::create(
                    DelayTime::create(waitFalldownToComplete),
                    CallFuncN::create(cb),
                    CallFuncN::create(cb),
                    nullptr);

            runAction(waitToRecheck);
        }
    }
コード例 #8
0
//================================================================================
// シーン初期化
//================================================================================
// on "init" you need to initialize your instance
bool ResultScene::init()
{
    //////////////////////////////
    // 1. super init first
    if ( !Layer::init() )
    {
        return false;
    }
    
    Size visibleSize = Director::getInstance()->getVisibleSize() / 2 + SCREEN_CENTER;
    Vec2 origin = Director::getInstance()->getVisibleSize() / 2 - SCREEN_CENTER;
        
    AchievementDataBaseList::setAchievementMin(ACHIEVEMENT_TYPE_GAME_TIME, GAME_TIME_MAX - m_nTimeBornus);
    
    // 更新処理の追加
    this->scheduleUpdate();
    // タッチ機能の有効化
    m_pTouchEventOneByOne =  EventListenerTouchOneByOne::create();
    m_pTouchEventOneByOne->setSwallowTouches(true);
    m_pTouchEventOneByOne->onTouchBegan = CC_CALLBACK_2(ResultScene::onTouchBegin,this);
    m_pTouchEventOneByOne->onTouchMoved = CC_CALLBACK_2(ResultScene::onTouchMoved,this);
    m_pTouchEventOneByOne->onTouchCancelled = CC_CALLBACK_2(ResultScene::onTouchCancelled, this);
    m_pTouchEventOneByOne->onTouchEnded = CC_CALLBACK_2(ResultScene::onTouchEnded, this);
    this->getEventDispatcher()->addEventListenerWithFixedPriority(m_pTouchEventOneByOne, 100);
  
    //フラグに応じてゲームオーバ処理分岐
    void (ResultScene::*pFuncInit)();
    if(!m_bGameOverFlag)
    {
        pFuncInit = &ResultScene::initGameClear;
        m_pFuncUpdate = &ResultScene::updateGameClear;
        
    }else{
        pFuncInit = &ResultScene::initGameOver;
        m_pFuncUpdate = &ResultScene::updateGameOver;
        
    }
    
    (this->*pFuncInit)();
    
    //スコアとランク表示
    m_pRankManager = RankManager::create(Vec2(origin.x + 100,origin.y + 600),m_nTimeBornus, this);
    
    //ボタン表示
    MenuItemSprite* pButtonRetry;
    MenuItemSprite* pButtonTitle;
    
    //タップ前のスプライト
    Sprite* pNormalSprite = Sprite::create(TEX_RESULT_RETRY_BUTTON);
    pNormalSprite->setColor(Color3B(255,255,255));
    
    //タップ時のスプライト
    Sprite* pSelectedSprite = Sprite::create(TEX_RESULT_RETRY_BUTTON);
    pSelectedSprite->setColor(Color3B(200,200,200));
    pButtonRetry = MenuItemSprite::create(pNormalSprite,pSelectedSprite,CC_CALLBACK_0(ResultScene::ButtonRetry,this));
    
    Menu* pButton = Menu::create(pButtonRetry,NULL);
    addChild(pButton);
    
    //タイトルボタン
    //タップ前のスプライト
    Sprite* pNormalSprite2 = Sprite::create(TEX_RESULT_TITLE_BUTTON);
    pButton->setPosition(Vec2(visibleSize.width - pNormalSprite2->getContentSize().width / 2,origin.y + 240));
    pNormalSprite2->setColor(Color3B(255,255,255));

    
    //タップ時のスプライト
    Sprite* pSelectedSprite2 = Sprite::create(TEX_RESULT_TITLE_BUTTON);
    pSelectedSprite2->setColor(Color3B(200,200,200));

    pButtonTitle = MenuItemSprite::create(pNormalSprite2,pSelectedSprite2,CC_CALLBACK_0(ResultScene::ButtonTitle,this));

    pButton = Menu::create(pButtonTitle,NULL);
    pButton->setPosition(Vec2(visibleSize.width - pSelectedSprite2->getContentSize().width / 2,origin.y + 150));
    addChild(pButton);
    
    AchievementDataBaseList::saveAchievement();
    
     //今、BGMが流れているかどうか
     if(SimpleAudioEngine::getInstance()->isBackgroundMusicPlaying()){
     
         //音楽を止める
         SimpleAudioEngine::getInstance()->stopBackgroundMusic(true);
     
     }

    //音量調整
    SimpleAudioEngine::getInstance()->setBackgroundMusicVolume(BGM_RESULT_VOLUME);
    //BGMをループ再生 第二引数がループするかどうか判定
    SimpleAudioEngine::getInstance()->playBackgroundMusic(BGM_RESULT_1, true);
    
    
    return true;
}
コード例 #9
0
void SpineBatchNode::draw (Renderer* renderer, const Mat4& transform, uint32_t transformFlags) {
    _drawCommand.init(_globalZOrder);
    _drawCommand.func = CC_CALLBACK_0(SpineBatchNode::onDrawSkeletonBatch, this, transform, transformFlags);
    renderer->addCommand(&_drawCommand);
}
コード例 #10
0
ファイル: EnemyBase.cpp プロジェクト: slienthuang/Design
void EnemyBase::runRoute()
{
	goNextPoint();
	if (!m_isArriveEnd)
	{
		this->runAction(Sequence::create(MoveTo::create(getStepTime(), m_nextPoint), CallFuncN::create(CC_CALLBACK_0(EnemyBase::runRoute, this)), NULL));
	}
	else
	{
		EnemyManager::getInstance()->removeEnemy(this);
		this->removeFromParent();
	}
}
コード例 #11
0
void NodeGrid::visit(Renderer *renderer, const kmMat4 &parentTransform, bool parentTransformUpdated)
{
    // quick return if not visible. children won't be drawn.
    if (!_visible)
    {
        return;
    }
    
    _groupCommand.init(_globalZOrder);
    renderer->addCommand(&_groupCommand);
    renderer->pushGroup(_groupCommand.getRenderQueueID());

    bool dirty = parentTransformUpdated || _transformUpdated;
    if(dirty)
        _modelViewTransform = this->transform(parentTransform);
    _transformUpdated = false;

    // IMPORTANT:
    // To ease the migration to v3.0, we still support the kmGL stack,
    // but it is deprecated and your code should not rely on it
    kmGLPushMatrix();
    kmGLLoadMatrix(&_modelViewTransform);

    Director::Projection beforeProjectionType;
    if(_nodeGrid && _nodeGrid->isActive())
    {
        beforeProjectionType = Director::getInstance()->getProjection();
        _nodeGrid->set2DProjection();
    }

    _gridBeginCommand.init(_globalZOrder);
    _gridBeginCommand.func = CC_CALLBACK_0(NodeGrid::onGridBeginDraw, this);
    renderer->addCommand(&_gridBeginCommand);


    if(_gridTarget)
    {
        _gridTarget->visit(renderer, _modelViewTransform, dirty);
    }
    
    int i = 0;

    if(!_children.empty())
    {
        sortAllChildren();
        // draw children zOrder < 0
        for( ; i < _children.size(); i++ )
        {
            auto node = _children.at(i);

            if ( node && node->getLocalZOrder() < 0 )
                node->visit(renderer, _modelViewTransform, dirty);
            else
                break;
        }
        // self draw,currently we have nothing to draw on NodeGrid, so there is no need to add render command
        this->draw(renderer, _modelViewTransform, dirty);

        for(auto it=_children.cbegin()+i; it != _children.cend(); ++it) {
            (*it)->visit(renderer, _modelViewTransform, dirty);
        }
    }
    else
    {
        this->draw(renderer, _modelViewTransform, dirty);
    }
    
    // reset for next frame
    _orderOfArrival = 0;
    
    if(_nodeGrid && _nodeGrid->isActive())
    {
        // restore projection
        Director *director = Director::getInstance();
        director->setProjection(beforeProjectionType);
    }

    _gridEndCommand.init(_globalZOrder);
    _gridEndCommand.func = CC_CALLBACK_0(NodeGrid::onGridEndDraw, this);
    renderer->addCommand(&_gridEndCommand);

    renderer->popGroup();
 
    kmGLPopMatrix();
}
コード例 #12
0
ファイル: ScrollView.cpp プロジェクト: Eason-Xi/Tui-x
void CScrollView::beforeDraw()
{
	_beforeDrawCommand.init(_globalZOrder);
	_beforeDrawCommand.func = CC_CALLBACK_0(CScrollView::onBeforeDraw, this);
	Director::getInstance()->getRenderer()->addCommand(&_beforeDrawCommand);
}
コード例 #13
0
ファイル: Hills.cpp プロジェクト: jfb6486/MaoMaoPaoPaoDemo
void Hills::draw(Renderer* renderer, const Mat4 &transform, uint32_t flags) {
    Node::draw(renderer, transform, flags);
    rendererCommands[0].init(0.0f);
    rendererCommands[0].func = CC_CALLBACK_0(Hills::onDraw, this, transform);
    renderer->addCommand(&rendererCommands[0]);
}
コード例 #14
0
ファイル: GateResult.cpp プロジェクト: robert1111/fancyHeart
void GateResult::onEnter()
{
    BaseUI::onEnter();
    bool isWin=this->pResultResp.star()!=0;
    if (isWin) {
        Widget* img_bg=(Widget*)layout->getChildByName("img_bg");
        Button* btn_return=(Button*)layout->getChildByName("btn_return");
        btn_return->addTouchEventListener(CC_CALLBACK_2(GateResult::touchButtonEvent, this));
        img_bg->setVisible(false);
        btn_return->setVisible(false);
        Widget* panel_win=(Widget*)layout->getChildByName("panel_win");
        panel_win->setAnchorPoint(Vec2(0.5, 0.5));
        panel_win->setScale(0.2);
        panel_win->setVisible(true);
        Widget* img_round=(Widget*)panel_win->getChildByName("img_round");
        img_round->runAction(RepeatForever::create(RotateBy::create(1.0f, 360)));
        Clip* clip=Clip::create("winEffect.plist", "winEffect");
        clip->setPosition(panel_win->getContentSize().width/2,panel_win->getContentSize().height/2);
        clip->setScale(2, 2);
        panel_win->addChild(clip);
        clip->play(true);
        panel_win->runAction(Sequence::create(ScaleTo::create(0.3, 1),DelayTime::create(1),CCCallFunc::create(CC_CALLBACK_0(GateResult::resetUI, this)),CallFunc::create(CC_CALLBACK_0(Sprite::removeFromParent, panel_win)), NULL));
    }else{
        this->resetUI();
    }
    
    
}
コード例 #15
0
ファイル: RoleLayer.cpp プロジェクト: zhyswan/jump
void RoleLayer::draw(cocos2d::Renderer *renderer, const cocos2d::Mat4 &transform, uint32_t flags){
    //CCLOG("RoleLayer::draw");
    _customCommand.init(1);
    _customCommand.func = CC_CALLBACK_0(RoleLayer::onDraw, this,transform,flags);
    renderer->addCommand(&_customCommand);
}
コード例 #16
0
ファイル: WagonSelect.cpp プロジェクト: songmiao/WagonWar
void WagonSelect::createUI()
{
    auto bk =  Sprite::create("wagonselect_bk.png");
    if(g_visibleRect.visibleWidth>960)
    {
        bk->setScaleX(g_visibleRect.visibleWidth/960);
    }
    bk->setAnchorPoint(Point::ANCHOR_MIDDLE);
    bk->setPosition(g_visibleRect.center);
    this->addChild(bk);
    
    _wagon_bk = Sprite::create("wagon_bk.png");
    if(g_visibleRect.visibleWidth>960)
    {
        _wagon_bk->setScaleX(g_visibleRect.visibleWidth/960);
    }
    _wagon_bk->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
    _wagon_bk->setPosition(Point(130,280));
    this->addChild(_wagon_bk,1);
    
    //boy or girl
    _boy_memuitem = MenuItemImage::create("boy_0.png","boy_1.png",
                                                  CC_CALLBACK_1(WagonSelect::boy_selected_callback, this));
    _boy_memuitem->setAnchorPoint(Point::ANCHOR_MIDDLE);
    _boy_memuitem->setPosition(Point(60,g_visibleRect.visibleHeight/2+60));
    _boy_memuitem->selected();
    
    _girl_memuitem = MenuItemImage::create("girl_0.png","girl_1.png",
                                                 CC_CALLBACK_1(WagonSelect::girl_selected_callback, this));
    _girl_memuitem->setAnchorPoint(Point::ANCHOR_MIDDLE);
    _girl_memuitem->setPosition(Point(60,g_visibleRect.visibleHeight/2-60));
    
    auto menu = Menu::create(_boy_memuitem, _girl_memuitem, nullptr);
    menu->setPosition(Point::ZERO);
    this->addChild(menu,1);
    
    //
    MenuItemImage* ready_menu;
    if (_turntype == FIRST_TURN) {
        ready_menu = MenuItemImage::create("btn_ready_1.png","btn_ready_2.png",CC_CALLBACK_1(WagonSelect::ready_callback, this));
    }
    else if(_turntype == SECOND_TURN) {
        ready_menu = MenuItemImage::create("btn_start_1.png","btn_start_2.png",CC_CALLBACK_1(WagonSelect::ready_callback, this));
    }
    ready_menu->setPosition(Point(g_visibleRect.visibleWidth-120, g_visibleRect.visibleHeight-60));
    auto menu_ready = Menu::create(ready_menu, nullptr);
    menu_ready->setPosition(Point::ZERO);
    this->addChild(menu_ready,1);
    
    //
    _wagon1_menuitem = MenuItemImage::create("wagon_item_0.png","wagon_item_1.png",
                                                 CC_CALLBACK_1(WagonSelect::wagon1_selected_callback, this));
    _wagon1_menuitem->setAnchorPoint(Point::ANCHOR_MIDDLE);
    _wagon1_menuitem->setPosition(Point(120,g_visibleRect.visibleHeight/2-80));
    _wagon1_menuitem->selected();
    
    _wagon2_menuitem = MenuItemImage::create("wagon_item_0.png","wagon_item_1.png",
                                                 CC_CALLBACK_1(WagonSelect::wagon2_selected_callback, this));
    _wagon2_menuitem->setAnchorPoint(Point::ANCHOR_MIDDLE);
    _wagon2_menuitem->setPosition(Point(310,g_visibleRect.visibleHeight/2-80));
    
    _wagon3_menuitem = MenuItemImage::create("wagon_item_0.png","wagon_item_1.png",
                                                 CC_CALLBACK_1(WagonSelect::wagon3_selected_callback, this));
    _wagon3_menuitem->setAnchorPoint(Point::ANCHOR_MIDDLE);
    _wagon3_menuitem->setPosition(Point(500,g_visibleRect.visibleHeight/2-80));
    
    _wagon4_menuitem = MenuItemImage::create("wagon_item_0.png","wagon_item_1.png",
                                                 CC_CALLBACK_1(WagonSelect::wagon4_selected_callback, this));
    _wagon4_menuitem->setAnchorPoint(Point::ANCHOR_MIDDLE);
    _wagon4_menuitem->setPosition(Point(690,g_visibleRect.visibleHeight/2-80));
    
    auto menu_wagon = Menu::create(_wagon1_menuitem, _wagon2_menuitem, _wagon3_menuitem, _wagon4_menuitem, nullptr);
    menu_wagon->setPosition(Point::ZERO);
    _wagon_bk->addChild(menu_wagon,1);
    
    //
    auto wagon1 = Sprite::createWithSpriteFrame(SpriteFrameCache::getInstance()->getSpriteFrameByName("cnm_idle01.png"));
    wagon1->runAction(RepeatForever::create(g_gameConfig.getAnimate(g_gameAnimation.cnm_idle)));
    wagon1->setAnchorPoint(Point::ANCHOR_MIDDLE);
    wagon1->setPosition(Point(120,g_visibleRect.visibleHeight/2-10));
    wagon1->setScale(1.3f);
    _wagon_bk->addChild(wagon1, 2);
    
    auto wagon2 = Sprite::createWithSpriteFrame(SpriteFrameCache::getInstance()->getSpriteFrameByName("tankidle01.png"));
    wagon2->runAction(RepeatForever::create(g_gameConfig.getAnimate(g_gameAnimation.tank_idle)));
    wagon2->setAnchorPoint(Point::ANCHOR_MIDDLE);
    wagon2->setPosition(Point(310,g_visibleRect.visibleHeight/2-15));
    wagon2->setScale(1.3f);
    _wagon_bk->addChild(wagon2, 3);
    
    auto wagon3 = Sprite::createWithSpriteFrame(SpriteFrameCache::getInstance()->getSpriteFrameByName("rockidle01.png"));
    wagon3->runAction(RepeatForever::create(g_gameConfig.getAnimate(g_gameAnimation.rock_idle)));
    wagon3->setAnchorPoint(Point::ANCHOR_MIDDLE);
    wagon3->setPosition(Point(500,g_visibleRect.visibleHeight/2));
    wagon3->setScale(1.3f);
    _wagon_bk->addChild(wagon3, 3);
    
    auto wagon4_1 = Sprite::createWithSpriteFrame(SpriteFrameCache::getInstance()->getSpriteFrameByName("mechidle01.png"));
    wagon4_1->runAction(RepeatForever::create(g_gameConfig.getAnimate(g_gameAnimation.mech_idle)));
    wagon4_1->setAnchorPoint(Point::ANCHOR_MIDDLE);
    wagon4_1->setPosition(Point(700,g_visibleRect.visibleHeight/2-5));
    wagon4_1->setScale(1.3f);
    _wagon_bk->addChild(wagon4_1, 2);
    
    auto wagon4_2 = Sprite::createWithSpriteFrame(SpriteFrameCache::getInstance()->getSpriteFrameByName("mechgunidle01.png"));
    wagon4_2->runAction(RepeatForever::create(g_gameConfig.getAnimate(g_gameAnimation.mechgun_idle)));
    wagon4_2->setAnchorPoint(Point::ANCHOR_MIDDLE);
    wagon4_2->setPosition(Point(700,g_visibleRect.visibleHeight/2-20));
    wagon4_2->setScale(1.3f);
    _wagon_bk->addChild(wagon4_2, 3);

    //dude
    auto offsetPoint1 = Point(30.0f, 55.0f);
    _dude1 = Sprite::create("boy.png");
    _dude1->setAnchorPoint(Point(Point::ANCHOR_MIDDLE));
    _dude1->setPosition(wagon1->getPosition() + offsetPoint1);
    _dude1->setScale(1.3f);
    _wagon_bk->addChild(_dude1,2);

    auto offsetPoint2 = Point(20.0f, 65.0f);
    _dude2 = Sprite::create("boy.png");
    _dude2->setAnchorPoint(Point(Point::ANCHOR_MIDDLE));
    _dude2->setPosition(wagon2->getPosition() + offsetPoint2);
    _dude2->setScale(1.3f);
    _wagon_bk->addChild(_dude2,2);
    
    auto offsetPoint3 = Point(30.0f, 50.0f);
    _dude3 = Sprite::create("boy.png");
    _dude3->setAnchorPoint(Point(Point::ANCHOR_MIDDLE));
    _dude3->setPosition(wagon3->getPosition() + offsetPoint3);
    _dude3->setScale(1.3f);
    _wagon_bk->addChild(_dude3,2);
    
    auto offsetPoint4 = Point(10.0f, 55.0f);
    _dude4 = Sprite::create("boy.png");
    _dude4->setAnchorPoint(Point(Point::ANCHOR_MIDDLE));
    _dude4->setPosition(wagon4_1->getPosition() + offsetPoint4);
    _dude4->setScale(1.3f);
    _wagon_bk->addChild(_dude4,2);
    
    //shawdow
    auto shawdow1 = Sprite::create("shawdow.png");
    shawdow1->setAnchorPoint(Point::ANCHOR_MIDDLE);
    shawdow1->setPosition(Point(120,g_visibleRect.visibleHeight/2-70));
    shawdow1->setOpacity(200);
    _wagon_bk->addChild(shawdow1,2);

    auto shawdow2 = Sprite::create("shawdow.png");
    shawdow2->setAnchorPoint(Point::ANCHOR_MIDDLE);
    shawdow2->setPosition(Point(310,g_visibleRect.visibleHeight/2-70));
    shawdow2->setOpacity(200);
    _wagon_bk->addChild(shawdow2,2);

    auto shawdow3 = Sprite::create("shawdow.png");
    shawdow3->setAnchorPoint(Point::ANCHOR_MIDDLE);
    shawdow3->setPosition(Point(500,g_visibleRect.visibleHeight/2-70));
    shawdow3->setOpacity(200);
    _wagon_bk->addChild(shawdow3,2);

    auto shawdow4 = Sprite::create("shawdow.png");
    shawdow4->setAnchorPoint(Point::ANCHOR_MIDDLE);
    shawdow4->setPosition(Point(690,g_visibleRect.visibleHeight/2-70));
    shawdow4->setOpacity(200);
    _wagon_bk->addChild(shawdow4,2);

    // params
    initWagonParams();
    
    // name
    TTFConfig horseyTTFConfig;
    horseyTTFConfig.outlineSize = 3;
    horseyTTFConfig.fontSize = 30;
    horseyTTFConfig.fontFilePath = "fonts/britanic bold.ttf";
    auto horseyLabel = Label::createWithTTF(horseyTTFConfig, "HORSEY", TextHAlignment::CENTER, 20);
    horseyLabel->setPosition(120,g_visibleRect.visibleHeight/2-110);
    //horseyLabel->setSpacing(-5);
    horseyLabel->setAnchorPoint(Point::ANCHOR_MIDDLE);
    horseyLabel->enableOutline(Color4B::BLACK);
    _wagon_bk->addChild(horseyLabel,2);
    
    TTFConfig tankTTFConfig;
    tankTTFConfig.outlineSize = 3;
    tankTTFConfig.fontSize = 30;
    tankTTFConfig.fontFilePath = "fonts/britanic bold.ttf";
    auto tankLabel = Label::createWithTTF(horseyTTFConfig, "TANK", TextHAlignment::CENTER, 20);
    tankLabel->setPosition(310,g_visibleRect.visibleHeight/2-110);
    //tankLabel->setSpacing(-5);
    tankLabel->setAnchorPoint(Point::ANCHOR_MIDDLE);
    tankLabel->enableOutline(Color4B::BLACK);
    _wagon_bk->addChild(tankLabel,2);
    
    TTFConfig rockTTFConfig;
    rockTTFConfig.outlineSize = 3;
    rockTTFConfig.fontSize = 30;
    rockTTFConfig.fontFilePath = "fonts/britanic bold.ttf";
    auto rockLabel = Label::createWithTTF(horseyTTFConfig, "ROCK", TextHAlignment::CENTER, 20);
    rockLabel->setPosition(500,g_visibleRect.visibleHeight/2-110);
    //rockLabel->setSpacing(-5);
    rockLabel->setAnchorPoint(Point::ANCHOR_MIDDLE);
    rockLabel->enableOutline(Color4B::BLACK);
    _wagon_bk->addChild(rockLabel,2);
    
    TTFConfig mechTTFConfig;
    mechTTFConfig.outlineSize = 3;
    mechTTFConfig.fontSize = 30;
    mechTTFConfig.fontFilePath = "fonts/britanic bold.ttf";
    auto mechLabel = Label::createWithTTF(horseyTTFConfig, "MECH", TextHAlignment::CENTER, 20);
    mechLabel->setPosition(690,g_visibleRect.visibleHeight/2-110);
    //mechLabel->setSpacing(-5);
    mechLabel->setAnchorPoint(Point::ANCHOR_MIDDLE);
    mechLabel->enableOutline(Color4B::BLACK);
    _wagon_bk->addChild(mechLabel,2);
    
    // flash
    flash = Sprite::create("wagon_flash.png");
    flash->setAnchorPoint(Point::ANCHOR_MIDDLE);
    flash->setPosition(Point(120,g_visibleRect.visibleHeight/2-80));
    flash->runAction(RepeatForever::create(Blink::create(1,1)));
    _wagon_bk->addChild(flash,3);
    
    auto returnMenuListener = EventListenerCustom::create("returntoMenu", CC_CALLBACK_0(WagonSelect::returntoMenu, this));
    _eventDispatcher->addEventListenerWithSceneGraphPriority(returnMenuListener, this);
    
    auto wagonselectshowpopwindowlistener = EventListenerCustom::create("wagonselectshowpopwindowlistener", CC_CALLBACK_0(WagonSelect::showConnectingPopWindow, this));
    _eventDispatcher->addEventListenerWithSceneGraphPriority(wagonselectshowpopwindowlistener, this);
}
コード例 #17
0
ファイル: UI.cpp プロジェクト: destiny14/FlyingSquirrel
void UI::createLevelEditorUI()
{
	Size visibleSize = Director::getInstance()->getVisibleSize();
	auto labelMenuTitle = LabelTTF::create("Level Editor", "Segoe UI", 12);
	labelMenuTitle->setPosition(35.0f, visibleSize.height - 40.0f);
	m_pLevelEditor->addChild(labelMenuTitle);

	MenuItemImage* sidebarBackground = MenuItemImage::create("Resources/pictures/generic/ui_background.png", "ui_background.png", CC_CALLBACK_0(UI::nullCallback, this));
	sidebarBackground->setPosition(100.0f, visibleSize.height * 0.5f);
	sidebarBackground->setScale(200, visibleSize.height);

	MenuItemFont* addTextureObject = MenuItemFont::create("add texture", CC_CALLBACK_1(LevelEditor::addTextureObjectCallback, pLevelEditor));
	addTextureObject->setFontNameObj("Arial");
	addTextureObject->setFontSizeObj(30);
	addTextureObject->setPosition(80.0f, visibleSize.height - 80.0f);

	MenuItemFont* addGroundObject = MenuItemFont::create("add ground", CC_CALLBACK_1(LevelEditor::addGroundObjectCallback, pLevelEditor));
	addGroundObject->setFontNameObj("Arial");
	addGroundObject->setFontSizeObj(30);
	addGroundObject->setPosition(80.0f, visibleSize.height - 120.0f);

	MenuItemFont* addNutObject = MenuItemFont::create("add nut", CC_CALLBACK_1(LevelEditor::addNutObjectCallback, pLevelEditor));
	addNutObject->setFontNameObj("Arial");
	addNutObject->setFontSizeObj(30);
	addNutObject->setPosition(80.0f, visibleSize.height - 160.0f);

	MenuItemFont* addCrystalObject = MenuItemFont::create("add crystal", CC_CALLBACK_1(LevelEditor::addCrystalObjectCallback, pLevelEditor));
	addCrystalObject->setFontNameObj("Arial");
	addCrystalObject->setFontSizeObj(30);
	addCrystalObject->setPosition(80.0f, visibleSize.height - 200.0f);

	MenuItemFont* addAirObject = MenuItemFont::create("add aircurrent", CC_CALLBACK_1(LevelEditor::addAirObjectCallback, pLevelEditor));
	addAirObject->setFontNameObj("Arial");
	addAirObject->setFontSizeObj(30);
	addAirObject->setPosition(80.0f, visibleSize.height - 240.0f);

	MenuItemFont* changeLayerObject = MenuItemFont::create("mainLayer", CC_CALLBACK_0(LevelEditor::changeLayerCallback, pLevelEditor));
	changeLayerObject->setFontNameObj("Arial");
	changeLayerObject->setFontSizeObj(30);
	changeLayerObject->setPosition(73.0f, visibleSize.height - 280.0f);
	changeLayerObject->setTag(111);

	MenuItemFont* toggleGrid = MenuItemFont::create("snap to grid", CC_CALLBACK_0(LevelEditor::toggleGridCallback, pLevelEditor));
	toggleGrid->setFontNameObj("Arial");
	toggleGrid->setFontSizeObj(30);
	toggleGrid->setPosition(80.0f, visibleSize.height - 320.0f);
	toggleGrid->setTag(112);

	MenuItemFont* toggleSelectionMode = MenuItemFont::create("selection", CC_CALLBACK_0(LevelEditor::toggleSelectionMode, pLevelEditor));
	toggleSelectionMode->setFontNameObj("Arial");
	toggleSelectionMode->setFontSizeObj(30);
	toggleSelectionMode->setPosition(80.0f, visibleSize.height - 360.0f);
	toggleSelectionMode->setTag(113);

	MenuItemFont* saveLevelObject = MenuItemFont::create("save level", CC_CALLBACK_0(LevelEditor::saveLevelCallback, pLevelEditor));
	saveLevelObject->setFontNameObj("Arial");
	saveLevelObject->setFontSizeObj(30);
	saveLevelObject->setPosition(70.0f, visibleSize.height - 400.0f);

	MenuItemFont* mainMenuObject = MenuItemFont::create("Mainmenu", CC_CALLBACK_0(LevelEditor::mainMenuCallback, pLevelEditor));
	mainMenuObject->setFontNameObj("Arial");
	mainMenuObject->setFontSizeObj(30);
	mainMenuObject->setPosition(70.0f, visibleSize.height - 440.0f);

	auto menu = Menu::create(addTextureObject, addGroundObject, addNutObject, addCrystalObject, addAirObject, changeLayerObject, toggleSelectionMode, saveLevelObject, toggleGrid, mainMenuObject, NULL);
	auto menuBackground = Menu::create(sidebarBackground, NULL);
	menuBackground->setPosition(0, 0);
	menu->setPosition(0, 0);
	m_pLevelEditor->addChild(menu);
	m_pLevelEditor->addChild(menuBackground, -10);
	pLevelEditor->MainMenu = menu;
}
コード例 #18
0
ファイル: CCScrollView.cpp プロジェクト: Alprog/LHR2
void ScrollView::afterDraw()
{
    _afterDrawCommand.init(_globalZOrder);
    _afterDrawCommand.func = CC_CALLBACK_0(ScrollView::onAfterDraw, this);
    Director::getInstance()->getRenderer()->addCommand(&_afterDrawCommand);
}
コード例 #19
0
ファイル: HWindow.cpp プロジェクト: joyfish/Shoot
void HWindow::startAnim(){
    if (m_tips) {
        Node* tips_bg = m_tips->getChildByName("bg");
        Point pre_pos = tips_bg->getPosition();
        
        switch (m_anim_type) {
            case WINDOW_ANIM_TOP:
                tips_bg->setPosition(Point(pre_pos.x, _pTop+480));
                tips_bg->runAction(Sequence::create(MoveTo::create(0.3f, Point(pre_pos.x, pre_pos.y-20)),MoveTo::create(0.1f, Point(pre_pos.x, pre_pos.y+10)),MoveTo::create(0.1f, Point(pre_pos.x, pre_pos.y)),CallFunc::create(CC_CALLBACK_0(HWindow::onStartAnimOver, this)), NULL));
                break;
            case WINDOW_ANIM_RIGHT:
                tips_bg->setPosition(Point(_pRight+640, pre_pos.y));
                tips_bg->runAction(Sequence::create(MoveTo::create(0.3f, Point(pre_pos.x-20, pre_pos.y)),MoveTo::create(0.1f, Point(pre_pos.x+10, pre_pos.y)),MoveTo::create(0.1f, Point(pre_pos.x, pre_pos.y)),CallFunc::create(CC_CALLBACK_0(HWindow::onStartAnimOver,this)),NULL));
                break;
            case WINDOW_ANIM_LEFT:
                tips_bg->setPosition(Point(_pLeft-640, pre_pos.y));
                tips_bg->runAction(Sequence::create(MoveTo::create(0.3f, Point(pre_pos.x+20, pre_pos.y)),MoveTo::create(0.1f, Point(pre_pos.x-10, pre_pos.y)),MoveTo::create(0.1f, Point(pre_pos.x, pre_pos.y)),CallFunc::create(CC_CALLBACK_0(HWindow::onStartAnimOver,this)),NULL));
                break;
            case WINDOW_ANIM_BOTTOM:
                tips_bg->setPosition(Point(pre_pos.x, _pBottom - 480));
                tips_bg->runAction(Sequence::create(MoveTo::create(0.3f, Point(pre_pos.x, pre_pos.y+20)),MoveTo::create(0.1f, Point(pre_pos.x, pre_pos.y-10)),MoveTo::create(0.1f, Point(pre_pos.x, pre_pos.y)),CallFunc::create(CC_CALLBACK_0(HWindow::onStartAnimOver, this)), NULL));
                break;
            default:
                onStartAnimOver();
                break;
        }
        
    }
}
コード例 #20
0
ファイル: TileMapTest.cpp プロジェクト: jiaozicat/cocos2d-x
void TMXIsoObjectsTest::draw(Renderer *renderer, const Mat4 &transform, uint32_t flags)
{
    _renderCmd.init(_globalZOrder);
    _renderCmd.func = CC_CALLBACK_0(TMXIsoObjectsTest::onDraw, this, transform, flags);
    renderer->addCommand(&_renderCmd);
}
コード例 #21
0
ファイル: ChoseLevel.cpp プロジェクト: Tearingsun/EndlessWar
bool ChoseLevel::init(PhysicsWorld* world){
	if (!Layer::init()){
		return false;
	}
	m_world = world;
	visibleSize = Director::getInstance()->getVisibleSize();
	origin = Director::getInstance()->getVisibleOrigin();

	if (!database->getBoolForKey("isExit")){
		database->setBoolForKey("isExit", true);
		database->setIntegerForKey("nowLevel",0);
		database->setIntegerForKey("nowStage",0);
		level = 0;
		stage = 0;
	}
	else{
		level = database->getIntegerForKey("nowLevel");
		stage = database->getIntegerForKey("nowStage");
	}

	Sprite* bgImage = Sprite::create("images/bg.png");
	bgImage->setPosition(visibleSize.width/2, visibleSize.height/2);
	this->addChild(bgImage,1);

	auto homeItem = MenuItemImage::create("images/home.png","images/home.png",CC_CALLBACK_0(ChoseLevel::backHome,this));
	auto homeMenu = Menu::createWithItem(homeItem);
	this->addChild(homeMenu,5);
	homeMenu->setPosition(visibleSize.width-homeItem->getContentSize().width/2, visibleSize.height-homeItem->getContentSize().height/2);

	//auto levelOne = MenuItemLabel::create(Label::createWithTTF("Zero","fonts/arial.ttf",40),
	//													CC_CALLBACK_0(ChoseLevel::selectLevel,this,0));
	//levelOne->setPosition(-2*levelOne->getContentSize().width,0);
	//auto levelTwo = MenuItemLabel::create(Label::createWithTTF("One", "fonts/arial.ttf", 40),
	//													CC_CALLBACK_0(ChoseLevel::selectLevel, this, 1));
	//levelTwo->setPosition(0,0);
	//auto levelThree = MenuItemLabel::create(Label::createWithTTF("Two", "fonts/arial.ttf", 40),
	//													CC_CALLBACK_0(ChoseLevel::selectLevel, this, 2));
	//levelThree->setPosition(2 * levelThree->getContentSize().width, 0);
	//auto choseMenu = Menu::create(levelOne,levelTwo,levelThree,NULL);

	//choseMenu->setPosition(visibleSize.width/2,visibleSize.height/2);
	//this->addChild(choseMenu,2);

	auto menuBg = Sprite::create("images/scroll.png");
	menuBg->setPosition(visibleSize.width/2, visibleSize.height/2);
	this->addChild(menuBg,2);

	Vector<MenuItem*> levels;
	MenuItemSprite* levelItem;
	/*
	for (int i = 0; i < unlock; i++){
		auto normalSprite = Sprite::create("images/levelImage.png");
		auto selectedSprite = Sprite::create("images/levelImage.png");
		selectedSprite->setOpacity(200);
		levelItem = MenuItemSprite::create(normalSprite, selectedSprite, CC_CALLBACK_0(ChoseLevel::selectLevel,this,i));
		levelItem->setPosition(i*levelItem->getContentSize().width*3/2,0);
		
		auto levelStr = String::createWithFormat("%d",i+1);
		auto levelLabel = Label::createWithTTF(levelStr->getCString(),"fonts/arial.ttf",40);
		levelLabel->setPosition(levelItem->getContentSize().width/2, levelItem->getContentSize().height/2);
		levelItem->addChild(levelLabel);
		levels.pushBack(levelItem);
	}*/
	
	int count = 0;

	for (int i = 0; i < 3; i++) {
		for (int j = 0; j < 2; j++){
			auto normalSprite = Sprite::create("images/levelImage.png");
			auto selectedSprite = Sprite::create("images/levelImage.png");
			selectedSprite->setOpacity(200);
			levelItem = MenuItemSprite::create(normalSprite, selectedSprite);
			levelItem->setPosition(i*levelItem->getContentSize().width*3/2, -j*levelItem->getContentSize().height*3/2);

			if (count <= level){
				levelItem->setCallback(CC_CALLBACK_0(ChoseLevel::selectLevel, this, count));
				auto levelStr = String::createWithFormat("%d", count + 1);
				auto levelLabel = Label::createWithTTF(levelStr->getCString(), "fonts/arial.ttf", 40);
				levelLabel->setPosition(levelItem->getContentSize().width / 2, levelItem->getContentSize().height / 2);
				levelItem->addChild(levelLabel);
				count++;
			}
			else{
				auto lock = Sprite::create("images/locked.png");
				lock->setPosition(levelItem->getContentSize().width / 2, levelItem->getContentSize().height / 2);
				levelItem->addChild(lock);
			}

			levels.pushBack(levelItem);
		}
	}

	auto levelMenu = Menu::createWithArray(levels);
	levelMenu->setPosition(visibleSize.width / 2 - levelItem->getContentSize().width * 3 / 2, visibleSize.height / 2 + levelItem->getContentSize().width/10*7);
	this->addChild(levelMenu,3);

	return true;
}
コード例 #22
0
ファイル: Monster3.cpp プロジェクト: gamdekong/combat_project
void Monster3::HittedAction()
{
	Animation *animation = Animation::create();
	animation->setDelayPerUnit(0.1);
	switch (monsterNum)
	{
	case BEAST:
		animation->addSpriteFrameWithTexture(monster, Rect(0, 360, 120, 120));
		animation->addSpriteFrameWithTexture(monster, Rect(120, 360, 120, 120));

		break;

	case BIRD:
		animation->addSpriteFrameWithTexture(monster, Rect(0, 360, 120, 120));
		animation->addSpriteFrameWithTexture(monster, Rect(120, 360, 120, 120));
		animation->addSpriteFrameWithTexture(monster, Rect(240, 360, 120, 120));

		break;
	case DOG:
		animation->addSpriteFrameWithTexture(monster, Rect(0, 360, 120, 120));
		animation->addSpriteFrameWithTexture(monster, Rect(120, 360, 120, 120));
		animation->addSpriteFrameWithTexture(monster, Rect(240, 360, 120, 120));

		break;
	case BAT:
		animation->addSpriteFrameWithTexture(monster, Rect(0, 240, 120, 120));
		animation->addSpriteFrameWithTexture(monster, Rect(120, 240, 120, 120));
		animation->addSpriteFrameWithTexture(monster, Rect(240, 240, 120, 120));
		animation->addSpriteFrameWithTexture(monster, Rect(360, 240, 120, 120));
		animation->addSpriteFrameWithTexture(monster, Rect(480, 240, 120, 120));
		break;
	case SNAKE:
		animation->addSpriteFrameWithTexture(monster, Rect(0, 360, 120, 120));
		animation->addSpriteFrameWithTexture(monster, Rect(120, 360, 120, 120));
		animation->addSpriteFrameWithTexture(monster, Rect(240, 360, 120, 120));

		break;
	case SOUL:
		animation->addSpriteFrameWithTexture(monster, Rect(0, 240, 120, 120));
		animation->addSpriteFrameWithTexture(monster, Rect(120, 240, 120, 120));
		animation->addSpriteFrameWithTexture(monster, Rect(240, 240, 120, 120));

		break;
	case SWORND:
		animation->addSpriteFrameWithTexture(monster, Rect(0, 240, 120, 120));
		animation->addSpriteFrameWithTexture(monster, Rect(120, 240, 120, 120));
		animation->addSpriteFrameWithTexture(monster, Rect(240, 240, 120, 120));

		break;
	case WORM:
		animation->addSpriteFrameWithTexture(monster, Rect(0, 360, 120, 120));
		animation->addSpriteFrameWithTexture(monster, Rect(120, 360, 120, 120));
		animation->addSpriteFrameWithTexture(monster, Rect(240, 360, 120, 120));
		animation->addSpriteFrameWithTexture(monster, Rect(360, 360, 120, 120));
		animation->addSpriteFrameWithTexture(monster, Rect(480, 360, 120, 120));
		break;
	}
	auto animate = Animate::create(animation);
	auto seq = Sequence::create(animate, CallFunc::create(CC_CALLBACK_0(Monster3::IdleAction, this)), nullptr);
	this->stopAllActions();
	this->runAction(seq);
}
コード例 #23
0
void HelloWorld::draw(cocos2d::Renderer* renderer, const cocos2d::Mat4 &transform, uint32_t flags){
     _customCommand.init(_globalZOrder);
     _customCommand.func=CC_CALLBACK_0(HelloWorld::onDraw, this,transform,flags);
     renderer->addCommand(&_customCommand);
}
コード例 #24
0
ファイル: GameGuiLayer.cpp プロジェクト: joyfish/cocos2d
bool GameGuiLayer::init(){
	if ( !Layer::init() )
	{
		return false;
	}
	Size visibleSize = Director::getInstance()->getVisibleSize();
	//add pause btn to this layer
	MenuItemImage* start_btn = MenuItemImage::create("btn_bg_normal.png","btn_bg_click.png",CC_CALLBACK_0(GameGuiLayer::pauseGame,this));
	Menu* start_game = Menu::create(start_btn,NULL);
	start_game->setPosition(50,visibleSize.height-50);
	this->addChild(start_game);


	initTime();
	scheduleUpdate();
	return true;
}
コード例 #25
0
void HelloWorld::draw(Renderer *renderer, const Mat4& transform, uint32_t flags)
{
	mCustomCommand.init(0);
	mCustomCommand.func = CC_CALLBACK_0(HelloWorld::onDraw, this, transform, flags);
	renderer->addCommand(&mCustomCommand);
}
コード例 #26
0
void Block::initBlock() {

    // 빌딩과 루프에 대한 스프라이트 프레임 레퍼런스 보관
    _tile1 = CCSpriteFrameCache::getInstance()->getSpriteFrameByName ("building_1.png");
    _tile2 = CCSpriteFrameCache::getInstance()->getSpriteFrameByName ("building_2.png");
    _tile3 = CCSpriteFrameCache::getInstance()->getSpriteFrameByName ("building_3.png");
    _tile4 = CCSpriteFrameCache::getInstance()->getSpriteFrameByName ("building_4.png");
    _tile1->getTexture()->setAliasTexParameters();
    _tile2->getTexture()->setAliasTexParameters();
    _tile3->getTexture()->setAliasTexParameters();
    _tile4->getTexture()->setAliasTexParameters();
    
    _roof1 = CCSpriteFrameCache::getInstance()->getSpriteFrameByName ("roof_1.png");
    _roof2 = CCSpriteFrameCache::getInstance()->getSpriteFrameByName ("roof_2.png");
    _roof1->getTexture()->setAliasTexParameters();
    _roof2->getTexture()->setAliasTexParameters();
    

    //create tiles
    int i;
    
    // 벽은 20개 보관
    _wallTiles.reserve(20);
    //= CCArray::createWithCapacity(20);
//    _wallTiles.retain();

    // 지붕은 5개 보관
    _roofTiles.reserve(5);
  //  _roofTiles = CCArray::createWithCapacity(5);
  //  _roofTiles->retain();

    
    Sprite * tile;
    
    // 미리 roof_1 스프라이트를 5장 준비하여 보관, x는 5장 옆으로 y는 0, 크기는 138, 즉 -138까지 지붕
    // 미리 building_1 스프라이트를 20장 준비하여 보관, x는 5장 옆으로 y는 47, -120정도 부터 배치
    // 즉 눈에 보이지 않는 화면 아래에 5장 정도로 깔아둔다.
    for (i = 0; i < 5; i++) {
        tile = CCSprite::createWithSpriteFrameName("roof_1.png");
        tile->getTexture()->setAliasTexParameters();
        tile->setAnchorPoint(Point(0, 1));
        tile->setPosition(Point(i * _tileWidth, 0));
        tile->setVisible(false);
        this->addChild(tile, kMiddleground, kRoofTile);
        _roofTiles.pushBack(tile);
 //       _roofTiles->addObject(tile);
        
        for (int j = 0; j < 4; j++) {
            tile = Sprite::createWithSpriteFrameName("building_1.png");
            tile->getTexture()->setAliasTexParameters();
            tile->setAnchorPoint(Point(0, 1));
            tile->setPosition(Point(i * _tileWidth, -1 * (_tileHeight * 0.47f + j * _tileHeight)));
            tile->setVisible(false);
            this->addChild(tile, kBackground, kWallTile);
            _wallTiles.pushBack(tile);
 //           _wallTiles->addObject(tile);
        }
        
    }
    
    _chimneys.reserve(5);
//    _chimneys = CCArray::createWithCapacity(5);
//    _chimneys->retain();
    
    
    Sprite * chimney;
    Sprite * puff;
    
    // 타일을 옆으로 5장이니 굴뚝도 5장인가?
    for (i = 0; i < 5; i++) {
        chimney = Sprite::createWithSpriteFrameName("chimney.png");
        chimney->getTexture()->setAliasTexParameters();
        chimney->setVisible(false);
        this->addChild(chimney, kForeground, kChimney);
 
        _chimneys.pushBack(chimney);
//        _chimneys->addObject(chimney);
        
        for (int j = 0; j < TOTAL_PUFFS; j++) {
            puff = Sprite::createWithSpriteFrameName("puff_1.png");
            puff->getTexture()->setAliasTexParameters();
            puff->setAnchorPoint(Point(0,-0.5));
            puff->setVisible(false);
            chimney->addChild(puff, -1, j);
        }
        
    }
    
    
    Animation* animation;
    animation = Animation::create();
    SpriteFrame * frame;

    for(i = 1; i <= 4; i++) {
        char szName[100] = {0};
        sprintf(szName, "puff_%i.png", i);
        frame = SpriteFrameCache::getInstance()->getSpriteFrameByName(szName);
        frame->getTexture()->setAliasTexParameters();
        animation->addSpriteFrame(frame);
    }

    animation->setDelayPerUnit(0.75f / 4.0f);
    animation->setRestoreOriginalFrame(false);
    animation->setLoops(-1);
    _puffAnimation = CCAnimate::create(animation);
    _puffAnimation->retain();

    // docgkill
    _puffSpawn = Repeat::create(Sequence::create(DelayTime::create(0.5f),
                                                 CallFuncN::create( CC_CALLBACK_0(Block::createPuff, this) ),
                                                 NULL
                                                 ),
                                TOTAL_PUFFS
                                );
    _puffSpawn->retain();
    
 //   this->runAction(_puffSpawn->clone());

    _puffMove = MoveBy::create(1.0f, Point(-100,80));
    _puffMove->retain();
    _puffFade = CCFadeOut::create(2.0f);
    _puffFade->retain();
    _puffScale = CCScaleBy::create(1.5f, 1.5);
    _puffScale->retain();
    
    _puffIndex = 0;
}
コード例 #27
0
void MainMenuScene::license(Ref* sender){
    license_item->runAction(Sequence::create(ScaleTo::create(0.1f, 0.8f),
                                               ScaleTo::create(0.1f, 0.6f),
                                               ScaleTo::create(0.1f, 0.7f),
                                             CallFunc::create(CC_CALLBACK_0(MainMenuScene::license_callback, this)),NULL));
}
コード例 #28
0
ファイル: GameScene.cpp プロジェクト: yw920/dota
void GameScene::addTouchListener()
{
    
    auto touchListener = EventListenerTouchOneByOne::create();
    touchListener->onTouchBegan = [this](Touch* t,Event* e)->bool{
        auto menuCoo = menu->convertToNodeSpace(t->getLocation());
        Rect oldAABB =  buttonCoco->getBoundingBox();
        Vec2 oldVec = oldAABB.origin;
        Vec2 newVec = oldVec-buttonCoco->getContentSize()/2;
        Rect newAABB(newVec.x,newVec.y,oldAABB.size.width,oldAABB.size.height);
        
        if(mpProgressTimer->getPercentage()==100.0f&&newAABB.containsPoint(menuCoo)){
            isMagic = true;
            coco->playAnimation(BaseSprite::State::magic);
            if(!eff){
             eff = EffSprite::create("pfca/effect/eff_point_Coco_ult.fca", "effect/eff_point_Coco_ult");
            this->addChild(eff);
            }
            eff->setVisible(true);
            eff->setPosition(0-_director->getWinSize().width/2,0);
            eff->playAnimation(BaseSprite::State::magic,CallFunc::create(CC_CALLBACK_0(GameScene::effectCallback, this)));
            
            mpProgressTimer->setPercentage(0.f);
            
        }
        
        return true;
    };
    
    auto hurtLisener = EventListenerCustom::create("hurt", [this](EventCustom* e)->void{
      
        auto hurtObject = (BaseSprite*)e->getUserData();
        Label* l = nullptr;
       ProgressTimer* hp = nullptr;
        if(hurtObject==boss){
            l = l1;
            hp = effectHpProgressTimer[0];
            
        }else{
            l  = l2;
            hp = effectHpProgressTimer[1];
        }
        if(dynamic_cast<TreeBoss*>(hurtObject)){
            l->setPosition(hurtObject->getPosition()+Vec2(_director->getWinSize().width/2,_director->getWinSize().height/2+200));
            hp->setPosition(hurtObject->getPosition()+Vec2(_director->getWinSize().width/2,_director->getWinSize().height/2+180));
            
        }
        else{
              l->setPosition(hurtObject->getPosition()+Vec2(_director->getWinSize().width/2,_director->getWinSize().height/2+100));
            hp->setPosition(hurtObject->getPosition()+Vec2(_director->getWinSize().width/2,_director->getWinSize().height/2+130));
        }
       
        hp->setPercentage((hurtObject->getProperty().curLife/hurtObject->getProperty().maxLife)*100);

        
        
        l->setString("-"+Value((int)hurtObject->getCurHurt()).asString());
        if(!l->getParent()){
           
            this->addChild(l,3);
        }
        if(!hp->getParent()){
            this->addChild(hp,3);
        }
        hp->setVisible(true);
        if(!l->isVisible()){
            l->setVisible(true);
            l->setOpacity(255);
        }
        auto move = MoveBy::create(0.5f, Vec2(0,20));
        auto fade = FadeOut::create(0.5f);
        
        l->runAction(Sequence::create(move, fade,CallFunc::create(std::bind(&GameScene::lableCallback, this,l)),nullptr));
        
        hp->runAction(Sequence::create(DelayTime::create(1.0f),CallFuncN::create([](Node* n){
            n->setVisible(false);
        }), NULL));
    });
    
    
    _eventDispatcher->addEventListenerWithSceneGraphPriority(touchListener,buttonCoco);
    _eventDispatcher->addEventListenerWithSceneGraphPriority(hurtLisener,this);
    
    
}
コード例 #29
0
//================================================================================
// シーン初期化
//================================================================================
bool PauseScene::init()
{
    //////////////////////////////
    // 1. super init first
    if ( !Layer::init() )
    {
        return false;
    }

    Size visibleSize = Director::getInstance()->getVisibleSize() / 2 + SCREEN_CENTER;
    Vec2 origin = Director::getInstance()->getVisibleSize() / 2 - SCREEN_CENTER;

    //終了ボタン生成
    auto closeItem = MenuItemImage::create(
                                           "CloseNormal.png",
                                           "CloseSelected.png",
                                           CC_CALLBACK_1(PauseScene::menuCloseCallback, this));

    closeItem->setPosition(Vec2(origin.x + visibleSize.width - closeItem->getContentSize().width/2 ,
                                origin.y + closeItem->getContentSize().height/2));

    // create menu, it's an autorelease object
    auto menu = Menu::create(closeItem, NULL);
    menu->setPosition(Vec2::ZERO);
    this->addChild(menu, 1);

    // 更新処理の追加
    this->scheduleUpdate();
    
    // タッチ機能の有効化
    m_pTouchEventOneByOne =  EventListenerTouchOneByOne::create();
    m_pTouchEventOneByOne->setSwallowTouches(true);
    m_pTouchEventOneByOne->onTouchBegan = CC_CALLBACK_2(PauseScene::onTouchBegin,this);
    m_pTouchEventOneByOne->onTouchMoved = CC_CALLBACK_2(PauseScene::onTouchMoved,this);
    m_pTouchEventOneByOne->onTouchCancelled = CC_CALLBACK_2(PauseScene::onTouchCancelled, this);
    m_pTouchEventOneByOne->onTouchEnded = CC_CALLBACK_2(PauseScene::onTouchEnded, this);
    this->getEventDispatcher()->addEventListenerWithFixedPriority(m_pTouchEventOneByOne, 2);

    // 薄暗いスプライトを作成
    m_pMaskSprite = Sprite::create();
    m_pMaskSprite->setTextureRect(Rect(0,0,visibleSize.width,visibleSize.height));
    m_pMaskSprite->setColor(Color3B::BLACK);
    m_pMaskSprite->setOpacity(125);
    m_pMaskSprite->setPosition(Vec2(visibleSize.width / 2,visibleSize.height / 2));
    this->addChild(m_pMaskSprite);

    // メニューバースプライトの作成
    m_pMenuBarSpriteBase = Sprite::create(TEX_MENU_BUTTON);
    Sprite* pMenuBarSpriteSelected = Sprite::create(TEX_MENU_BUTTON);
    pMenuBarSpriteSelected->setColor(Color3B(200,200,200));
    MenuItemSprite* pMenuBarMenuItemSprite = MenuItemSprite::create(m_pMenuBarSpriteBase, pMenuBarSpriteSelected,
                                                                     CC_CALLBACK_0(PauseScene::returnGameCallback, this));
    pMenuBarMenuItemSprite->setPosition(Vec2(565, visibleSize.height - 32));

    // ゲーム再開メニュースプライトの作成
    m_pReturnGameSpriteBase = Sprite::create(TEX_BUTTON_RETURN_GAME);
    Sprite* pReturnGameSpriteSelected = Sprite::create(TEX_BUTTON_RETURN_GAME);
    pReturnGameSpriteSelected->setColor(Color3B(200,200,200));
    MenuItemSprite* pReturnGameMenuItemSprite = MenuItemSprite::create(m_pReturnGameSpriteBase, pReturnGameSpriteSelected,
                                                                       CC_CALLBACK_0(PauseScene::returnGameCallback, this));
    pReturnGameMenuItemSprite->setPosition(Vec2(visibleSize.width /2,origin.y + 700));

    // ゲームやり直しメニュースプライトの作成
    m_pRetryGameSpriteBase = Sprite::create(TEX_RESULT_RETRY_BUTTON);
    Sprite* pRetryGameSpriteSelected = Sprite::create(TEX_RESULT_RETRY_BUTTON);
    pRetryGameSpriteSelected->setColor(Color3B(200,200,200));
    MenuItemSprite* pRetryGameMenuItemSprite = MenuItemSprite::create(m_pRetryGameSpriteBase, pRetryGameSpriteSelected,
                                                                      CC_CALLBACK_0(PauseScene::retryGameCallback, this));
    pRetryGameMenuItemSprite->setPosition(Vec2(visibleSize.width / 2,origin.y + 600));

    // タイトルリターンメニュースプライトの作成
    m_pReturnTitleSpriteBase = Sprite::create(TEX_RESULT_TITLE_BUTTON);
    Sprite* pReturnTitleSpriteSelected = Sprite::create(TEX_RESULT_TITLE_BUTTON);
    pReturnTitleSpriteSelected->setColor(Color3B(200,200,200));
    MenuItemSprite* pReturnTitleMenuItemSptire = MenuItemSprite::create(m_pReturnTitleSpriteBase, pReturnTitleSpriteSelected,
                                                                        CC_CALLBACK_0(PauseScene::returnTitleCallback, this));
    pReturnTitleMenuItemSptire->setPosition(Vec2(visibleSize.width / 2,origin.y + 500));

    // メニューの一括登録
    Menu* pPauseSceneMenu = Menu::create(pMenuBarMenuItemSprite,pReturnGameMenuItemSprite,pReturnTitleMenuItemSptire,pRetryGameMenuItemSprite, NULL);
    pPauseSceneMenu->setPosition(Vec2::ZERO);
    this->addChild(pPauseSceneMenu);

    // コンフィグスプライト生成
    m_pConfigSprite = Sprite::create();
    m_pConfigSprite->setTextureRect(Rect(0,0,100,100));
    m_pConfigSprite->setColor(Color3B::YELLOW);
    m_pConfigSprite->setPosition(Vec2(400,200));
    //this->addChild(m_pConfigSprite);

    return true;
}
コード例 #30
0
cocos2d::Action* BattleScene::getRestartAction()
{
	return Sequence::create(FadeIn::create(0.5f),
		CallFunc::create(CC_CALLBACK_0(PreloadBattleScene::restart, _preloaderScene)), nullptr);
}