void MakeBackground()
    {
        float thickness       = 25f;
        float distanceBetween = 10f;
        float borderWidth     = Futile.screen.width;
        float borderHeight    = Futile.screen.height;

        TweenFlow   flow   = new TweenFlow();
        TweenConfig config = new TweenConfig()
                             .floatProp("alpha", 0.15f);
        float delayBetweenTweenStarts = 0.2f;

        for (int i = 0; borderWidth > 0 && borderHeight > 0; i++)
        {
            TBorderLayer layer = new TBorderLayer(borderWidth, borderHeight, 25f, new Color(0.75f, 0.2f, 0.2f, 1.0f));
            layer.x     = (distanceBetween + thickness) * i;
            layer.y     = (distanceBetween + thickness) * i;
            layer.alpha = 0.0f;
            AddChild(layer);
            borderWidth  = borderWidth - distanceBetween * 2f - thickness * 2f;
            borderHeight = borderHeight - distanceBetween * 2f - thickness * 2f;
            flow.insert(delayBetweenTweenStarts * i, new Tween(layer, 0.3f, config));
        }

        Go.addTween(flow);
        flow.play();
    }
Пример #2
0
    void Start()
    {
        // create a TweenConfig that we will use on all 4 cubes
        var config = new TweenConfig()
            .setEaseType( EaseType.QuadIn ) // set the ease type for the tweens
            .materialColor( Color.magenta ) // tween the material color to magenta
            .eulerAngles( new Vector3( 0, 360, 0 ) ) // do a 360 rotation
            .position( new Vector3( 2, 8, 0 ), true ) // relative position tween so it will be start from the current location
            .setIterations( 2, LoopType.PingPong ); // 2 iterations with a PingPong loop so we go out and back;

        // create the flow and set it to have 2 iterations
        var flow = new TweenFlow().setIterations( 2 );

        // add a completion handler for the chain
        flow.setOnCompleteHandler( c => Debug.Log( "flow complete" ) );

        // create a Tween for each cube and it to the flow
        var startTime = 0f;
        foreach( var cube in cubes )
        {
            var tween = new Tween( cube, 0.5f, config );
            flow.insert( startTime, tween );

            // increment our startTime so that the next tween starts when this one is halfway done
            startTime += 0.25f;
        }

        _tween = flow;
    }
    void AnimateLettersIn(List <FLabel> letters,
                          float finalZero,
                          float yPosition,
                          float durationPerLetter,
                          float overlapBetweenLetterFlyins,
                          float extraRotationAmount,
                          System.Action <AbstractTween> onCompleteFunction)
    {
        if (overlapBetweenLetterFlyins > durationPerLetter)
        {
            Debug.Log("overlap can't be greater than duration!");
            return;
        }

        float horizontalDivision = (Futile.screen.width - finalZero * 2) / (letters.Count + 1);

        TweenFlow flow = new TweenFlow();

        for (int i = 0; i < letters.Count; i++)
        {
            TweenChain chain = TweenChainForLetter(letters[i], durationPerLetter, finalZero + horizontalDivision * (i + 1), yPosition, extraRotationAmount);

            flow.insert((durationPerLetter - overlapBetweenLetterFlyins) * i, chain);
        }

        if (onCompleteFunction != null)
        {
            flow.setOnCompleteHandler(onCompleteFunction);
        }
        Go.addTween(flow);
        flow.play();
    }
Пример #4
0
    public void LevelEnded()
    {
        currentLevel++;

        PauseAllCircles();

        gameManager.gameState = GameState.Transitioning;

        ExecuteDelayedAction(1.0f, () =>
            {
                if (currentLevel == levels.Length)
                {
                    gameManager.gameState = GameState.Ended;

                    TweenFlow fadeOutFlow = new TweenFlow();

                    foreach (GameObject circle in GameObject.FindGameObjectsWithTag("Circle"))
                    {
                        Tween fadeOutTween = new Tween(circle.transform, transitionHalfTime, new TweenConfig().scale(0).setEaseType(EaseType.Linear));
                        fadeOutFlow.insert(0, fadeOutTween);
                    }

                    fadeOutFlow.setOnCompleteHandler((a) =>
                    {
                        ClearLevel();

                        TweenFlow fadeInFlow = new TweenFlow();

                        gameFinishedObject.SetActive(true);
                        Vector3 origScale = gameFinishedObject.transform.localScale;

                        gameFinishedObject.transform.localScale = Vector3.zero;

                        Tween fadeInTween = new Tween(gameFinishedObject.transform, transitionHalfTime, new TweenConfig().scale(origScale).setEaseType(EaseType.QuadIn));

                        fadeInFlow.insert(0, fadeInTween);

                        fadeInFlow.setOnCompleteHandler((aaa) =>
                        {
                            ExecuteDelayedAction(2.0f, () =>
                            {
                                GameObject.Find("PageManager").GetComponent<PageManager>().GoToPage(GamePage.MainMenu);
                            });
                        });

                        fadeInFlow.play();
                    }
                    );

                    gameManager.gameState = GameState.Transitioning;
                    fadeOutFlow.play();
                }
                else
                {
                    SwitchToLevel(currentLevel);
                }
            }
        );
    }
