Beispiel #1
0
        public override void onEnter()
        {
            base.onEnter();
            CCSize s = CCDirector.sharedDirector().getWinSize();

            m_pInScene.scale        = 0.5f;
            m_pInScene.position     = new CCPoint(s.width, 0);
            m_pInScene.anchorPoint  = new CCPoint(0.5f, 0.5f);
            m_pOutScene.anchorPoint = new CCPoint(0.5f, 0.5f);

            CCActionInterval jump     = CCJumpBy.actionWithDuration(m_fDuration / 4, new CCPoint(-s.width, 0), s.width / 4, 2);
            CCActionInterval scaleIn  = CCScaleTo.actionWithDuration(m_fDuration / 4, 1.0f);
            CCActionInterval scaleOut = CCScaleTo.actionWithDuration(m_fDuration / 4, 0.5f);

            CCActionInterval jumpZoomOut = (CCActionInterval)(CCSequence.actions(scaleOut, jump));
            CCActionInterval jumpZoomIn  = (CCActionInterval)(CCSequence.actions(jump, scaleIn));

            CCActionInterval delay = CCDelayTime.actionWithDuration(m_fDuration / 2);

            m_pOutScene.runAction(jumpZoomOut);
            m_pInScene.runAction
            (
                CCSequence.actions
                (
                    delay,
                    jumpZoomIn,
                    CCCallFunc.actionWithTarget(this, base.finish)
                )
            );
        }
Beispiel #2
0
        public override void onEnter()
        {
            base.onEnter();
            CCSize winSize = CCDirector.sharedDirector().getWinSize();

            this.m_pInScene.scale        = 0.5f;
            this.m_pInScene.position     = new CCPoint(winSize.width, 0f);
            this.m_pInScene.anchorPoint  = new CCPoint(0.5f, 0.5f);
            this.m_pOutScene.anchorPoint = new CCPoint(0.5f, 0.5f);
            CCActionInterval cCActionInterval  = CCJumpBy.actionWithDuration(this.m_fDuration / 4f, new CCPoint(-winSize.width, 0f), winSize.width / 4f, 2);
            CCActionInterval cCActionInterval1 = CCScaleTo.actionWithDuration(this.m_fDuration / 4f, 1f);
            CCActionInterval cCActionInterval2 = CCScaleTo.actionWithDuration(this.m_fDuration / 4f, 0.5f);

            CCFiniteTimeAction[] cCFiniteTimeActionArray = new CCFiniteTimeAction[] { cCActionInterval2, cCActionInterval };
            CCActionInterval     cCActionInterval3       = (CCActionInterval)CCSequence.actions(cCFiniteTimeActionArray);

            CCFiniteTimeAction[] cCFiniteTimeActionArray1 = new CCFiniteTimeAction[] { cCActionInterval, cCActionInterval1 };
            CCActionInterval     cCActionInterval4        = (CCActionInterval)CCSequence.actions(cCFiniteTimeActionArray1);
            CCActionInterval     cCActionInterval5        = CCDelayTime.actionWithDuration(this.m_fDuration / 2f);

            this.m_pOutScene.runAction(cCActionInterval3);
            CCScene mPInScene = this.m_pInScene;

            CCFiniteTimeAction[] cCFiniteTimeActionArray2 = new CCFiniteTimeAction[] { cCActionInterval5, cCActionInterval4, CCCallFunc.actionWithTarget(this, new SEL_CallFunc(this.finish)) };
            mPInScene.runAction(CCSequence.actions(cCFiniteTimeActionArray2));
        }
 public override void unselected()
 {
     if (this.m_bIsEnabled)
     {
         base.unselected();
         base.stopActionByTag(-1061138430);
         CCAction cCAction = CCScaleTo.actionWithDuration(0.1f, this.m_fOriginalScale);
         cCAction.tag = -1061138430;
         base.runAction(cCAction);
     }
 }
        public override void onEnter()
        {
            base.onEnter();

            CCActionInterval inA, outA;

            m_pInScene.Visible = false;

            float inDeltaZ, inAngleZ;
            float outDeltaZ, outAngleZ;

            if (m_eOrientation == tOrientation.kOrientationUpOver)
            {
                inDeltaZ  = 90;
                inAngleZ  = 270;
                outDeltaZ = 90;
                outAngleZ = 0;
            }
            else
            {
                inDeltaZ  = -90;
                inAngleZ  = 90;
                outDeltaZ = -90;
                outAngleZ = 0;
            }

            inA = (CCActionInterval)CCSequence.actions
                  (
                CCDelayTime.actionWithDuration(m_fDuration / 2),
                CCSpawn.actions
                (
                    new CCOrbitCamera(m_fDuration / 2, 1, 0, inAngleZ, inDeltaZ, 90, 0),
                    CCScaleTo.actionWithDuration(m_fDuration / 2, 1),
                    CCShow.action()
                ),
                CCCallFunc.actionWithTarget(this, base.finish)
                  );

            outA = (CCActionInterval)CCSequence.actions
                   (
                CCSpawn.actions
                (
                    new CCOrbitCamera(m_fDuration / 2, 1, 0, outAngleZ, outDeltaZ, 90, 0),
                    CCScaleTo.actionWithDuration(m_fDuration / 2, 0.5f)
                ),
                CCHide.action(),
                CCDelayTime.actionWithDuration(m_fDuration / 2)
                   );

            m_pInScene.Scale = 0.5f;
            m_pInScene.RunAction(inA);
            m_pOutScene.RunAction(outA);
        }
