void TransitionSplitCols::onEnter() { TransitionScene::onEnter(); _gridProxy->setTarget(_outScene); _gridProxy->onEnter(); ActionInterval* split = action(); ActionInterval* seq = (ActionInterval*)Sequence::create ( split, CallFunc::create(CC_CALLBACK_0(TransitionSplitCols::switchTargetToInscene,this)), split->reverse(), nullptr ); _gridProxy->runAction ( Sequence::create ( easeActionWithAction(seq), CallFunc::create(CC_CALLBACK_0(TransitionScene::finish,this)), StopGrid::create(), nullptr ) ); }
void Tutorial::startAnimateGuideRight(eTutorialState state) { if (nullptr != _guideRight) // if (nullptr != _guideRight && false == _rightPressed) { this->stopAnimationGuideRight(); ActionInterval * action = nullptr; switch (state) { case eTutorialState::TUTORIAL_CONTROLLER_RIGHT: case eTutorialState::TUTORIAL_CONTROLLER_JUMP_RIGHT: action = _animLongPress->clone(); break; case eTutorialState::TUTORIAL_CONTROLLER_JUMP_LEFT: case eTutorialState::TUTORIAL_CONTROLLER_JUMP_VERTICAL: action = _animTap->clone(); break; case eTutorialState::TUTORIAL_CONTROLLER_LEFT: case eTutorialState::TUTORIAL_NONE: default: break; } if (action) { action->setTag(static_cast<int>(eAction::ANIMATION)); _guideRight->runAction(action); } } }
void ParticleComponentTest::defaultPlay() { ComRender* Particle = static_cast<ComRender*>(_rootNode->getChildByTag(10020)->getComponent("CCParticleSystemQuad")); ActionInterval* jump = CCJumpBy::create(5, Point(-500,0), 50, 4); FiniteTimeAction* action = CCSequence::create( jump, jump->reverse(), nullptr); Particle->getNode()->runAction(action); }
bool RenderTextureClippingNode::init() { setContentSize(RenderContentSize); m_pTopSprite = Sprite::create("res/ui/water_bottle/bottle.png"); m_pTopSprite->retain(); m_pWater = Sprite::create("res/ui/water_bottle/water.png"); m_pWater->retain(); m_pMaskSprite = Sprite::create("res/ui/water_bottle/water_mask.png"); m_pMaskSprite->retain(); m_pTopSprite->setPosition(RenderContentSize*0.5f); m_pWater->setPosition(RenderContentSize*0.5f); m_pMaskSprite->setPosition(RenderContentSize*0.5f); Size s = Director::getInstance()->getWinSize(); m_pTarget = RenderTexture::create(RenderContentSize.width, RenderContentSize.height); this->addChild(m_pTarget); BlendFunc maskBlend = {GL_ONE, GL_ZERO}; BlendFunc waterBlend = {GL_DST_ALPHA, GL_ZERO}; m_pMaskSprite->setBlendFunc(maskBlend); m_pWater->setBlendFunc(waterBlend); ActionInterval* pMoveAction = MoveBy::create(0.4f, Vec2(8.0f,0.0f)); ActionInterval* pRepeatAction = Sequence::create(pMoveAction, pMoveAction->reverse(), NULL); m_pWater->runAction(RepeatForever::create(pRepeatAction)); return true; }
bool Parallel::initWithActions(ActionInterval * action, ...) { va_list actions; va_start(actions, action); ActionInterval * action1 = action; while (action1 != NULL) { ActionInterval * action2 = va_arg(actions, ActionInterval *); if (action2 != NULL) { Parallel * tmp = new Parallel(); tmp->autorelease(); tmp->_initWithTwoActions(action1, action2); action1 = tmp; } else { ActionInterval * tmp = new ActionInterval(); tmp->autorelease(); _initWithTwoActions(action1, tmp); break; } } va_end(actions); return false; }
void TransitionRotoZoom:: onEnter() { TransitionScene::onEnter(); _inScene->setScale(0.001f); _outScene->setScale(1.0f); _inScene->setAnchorPoint(Vec2::ANCHOR_MIDDLE); _outScene->setAnchorPoint(Vec2::ANCHOR_MIDDLE); ActionInterval *rotozoom = (ActionInterval*)(Sequence::create ( Spawn::create ( ScaleBy::create(_duration/2, 0.001f), RotateBy::create(_duration/2, 360 * 2), nullptr ), DelayTime::create(_duration/2), nullptr )); _outScene->runAction(rotozoom); _inScene->runAction ( Sequence::create ( rotozoom->reverse(), CallFunc::create(CC_CALLBACK_0(TransitionScene::finish,this)), nullptr ) ); }
ActionReverseSequence2::ActionReverseSequence2() : ActionBase("ReverseSeq 2", NULL) { // Test: // Sequence should work both with IntervalAction and InstantActions ActionInterval *move1 = new MoveBy(1, fzPoint(250, 0)); ActionInterval *move2 = new MoveBy(1, fzPoint(0, 50)); ActionInstant *tog1 = new ToggleVisibility(); ActionInstant *tog2 = new ToggleVisibility(); ActionInterval *seq = new Sequence(move1, tog1, move2, tog2, move1->reverse(), NULL); ActionInterval *action = new Repeat(new Sequence(seq, seq->reverse(), NULL), 3); // Test: // Also test that the reverse of Hide is Show, and vice-versa kathia->runAction(action); ActionInterval *move_tamara = new MoveBy(1, fzPoint(100, 0)); ActionInterval *move_tamara2 = new MoveBy(1, fzPoint(50, 0)); ActionInstant *hide = new Hide(); ActionInterval *seq_tamara = new Sequence(move_tamara, hide, move_tamara2, NULL); ActionInterval *action_tamara = new Sequence(seq_tamara, seq_tamara->reverse(), NULL); tamara->runAction(action_tamara); }
ActionOrbit::ActionOrbit() : ActionBase("ActionOrbit", NULL) { ActionInterval * orbit1 = new OrbitCamera(2, 1, 0, 0, 180, 0, 0); ActionInterval * action1 = new Sequence(orbit1, orbit1->reverse(), NULL); ActionInterval * orbit2 = new OrbitCamera(2, 1, 0, 0, 180, -45, 0); ActionInterval * action2 = new Sequence(orbit2, orbit2->reverse(), NULL); ActionInterval * orbit3 = new OrbitCamera(2, 1, 0, 0, 180, 90, 0); ActionInterval * action3 = new Sequence(orbit3, orbit3->reverse(), NULL); kathia->runAction(new RepeatForever(action1)); tamara->runAction(new RepeatForever(action2)); grossini->runAction(new RepeatForever(action3)); ActionInterval * move = new MoveBy(3, fzPoint(100, -100));; ActionInterval * move_back = move->reverse(); ActionInterval * seq = new Sequence(move, move_back, NULL); Action * rfe = new RepeatForever(seq); kathia->runAction(rfe); tamara->runAction(rfe->copy()); grossini->runAction(rfe->copy()); }
void NewSpriteBatchTest::addNewSpriteWithCoords(Vec2 p) { auto BatchNode = static_cast<SpriteBatchNode*>( getChildByTag(kTagSpriteBatchNode) ); int idx = (int) (CCRANDOM_0_1() * 1400 / 100); int x = (idx%5) * 85; int y = (idx/5) * 121; auto sprite = Sprite::createWithTexture(BatchNode->getTexture(), Rect(x,y,85,121)); BatchNode->addChild(sprite); sprite->setPosition( Vec2( p.x, p.y) ); ActionInterval* action; float random = CCRANDOM_0_1(); if( random < 0.20 ) action = ScaleBy::create(3, 2); else if(random < 0.40) action = RotateBy::create(3, 360); else if( random < 0.60) action = Blink::create(1, 3); else if( random < 0.8 ) action = TintBy::create(2, 0, -255, -255); else action = FadeOut::create(2); auto action_back = action->reverse(); auto seq = Sequence::create(action, action_back, nullptr); sprite->runAction( RepeatForever::create(seq)); }
void UIBuildingBase::setSharkAction() { ActionInterval * ac = TintBy::create(1,-100,-100,-100); ActionInterval * acback = ac->reverse(); ActionInterval * final = RepeatForever::create(Sequence::create(ac,acback,NULL)); setSharkAction(final); }
ActionReverse::ActionReverse() : ActionBase("Reverse", NULL) { ActionInterval *jump = new JumpBy(2, fzPoint(300, 0), 50, 4); ActionInterval *action = new Sequence(jump, jump->reverse(), NULL); grossini->runAction(action); }
void Parallel::update(float t) { for (int i = 0; i < 2; i++) { ActionInterval * action = _actions[i]; if (action != NULL && !action->isFinished()) { action->update(t); } } }
ActionScale::ActionScale() : ActionBase("Scale", NULL) { ActionInterval *actionTo = new ScaleTo(2, 0.5f); ActionInterval *actionBy = new ScaleBy(2, 1, 10); ActionInterval *actionBy2 = new ScaleBy(2, 5, 1); tamara->runAction(new Sequence(actionBy, actionBy->reverse(), NULL)); grossini->runAction(actionTo); kathia->runAction(new Sequence(actionBy2, actionBy2->reverse(), NULL)); }
ActionMove::ActionMove() : ActionBase("Move", NULL) { ActionInterval* actionTo = new MoveTo(2, fzPoint(getContentSize()-fzPoint(40, 40))); ActionInterval* actionBy = new MoveBy(2, fzPoint(80,80)); ActionInterval* actionByBack = actionBy->reverse(); tamara->runAction(actionTo); grossini->runAction(new Sequence(actionBy, actionByBack, NULL)); kathia->runAction(new MoveTo(1, fzPoint(40, 40))); }
ActionRotateJerk::ActionRotateJerk() : ActionBase("RotateJerk", NULL) { ActionInterval *seq = new Sequence(new RotateTo(0.5f, -20), new RotateTo(0.5f, 20), NULL); ActionInterval *rep1 = new Repeat(seq, 10); Action *rep2 = new RepeatForever(seq->copy()); tamara->runAction(rep1); kathia->runAction(rep2); }
ActionJump::ActionJump() : ActionBase("Jump", NULL) { ActionInterval *actionTo = new JumpTo(2, fzPoint(300, 300), 50, 4); ActionInterval *actionBy = new JumpBy(2, fzPoint(300, 0), 50, 4); ActionInterval *actionUp = new JumpBy(2, fzPoint(0, 0), 80, 4); ActionInterval *actionByBack = actionBy->reverse(); tamara->runAction(actionTo); grossini->runAction(new Sequence(actionBy, actionByBack, NULL)); kathia->runAction(new RepeatForever(actionUp)); }
void TestFrameEvent::onFrameEvent(cocostudio::Bone *bone, const std::string& evt, int originFrameIndex, int currentFrameIndex) { CCLOG("(%s) emit a frame event (%s) at frame index (%d).", bone->getName().c_str(), evt.c_str(), currentFrameIndex); if (!_gridNode->getActionByTag(FRAME_EVENT_ACTION_TAG) || _gridNode->getActionByTag(FRAME_EVENT_ACTION_TAG)->isDone()) { _gridNode->stopAllActions(); ActionInterval *action = ShatteredTiles3D::create(0.2f, Size(16,12), 5, false); action->setTag(FRAME_EVENT_ACTION_TAG); _gridNode->runAction(action); } }
void PixelMapPartial::PlaySmallAnimation(cocos2d::Sprite* s) { bool scaleDirection = rand()%2; auto s1 = ScaleTo::create(2, kSpriteScale*0.8); auto s2 = ScaleTo::create(2, kSpriteScale*1.1); ActionInterval* loop = nullptr; if (scaleDirection) loop = RepeatForever::create(Sequence::create(s1, s2, NULL)); else loop = RepeatForever::create(Sequence::create(s2, s1, NULL));; loop->setTag(SMALL_ANIMATION_TAG); s->runAction(loop); }
ActionRotateToRepeat::ActionRotateToRepeat() : ActionBase("RotateToRepeat", NULL) { ActionInterval *action1 = new RotateTo(1, 90); ActionInterval *action2 = new RotateTo(1, 0); ActionInterval *seq = new Sequence(action1, action2, NULL); Action *rep1 = new RepeatForever(seq->copy()); Action *rep2 = new Repeat(seq, 5); tamara->runAction(rep1); kathia->runAction(rep2); }
ActionReverseSequence::ActionReverseSequence() : ActionBase("ReverseSeq", NULL) { ActionInterval *move1 = new MoveBy(1, fzPoint(250, 0)); ActionInterval *move2 = new MoveBy(1, fzPoint(0, 50)); ActionInterval *seq = new Sequence(move1, move2, move1->reverse(), NULL); ActionInterval *action = new Sequence(seq, seq->reverse(), NULL); grossini->runAction(action); }
ActionRotate::ActionRotate() : ActionBase("Rotate", NULL) { ActionInterval *actionTo = new RotateTo(2, 45); ActionInterval *actionTo2 = new RotateTo(2, -45); ActionInterval *actionTo0 = new RotateTo(2, 0); ActionInterval *actionBy = new RotateBy(2, 360); ActionInterval *actionByBack = actionBy->reverse(); tamara->runAction(new Sequence(actionTo, actionTo0, NULL)); grossini->runAction(new Sequence(actionBy, actionByBack, NULL)); kathia->runAction(new Sequence(actionTo2, actionTo0->copy(), NULL)); }
void Leaf::initBody() { CSprite* leafSprite = new CSprite(SPRITE_TYPE_MAIN); leafSprite->initWithIdentifier(FRAME_LEAF_IDLE); leafSprite->bind(CStringUtil::getPattern(FRAME_LEAF_IDLE)); ActionInterval* drownAction = (ActionInterval*) leafSprite->getAction(FRAME_LEAF_FALL, false); this->drownDuration = drownAction->getDuration(); this->getSprites()->pushBack(leafSprite); RectBody* rectBody = new RectBody(leafSprite->getContentSize().width, leafSprite->getContentSize().height); rectBody->setAnchorPoint(Point(0.5, 0.5)); CC_SAFE_RETAIN(rectBody); this->body = rectBody; }
ActionSkew::ActionSkew() : ActionBase("Action Skew", NULL) { ActionInterval *actionTo = new SkewTo(2, 37.2f, -37.2f); ActionInterval *actionToBack = new SkewTo(2, 0, 0); ActionInterval *actionBy = new SkewBy(2, 0, -90); ActionInterval *actionBy2 = new SkewBy(2, 45, 45); ActionInterval *actionByBack = actionBy->reverse(); tamara->runAction(new Sequence(actionTo, actionToBack, NULL)); grossini->runAction(new Sequence(actionBy, actionByBack, NULL)); kathia->runAction(new Sequence(actionBy2, actionBy2->reverse(), NULL)); }
cocos2d::Node* ParticleComponentTest::createGameScene() { Node *node = SceneReader::getInstance()->createNodeWithSceneFile("scenetest/ParticleComponentTest/ParticleComponentTest.json"); if (node == nullptr) { return nullptr; } ComRender* Particle = static_cast<ComRender*>(node->getChildByTag(10020)->getComponent("CCParticleSystemQuad")); ActionInterval* jump = JumpBy::create(5, Point(-500,0), 50, 4); FiniteTimeAction* action = Sequence::create( jump, jump->reverse(), nullptr); Particle->getNode()->runAction(action); return node; }
void StartPanel::hide() { ActionInterval * fadeout = FadeOut::create(1); Vector<Node *> children_list = this->getChildren(); Vector<Node *>::iterator itor = children_list.begin(); Vector<Node *>::iterator iend = children_list.end(); while (itor != iend) { ActionInterval * pAction = fadeout->clone(); (*itor)->runAction(pAction); itor++; } Smart09::create()->RemoveTouchHandle(m_pButtons[STARTUI_MENU_PLAY]); Smart09::create()->RemoveTouchHandle(m_pButtons[STARTUI_MENU_HELP]); Smart09::create()->RemoveTouchHandle(m_pButtonSound); }
//////////////////////////////////////////////////////// // // For test functions // //////////////////////////////////////////////////////// void performanceActions(Sprite* pSprite) { Size size = Director::sharedDirector()->getWinSize(); pSprite->setPosition(ccp((rand() % (int)size.width), (rand() % (int)size.height))); float period = 0.5f + (rand() % 1000) / 500.0f; RotateBy* rot = RotateBy::create(period, 360.0f * CCRANDOM_0_1()); ActionInterval* rot_back = rot->reverse(); Action *permanentRotation = RepeatForever::create(Sequence::create(rot, rot_back, NULL)); pSprite->runAction(permanentRotation); float growDuration = 0.5f + (rand() % 1000) / 500.0f; ActionInterval *grow = ScaleBy::create(growDuration, 0.5f, 0.5f); Action *permanentScaleLoop = RepeatForever::create(Sequence::create(grow, grow->reverse(), NULL)); pSprite->runAction(permanentScaleLoop); }
void StartPanel::show(const bool start) { ActionInterval * fadein = FadeIn::create(1); Vector<Node *> children_list = this->getChildren(); Vector<Node *>::iterator itor = children_list.begin(); Vector<Node *>::iterator iend = children_list.end(); while (itor != iend) { ActionInterval * pAction = fadein->clone(); (*itor)->runAction(pAction); itor++; } Smart09::create()->AddTouchHandle(TOUCH_GRADE_UI, m_pButtons[STARTUI_MENU_PLAY]); Smart09::create()->AddTouchHandle(TOUCH_GRADE_UI, m_pButtons[STARTUI_MENU_HELP]); Smart09::create()->AddTouchHandle(TOUCH_GRADE_UI, m_pButtonSound); }
void EnemyFlower::launchEnemy() { enemyBody->runAction(RepeatForever::create(AnimationManager::getInstance()->createAnimate(eAniflower))); Point pos = this->getPosition(); pos.y -= bodySize.height; startPos = pos; this->runAction(Place::create(pos)); ActionInterval *pMoveBy = MoveBy::create(1.0f, Point(0.0f, bodySize.height)); ActionInterval *pDelay = DelayTime::create(1.0f); ActionInterval *pMoveByBack = pMoveBy->reverse(); ActionInterval *pDelay2 = DelayTime::create(2.0f); this->runAction(RepeatForever::create( (ActionInterval*)Sequence::create(pMoveBy, pDelay, pMoveByBack, pDelay2, NULL))); this->scheduleUpdate(); }
bool BirdSprite::createBird() { this->createBirdByRandom(); if (Sprite::initWithSpriteFrame(AtlasLoader::getInstance()->getSpriteFrameByName(this->birdName))) { Animation *pAnimation = this->createAnimation(this->birdNameFormat.c_str(), 3, 10); Animate *pAnimate = Animate::create(pAnimation); this->idleAction = RepeatForever::create(pAnimate); //Create the swing action ActionInterval *pUp = CCMoveBy::create(0.4f, Point(0, 8)); ActionInterval *pUpBack =pUp->reverse(); this->swingAction = RepeatForever::create(Sequence::create(pUp, pUpBack, NULL)); return true; } return false; }
bool BirdSprite::createBird(){ this->createBirdByRandom(); if(Sprite::initWithSpriteFrame(AtlasLoader::getInstance()->getSpriteFrameByName(this->birdName))) { // init idle status //create the bird animation Animation* animation = this->createAnimation(this->birdNameFormat.c_str(), 3, 10); Animate* animate = Animate::create(animation); this->idleAction = RepeatForever::create(animate); // create the swing action ActionInterval *up = CCMoveBy::create(0.4f,Point(0, 8)); ActionInterval *upBack= up->reverse(); this->swingAction = RepeatForever::create(Sequence::create(up, upBack, NULL)); return true; }else { return false; } }