public void StartAttack()
 {
     soldierState = SoldierState.ATTACKING;
     agent.enabled = false;
     swordTween = sword.transform.DOLocalRotate (new Vector3 (0, -83, -20), 0.2f).SetLoops (-1, LoopType.Yoyo);
     StartCoroutine (AttackJump ());
 }

    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 chain and set it to have 2 iterations
        var chain = new TweenChain().setIterations( 2 );

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

        // create a Tween for each cube and it to the chain
        foreach( var cube in cubes )
        {
            var tween = new Tween( cube, 0.5f, config );
            chain.append( tween );
        }

        _tween = chain;
    }

    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;
    }

 public Tween AddTween(IComponent target, Func<float, float> ease, int tweenType, float duration)
 {
     Tween tween = new Tween();
     tween.Setup(target, CreateAccessor(target), ease, tweenType, duration);
     tweens.Add(tween);
     return tween;
 }

    public void AddHeart()
    {
        FSprite heart = new FSprite("heart.psd");
        heart.x = Random.Range(heart.width / 2f, Futile.screen.width - heart.width / 2f);
        heart.y = Random.Range(heart.height / 2f, Futile.screen.height - heart.height / 2f - 50f /*UI bar*/);
        heart.scale = 0;
        heart.rotation = Random.Range(0, 359f);
        heart.color = new Color(1.0f, Random.Range(0.0f, 0.3f), Random.Range(0.0f, 0.3f), 1.0f);
        AddChild(heart);
        hearts.Add(heart);

        Go.to(heart, Random.Range(1.0f, 5.0f), new TweenConfig()
            .setIterations(-1)
            .floatProp("rotation", 360 * (RXRandom.Float() < 0.5f ? 1 : -1), true));

        float inflationDuration = Random.Range(1.0f, 2.0f);
        Tween tweenUp = new Tween(heart, inflationDuration, new TweenConfig()
            .floatProp("scale", Random.Range(0.3f, 1.0f))
            .setEaseType(EaseType.SineInOut));

        Tween tweenDown = new Tween(heart, inflationDuration, new TweenConfig()
            .floatProp("scale", 0)
            .onComplete(OnHeartDisappearedWithoutBeingTouched)
            .setEaseType(EaseType.SineInOut));

        TweenChain chain = new TweenChain();
        chain.append(tweenUp);
        chain.append(tweenDown);

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

 public override void Execute()
 {
     var tweener = EntityView.transform.DORotate(DestinationRotation, Duration, RotateMode);
     tweener.Pause();
     
     CreatedTween = tweener;
 }

        public override void Execute()
        {
            var tweener = EntityView.transform.DOLookAt(LookAt, Duration, AxisConstraint);
            tweener.Pause();

            CreatedTween = tweener;
        }

        public override void Execute()
        {
            var tweener = EntityView.transform.DOPunchPosition(PunchVector, Duration, Vibration, Elasticity, UseSnapping);
            tweener.Pause();

            CreatedTween = tweener;
        }

        public override void Execute()
        {
            var tweener = Material.DOColor(NewColour, PropertyName, Duration);
            tweener.Pause();

            CreatedTween = tweener;
        }

    private bool RunTween(Tween tween)
    {
        var t = tween.TargetObj.Clock.CurrTime - tween.StartTime;

        if (t < tween.Delay)
            return false;

        if (!tween.Started)
        {
            tween.Started = true;
            tween.__SetStartVal();
            if (tween.StartCallback != null)
                tween.StartCallback(tween.TargetObj);
        }

        if (t >= tween.Duration + tween.Delay)
        {
            tween.Complete = true;
            tween.Property.SetValue(tween.TargetObj, tween.EndVal, null);

            if (tween.EndCallback != null)
                tween.EndCallback(tween.TargetObj);

            if (tween.ChainedTween != null)
            {
                __AddTween(tween.ChainedTween);
            }

            return true;
        }

        var val = tween.EasingType(t - tween.Delay, tween.StartVal, tween.EndVal - tween.StartVal, tween.Duration);
        tween.Property.SetValue(tween.TargetObj, val, null);
        return false;
    }

	public void Play() {
		if (_tween != null) {
			_tween.Destroy();
			_tween = null;
		}
		
		_looping = true;
		
		Vector3 theStartPos = _startPosition;	
		Vector3 theEndPos =_startPosition + BounceOffset;
			
		if (_reverse) {
			theStartPos = _startPosition + BounceOffset;
			theEndPos = _startPosition;
		}
		
		//LOOP YOYO:
		_tween = Tween.to(theStartPos, theEndPos, LoopDuration, EaseType, 
			(Tween t) => { transform.localPosition = (Vector3) t.Value;},
			null,
			0f,
			Yoyo,
			LoopCount
		);
		
		if (RandomStartProgress) {
			_tween.SetProgress(Random.Range(0f, 1f));
		}
	}

        void Awake()
        {
            tween = GetComponent<Tween>();
            tween.autoPlay = false;

            machine = new StateMachine<GateFSM>(this);
        }

        public override void Execute()
        {
            var tweener = EntityView.transform.DOMove(Destination, Duration, UseSnapping);
            tweener.Pause();

            CreatedTween = tweener;
        }

        internal static Sequence DoInsert(Sequence inSequence, Tween t, float atPosition)
        {
            TweenManager.AddActiveTweenToSequence(t);

            // If t has a delay add it as an interval
            atPosition += t.delay;
            inSequence.lastTweenInsertTime = atPosition;

            t.isSequenced = t.creationLocked = true;
            t.sequenceParent = inSequence;
            if (t.loops == -1) t.loops = 1;
            float tFullTime = t.duration * t.loops;
            t.autoKill = false;
            t.delay = t.elapsedDelay = 0;
            t.delayComplete = true;
            t.isSpeedBased = false;
            t.sequencedPosition = atPosition;
            t.sequencedEndPosition = atPosition + tFullTime;

            if (t.sequencedEndPosition > inSequence.duration) inSequence.duration = t.sequencedEndPosition;
            inSequence._sequencedObjs.Add(t);
            inSequence.sequencedTweens.Add(t);

            return inSequence;
        }

        void Awake()
        {
            tween = GetComponent<Tween>();
            tween.autoPlay = false;

            fsm = new Fsm(this);
        }

 public void shake()
 {
     if (shakeTween == null || !shakeTween.IsPlaying())
     {
         shakeTween = transform.DOShakePosition(duration, strength, vibrado, randomness);
     }       
 }

    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);
                }
            }
        );
    }

        public override void Execute()
        {
            var light = EntityView.GetComponent<Light>();
            var tweener = light.DOShadowStrength(ShadowStrength, Duration);
            tweener.Pause();

            CreatedTween = tweener;
        }

        public override void Execute()
        {
            var renderer = EntityView.GetComponent<Renderer>();
            var tweener = renderer.material.DOVector(Value, PropertyName, Duration);
            tweener.Pause();

            CreatedTween = tweener;
        }

        public override void Execute()
        {
            var light = EntityView.GetComponent<Light>();
            var tweener = light.DOColor(NewColour, Duration);
            tweener.Pause();

            CreatedTween = tweener;
        }