Beispiel #5
0
 public override void unselected()
 {
     // subclass to change the default action
     if (m_bIsEnabled)
     {
         base.unselected();
         this.stopActionByTag(unchecked ((int)kZoomActionTag));
         CCAction zoomAction = CCScaleTo.actionWithDuration(0.1f, m_fOriginalScale);
         zoomAction.tag = unchecked ((int)kZoomActionTag);
         this.runAction(zoomAction);
     }
 }
Beispiel #6
0
        public virtual bool onTextFieldInsertText(CCTextFieldTTF pSender, string text, int nLen)
        {
            // if insert enter, treat as default to detach with ime
            if ("\n" == text)
            {
                return(false);
            }

            // if the textfield's char count more than m_nCharLimit, doesn't insert text anymore.
            if (pSender.CharCount >= m_nCharLimit)
            {
                return(true);
            }

            // create a insert text sprite and do some action
            CCLabelTTF label = CCLabelTTF.labelWithString(text, TextInputTestScene.FONT_NAME, TextInputTestScene.FONT_SIZE);

            this.addChild(label);
            ccColor3B color = new ccColor3B {
                r = 226, g = 121, b = 7
            };

            label.Color = color;

            // move the sprite from top to position
            CCPoint endPos = pSender.position;

            if (pSender.CharCount > 0)
            {
                endPos.x += pSender.contentSize.width / 2;
            }
            CCSize  inputTextSize = label.contentSize;
            CCPoint beginPos      = new CCPoint(endPos.x, CCDirector.sharedDirector().getWinSize().height - inputTextSize.height * 2);

            float duration = 0.5f;

            label.position = beginPos;
            label.scale    = 8;

            CCAction seq = CCSequence.actions(
                CCSpawn.actions(
                    CCMoveTo.actionWithDuration(duration, endPos),
                    CCScaleTo.actionWithDuration(duration, 1),
                    CCFadeOut.actionWithDuration(duration)),
                CCCallFuncN.actionWithTarget(this, callbackRemoveNodeWhenDidAction));

            label.runAction(seq);
            return(false);
        }
Beispiel #7
0
        public override void onEnter()
        {
            base.onEnter();
            this.m_pInScene.scale        = 0.001f;
            this.m_pOutScene.scale       = 1f;
            this.m_pInScene.anchorPoint  = new CCPoint(0.6666667f, 0.5f);
            this.m_pOutScene.anchorPoint = new CCPoint(0.333333343f, 0.5f);
            CCActionInterval cCActionInterval  = CCScaleTo.actionWithDuration(this.m_fDuration, 0.01f);
            CCActionInterval cCActionInterval1 = CCScaleTo.actionWithDuration(this.m_fDuration, 1f);

            this.m_pInScene.runAction(this.easeActionWithAction(cCActionInterval1));
            CCScene mPOutScene = this.m_pOutScene;

            CCFiniteTimeAction[] cCFiniteTimeActionArray = new CCFiniteTimeAction[] { this.easeActionWithAction(cCActionInterval), CCCallFunc.actionWithTarget(this, new SEL_CallFunc(this.finish)) };
            mPOutScene.runAction(CCSequence.actions(cCFiniteTimeActionArray));
        }
 public override void selected()
 {
     if (this.Enabled)
     {
         base.selected();
         CCAction actionByTag = base.getActionByTag(-1061138430);
         if (actionByTag == null)
         {
             this.m_fOriginalScale = this.scale;
         }
         else
         {
             base.stopAction(actionByTag);
         }
         CCAction cCAction = CCScaleTo.actionWithDuration(0.1f, this.m_fOriginalScale * 1.2f);
         cCAction.tag = -1061138430;
         base.runAction(cCAction);
     }
 }