Пример #5
0
    public void Destroy()
    {
        TweenConfig alphaTweenConfig = new TweenConfig();

        alphaTweenConfig.addTweenProperty(new FloatTweenProperty("alpha", 0.0f, false));

        TweenConfig scaleTweenConfig = new TweenConfig();

        scaleTweenConfig.addTweenProperty(new FloatTweenProperty("scale", 20, false));

        Tween alphaTween = new Tween(this, 0.3f, alphaTweenConfig);
        Tween scaleTween = new Tween(this, 0.3f, scaleTweenConfig);

        TweenFlow tweenFlow = new TweenFlow();

        tweenFlow.insert(0.0f, alphaTween);
        tweenFlow.insert(0.0f, scaleTween);
        tweenFlow.setOnCompleteHandler(DoneDestroying);
        tweenFlow.play();
    }
Пример #6
0
	void OnGUI()
	{
		GUI.matrix = Matrix4x4.Scale( new Vector3( 2, 2, 2 ) );
		
		if( GUILayout.Button( "Tween Position/Rotation Flow" ) )
		{
			Debug.Log( "Do a position tween that lasts 5 seconds and do a rotation tween every second for 0.5 seconds while the position tween is going" );

			var flow = new TweenFlow().add( 0, () => { return GoKitLite.instance.positionTo( cube, 5f, new Vector3( 10, 10, 10 ) ); } )
				.add( 1f, () => { return GoKitLite.instance.rotationTo( cube, 0.5f, new Vector3( 90, 0, 0 ) ); } )
				.add( 2f, () => { return GoKitLite.instance.rotationTo( cube, 0.5f, new Vector3( 0, 90, 0 ) ); } )
				.add( 3f, () => { return GoKitLite.instance.rotationTo( cube, 0.5f, new Vector3( 0, 0, 90 ) ); } )
				.add( 4f, () => { return GoKitLite.instance.rotationTo( cube, 0.5f, new Vector3( 180, 180, 180 ) ); } )
				.setCompletionHandler( () => { Debug.Log( "All done with the position/rotation flow" ); } );
			
			StartCoroutine( flow.start() );
		}


		if( GUILayout.Button( "Bounce and Tween Color" ) )
		{
			Debug.Log( "First move to 0,0,0 then do a position tween up/down/up/down while simultaneously tweening the color" );

			// first we add our position tweens
			var flow = new TweenFlow().add( 0, () => { return GoKitLite.instance.positionTo( cube, 1f, new Vector3( 0, 0, 0 ) ); } )
				.add( 1, () => { return GoKitLite.instance.positionTo( cube, 1f, new Vector3( 0, 5, 0 ), 0, GoKitLiteEasing.Bounce.EaseOut ); } )
				.add( 2, () => { return GoKitLite.instance.positionTo( cube, 1f, new Vector3( 0, 0, 0 ), 0, GoKitLiteEasing.Bounce.EaseOut ); } )
				.add( 3, () => { return GoKitLite.instance.positionTo( cube, 1f, new Vector3( 0, 5, 0 ), 0, GoKitLiteEasing.Bounce.EaseOut ); } )
				.add( 4, () => { return GoKitLite.instance.positionTo( cube, 1f, new Vector3( 0, 0, 0 ), 0, GoKitLiteEasing.Bounce.EaseOut ); } );

			// now we add the color tweens. each will start just after the position tween starts
			flow.add( 1.2f, () => { return GoKitLite.instance.colorTo( cube, 0.5f, Color.magenta ); } )
				.add( 2.2f, () => { return GoKitLite.instance.colorTo( cube, 0.5f, Color.blue ); } )
				.add( 3.2f, () => { return GoKitLite.instance.colorTo( cube, 0.5f, Color.yellow ); } )
				.add( 4.2f, () => { return GoKitLite.instance.colorTo( cube, 0.5f, Color.green ); } );

			StartCoroutine( flow.start() );
		}

	}
Пример #7
0
    void OnGUI()
    {
        GUI.matrix = Matrix4x4.Scale(new Vector3(2, 2, 2));

        if (GUILayout.Button("Tween Position/Rotation Flow"))
        {
            Debug.Log("Do a position tween that lasts 5 seconds and do a rotation tween every second for 0.5 seconds while the position tween is going");

            var flow = new TweenFlow().add(0, () => { return(GoKitLite.instance.positionTo(cube, 5f, new Vector3(10, 10, 10))); })
                       .add(1f, () => { return(GoKitLite.instance.rotationTo(cube, 0.5f, new Vector3(90, 0, 0))); })
                       .add(2f, () => { return(GoKitLite.instance.rotationTo(cube, 0.5f, new Vector3(0, 90, 0))); })
                       .add(3f, () => { return(GoKitLite.instance.rotationTo(cube, 0.5f, new Vector3(0, 0, 90))); })
                       .add(4f, () => { return(GoKitLite.instance.rotationTo(cube, 0.5f, new Vector3(180, 180, 180))); })
                       .setCompletionHandler(() => { Debug.Log("All done with the position/rotation flow"); });

            StartCoroutine(flow.start());
        }


        if (GUILayout.Button("Bounce and Tween Color"))
        {
            Debug.Log("First move to 0,0,0 then do a position tween up/down/up/down while simultaneously tweening the color");

            // first we add our position tweens
            var flow = new TweenFlow().add(0, () => { return(GoKitLite.instance.positionTo(cube, 1f, new Vector3(0, 0, 0))); })
                       .add(1, () => { return(GoKitLite.instance.positionTo(cube, 1f, new Vector3(0, 5, 0), 0, GoKitLiteEasing.Bounce.EaseOut)); })
                       .add(2, () => { return(GoKitLite.instance.positionTo(cube, 1f, new Vector3(0, 0, 0), 0, GoKitLiteEasing.Bounce.EaseOut)); })
                       .add(3, () => { return(GoKitLite.instance.positionTo(cube, 1f, new Vector3(0, 5, 0), 0, GoKitLiteEasing.Bounce.EaseOut)); })
                       .add(4, () => { return(GoKitLite.instance.positionTo(cube, 1f, new Vector3(0, 0, 0), 0, GoKitLiteEasing.Bounce.EaseOut)); });

            // now we add the color tweens. each will start just after the position tween starts
            flow.add(1.2f, () => { return(GoKitLite.instance.colorTo(cube, 0.5f, Color.magenta)); })
            .add(2.2f, () => { return(GoKitLite.instance.colorTo(cube, 0.5f, Color.blue)); })
            .add(3.2f, () => { return(GoKitLite.instance.colorTo(cube, 0.5f, Color.yellow)); })
            .add(4.2f, () => { return(GoKitLite.instance.colorTo(cube, 0.5f, Color.green)); });

            StartCoroutine(flow.start());
        }
    }
Пример #8
0
    public void Destroy()
    {
        TweenConfig alphaTweenConfig = new TweenConfig();
        alphaTweenConfig.addTweenProperty(new FloatTweenProperty("alpha", 0.0f, false));

        TweenConfig scaleTweenConfig = new TweenConfig();
        scaleTweenConfig.addTweenProperty(new FloatTweenProperty("scale", 20, false));

        Tween alphaTween = new Tween(this, 0.3f, alphaTweenConfig);
        Tween scaleTween = new Tween(this, 0.3f, scaleTweenConfig);

        TweenFlow tweenFlow = new TweenFlow();
        tweenFlow.insert(0.0f, alphaTween);
        tweenFlow.insert(0.0f, scaleTween);
        tweenFlow.setOnCompleteHandler(DoneDestroying);
        tweenFlow.play();
    }
    void AnimateLettersIn(List<FLabel> letters,
		float finalZero,
		float yPosition,
		float durationPerLetter,
		float overlapBetweenLetterFlyins,
		float extraRotationAmount,
		System.Action<AbstractTween> onCompleteFunction)
    {
        if (overlapBetweenLetterFlyins > durationPerLetter) {
            Debug.Log("overlap can't be greater than duration!");
            return;
        }

        float horizontalDivision = (Futile.screen.width - finalZero * 2) / (letters.Count + 1);

        TweenFlow flow = new TweenFlow();

        for (int i = 0; i < letters.Count; i++) {
            TweenChain chain = TweenChainForLetter(letters[i], durationPerLetter, finalZero + horizontalDivision * (i + 1), yPosition, extraRotationAmount);

            flow.insert((durationPerLetter - overlapBetweenLetterFlyins) * i, chain);
        }

        if (onCompleteFunction != null) flow.setOnCompleteHandler(onCompleteFunction);
        Go.addTween(flow);
        flow.play();
    }