Beispiel #9
0
        public override void selected()
        {
            // subclass to change the default action
            if (this.Enabled)
            {
                base.selected();

                CCAction action = getActionByTag(unchecked ((int)kZoomActionTag));
                if (action != null)
                {
                    this.stopAction(action);
                }
                else
                {
                    m_fOriginalScale = this.scale;
                }

                CCAction zoomAction = CCScaleTo.actionWithDuration(0.1f, m_fOriginalScale * 1.2f);
                zoomAction.tag = unchecked ((int)kZoomActionTag);
                this.runAction(zoomAction);
            }
        }
Beispiel #10
0
        public override void onEnter()
        {
            base.onEnter();

            m_pInScene.scale  = 0.001f;
            m_pOutScene.scale = (1.0f);

            m_pInScene.anchorPoint  = new CCPoint(2 / 3.0f, 0.5f);
            m_pOutScene.anchorPoint = new CCPoint(1 / 3.0f, 0.5f);

            CCActionInterval scaleOut = CCScaleTo.actionWithDuration(m_fDuration, 0.01f);
            CCActionInterval scaleIn  = CCScaleTo.actionWithDuration(m_fDuration, 1.0f);

            m_pInScene.runAction(this.easeActionWithAction(scaleIn));
            m_pOutScene.runAction
            (
                CCSequence.actions
                (
                    this.easeActionWithAction(scaleOut),
                    CCCallFunc.actionWithTarget(this, (base.finish))
                )
            );
        }
Beispiel #11
0
        public override void onEnter()
        {
            float single;
            float single1;
            float single2;
            float single3;

            base.onEnter();
            this.m_pInScene.visible = false;
            if (this.m_eOrientation != tOrientation.kOrientationLeftOver)
            {
                single  = -90f;
                single1 = 90f;
                single2 = -90f;
                single3 = 0f;
            }
            else
            {
                single  = 90f;
                single1 = 270f;
                single2 = 90f;
                single3 = 0f;
            }
            CCFiniteTimeAction[] cCFiniteTimeActionArray  = new CCFiniteTimeAction[] { CCDelayTime.actionWithDuration(this.m_fDuration / 2f), null, null };
            CCFiniteTimeAction[] cCFiniteTimeActionArray1 = new CCFiniteTimeAction[] { CCOrbitCamera.actionWithDuration(this.m_fDuration / 2f, 1f, 0f, single1, single, 90f, 0f), CCScaleTo.actionWithDuration(this.m_fDuration / 2f, 1f), CCShow.action() };
            cCFiniteTimeActionArray[1] = CCSpawn.actions(cCFiniteTimeActionArray1);
            cCFiniteTimeActionArray[2] = CCCallFunc.actionWithTarget(this, new SEL_CallFunc(this.finish));
            CCActionInterval cCActionInterval = (CCActionInterval)CCSequence.actions(cCFiniteTimeActionArray);

            CCFiniteTimeAction[] cCFiniteTimeActionArray2 = new CCFiniteTimeAction[3];
            CCFiniteTimeAction[] cCFiniteTimeActionArray3 = new CCFiniteTimeAction[] { CCOrbitCamera.actionWithDuration(this.m_fDuration / 2f, 1f, 0f, single3, single2, 90f, 0f), CCScaleTo.actionWithDuration(this.m_fDuration / 2f, 0.5f) };
            cCFiniteTimeActionArray2[0] = CCSpawn.actions(cCFiniteTimeActionArray3);
            cCFiniteTimeActionArray2[1] = CCHide.action();
            cCFiniteTimeActionArray2[2] = CCDelayTime.actionWithDuration(this.m_fDuration / 2f);
            CCActionInterval cCActionInterval1 = (CCActionInterval)CCSequence.actions(cCFiniteTimeActionArray2);

            this.m_pInScene.scale = 0.5f;
            this.m_pInScene.runAction(cCActionInterval);
            this.m_pOutScene.runAction(cCActionInterval1);
        }