Пример #10
0
    private void SwitchToLevel(int numLevel)
    {
        GameObject[] circles = GameObject.FindGameObjectsWithTag("Circle");

        gameManager.gameState = GameState.Transitioning;

        if (circles.Length == 0)
        {
            FadeInLevel(numLevel);
        }
        else
        {
            TweenFlow fadeOutFlow = new TweenFlow();

            foreach (GameObject circle in circles)
            {
                Tween fadeOutTween = new Tween(circle.transform, transitionHalfTime, new TweenConfig().scale(0).setEaseType(EaseType.Linear));
                //fadeOutTween.setOnCompleteHandler((a) => { Go.killAllTweensWithTarget(circle.transform); Destroy(circle); });
                fadeOutFlow.insert(0, fadeOutTween);
            }

            fadeOutFlow.setOnCompleteHandler((a) =>
                {
                    FadeInLevel(numLevel);
                }
            );

            fadeOutFlow.play();
        }
    }
Пример #11
0
    private void FadeInLevel(int numLevel)
    {
        gameManager.currentTime_s = 0.0f;
        gameManager.AddTime(0);

        textLevelNum.text = "" + currentLevel;

        ClearLevel();

        LoadLevel(numLevel);

        TweenFlow fadeInFlow = new TweenFlow();

        foreach (GameObject circle in GameObject.FindGameObjectsWithTag("Circle"))
        {
            float origScale = circle.transform.localScale.x;
            circle.transform.localScale = Vector3.zero;

            Tween fadeInTween = new Tween(circle.transform, transitionHalfTime, new TweenConfig().scale(origScale).setEaseType(EaseType.QuadIn));

            fadeInFlow.insert(0, fadeInTween);
        }

        fadeInFlow.setOnCompleteHandler((aa) => { gameManager.gameState = GameState.Playing; });

        fadeInFlow.play();
    }
Пример #12
0
    private void MoveCircle(float seconds, bool forward, System.Action onComplete)
    {
        Vector3 direction;

        if (forward)
        {
            AdvanceTime(seconds * 0.5f);
            direction = Vector3.right;
        }
        else
        {
            AdvanceTime(-seconds * 0.5f);
            direction = Vector3.left;
        }

        Vector3 destPosition = circle.transform.position + direction * circleSpeed * seconds;

        TweenFlow moveFlow = new TweenFlow();
        Tween moveTween = new Tween(circle.transform, seconds * 0.5f, new TweenConfig().position(destPosition).setEaseType(EaseType.Linear));
        moveFlow.insert(0, moveTween);
        moveFlow.setOnCompleteHandler((a) => { onComplete.Invoke(); });

        moveFlow.play();
    }
Пример #13
0
    private void AdvanceTime(float secondsToAdd)
    {
        float dest = _seconds + secondsToAdd;

        TweenFlow moveFlow = new TweenFlow();
        Tween moveTween = new Tween(this, Mathf.Abs(secondsToAdd), new TweenConfig().floatProp("seconds", dest).setEaseType(EaseType.Linear));
        moveFlow.insert(0, moveTween);

        moveFlow.play();
    }
    void MakeBackground()
    {
        float thickness = 25f;
        float distanceBetween = 10f;
        float borderWidth = Futile.screen.width;
        float borderHeight = Futile.screen.height;

        TweenFlow flow = new TweenFlow();
        TweenConfig config = new TweenConfig()
            .floatProp("alpha", 0.15f);
        float delayBetweenTweenStarts = 0.2f;

        for (int i = 0; borderWidth > 0 && borderHeight > 0; i++) {
            TBorderLayer layer = new TBorderLayer(borderWidth, borderHeight, 25f, new Color(0.75f, 0.2f, 0.2f, 1.0f));
            layer.x = (distanceBetween + thickness) * i;
            layer.y = (distanceBetween + thickness) * i;
            layer.alpha = 0.0f;
            AddChild(layer);
            borderWidth = borderWidth - distanceBetween * 2f - thickness * 2f;
            borderHeight = borderHeight - distanceBetween * 2f - thickness * 2f;
            flow.insert(delayBetweenTweenStarts * i, new Tween(layer, 0.3f, config));
        }

        Go.addTween(flow);
        flow.play();
    }