public WaitForSeconds(Coroutine coroutine, double seconds)
 {
     this.coroutine = coroutine;
     TimeoutEvent e = new TimeoutEvent { Key = this };
     token = Flow.Bind(e, OnTimeout);
     TimeFlow.Default.Reserve(e, seconds);
 }

    public void Restart()
    {
		if(Hazards.Count > 0)
		{
			spawn_coroutine = StartCoroutine(SpawnRandomHazard());
		}
    }

	void Move(Vector3 newPos, float duration, float delay)
	{
		if (_moveCoroutine != null)
			StopCoroutine(_moveCoroutine);
		
		_moveCoroutine = StartCoroutine(MoveRoutine(newPos, duration, delay));
	}

    // Update is called once per frame
    void Update()
    {
        if(Input.GetKeyUp (KeyCode.Space)){

            switchAlly = !switchAlly;
        }
        //Raycasting
        if (Input.GetMouseButtonUp (0)) {

            Ray r = Camera.main.ScreenPointToRay (Input.mousePosition);
            RaycastHit hit;

            if (Physics.Raycast (r, out hit, float.MaxValue)) {
                //Debug.Log ("hit: " + hit.collider.name );

                if(hit.collider.name == "Ground" ){

                    if(switchAlly == true && quantity_player_a < 3){

                        clone = Instantiate (ally_a, hit.point, allyTransform_a.rotation) as GameObject;
                        quantity_player_a++;
                        c = StartCoroutine (DeleteAlly(clone));

                    }else if(switchAlly == false && quantity_player_b < 3){

                        clone = Instantiate (ally_b, hit.point, allyTransform_b.rotation) as GameObject;
                        quantity_player_b++;
                        c = StartCoroutine (DeleteAlly(clone));
                    }

                }

                }
            }
    }

    public void animateBlock(int currentBlockCount,int maxCount)
    {
        if (co != null)
            StopCoroutine(co);

        if(currentBlockCount > maxCount / 2)//more then half
        {
            mySR.color = new Color(1,1,1,1);//white
        }
        else if (currentBlockCount == 1)
        {
            mySR.color = new Color(1, 0, 0, 1);//red
        }
        //else if (currentBlockCount == 0)//block count is 0
        //{
        //    mySR.color = new Color(mySR.color.r, mySR.color.g, mySR.color.b, 0);
        //}
        else
        {
            mySR.color = new Color(1, 1, 0, 1);//yellow
        }

        //mySR.color = new Color(mySR.color.r, mySR.color.g, mySR.color.b, 1);
        alpha = mySR.color.a;
        myanimator.enabled = true;
        co = StartCoroutine(fadeOut());
    }

    public void Close(float time, Action onFinish)
    {
        if (m_Coroutine != null)
            StopCoroutine(m_Coroutine);

        m_Coroutine = StartCoroutine(MoveEyelidsCoroutine(0.0f, 0.0f, time, onFinish));
    }

	// Update is called once per frame
	void Update () {
		if(dialogManager.getID() >= startAtDialogNumber && dialogManager.getID() < endAtDialogNumber && !audioSource.isPlaying && !activate)
		{
			coroutineSound = StartCoroutine(WaitAndPlay(secondsToStart));
			activate = true;
		}

		if(dialogManager.getID() >= endAtDialogNumber && activate)
		{
			StopCoroutine(coroutineSound);
		}

		if(dialogManager.getID() >= endAtDialogNumber && audioSource.isPlaying && !activateEnd)
		{
			audioSource.loop = false;
			activateEnd = true;

			if(trailSource != null)
			{
            	trailSource.PlayScheduled( AudioSettings.dspTime + audioSource.clip.length - audioSource.time);
			}
		}

		//if(dialogManager.getID() >= endAtDialogNumber && !audioSource.isPlaying && activateEnd && !activateTrail)
		//{
		//	trailSource.Play();
		//	activateTrail = true;
		//}
	}

    protected IEnumerator PanelTransition(bool isShowing)
    {
        //Init
        float timeLeft = 0f;
        JEngine.Instance.uiManager.nbPanelInTransition++;

        //Process
        yield return new WaitForEndOfFrame();
        if (isShowing)
        {
            while (canvasGroup.alpha < 1f)
            {
                timeLeft += Time.unscaledDeltaTime;
                canvasGroup.alpha = transitionCurve.Evaluate(timeLeft / transitionDuration);
				yield return new WaitForEndOfFrame();
            }
        }
        else
        {
            while (canvasGroup.alpha > 0f)
            {
                timeLeft += Time.unscaledDeltaTime;
                canvasGroup.alpha = transitionCurve.Evaluate(1f - (timeLeft / transitionDuration));
				yield return new WaitForEndOfFrame();
            }
            canvasGroup.blocksRaycasts = false;
        }

        transitionCoroutine = null;
        JEngine.Instance.uiManager.nbPanelInTransition--;
    }

//--------------------------------------------------------------------------------------------

    void Start ()
	{
		// get handle on player script
		playerScript = GetComponent<Player> ();
		if(playerScript.chassisQuick) 
		{
			rechargeRate *= playerScript.cooldownBoost;
		}

		//get handle on energy bar
		energyBar = GameObject.Find("EnergyBar").GetComponent<RectTransform>();
		origin = energyBar.localPosition;

		energySprites = Resources.LoadAll<Sprite>("GUI_Assets/EnergyIcons");
		energyImg = GameObject.Find("EnergyImg").GetComponent<Image>();
		blinkCoroutine = null;

        meshList =  playerScript.GetComponentsInChildren<MeshRenderer>();

        currEnergy = maxEnergy;

		isActive = false;
		isOnCooldown = false;
		isOnCooldownDelay = false;
		isOnInitialActivate = false;

		//get handle on audio source for secondary ready
		AudioSource[] sources = GetComponents<AudioSource>();
		readyAudio = sources[1];

		//audio source for phase on and off
		onSound = sources[2];
		offSound = sources[3];
	}

//--------------------------------------------------------------------------------------------

	void Start()
	{
		//get handle on energy bar
		energyBar = GameObject.Find("EnergyBar").GetComponent<RectTransform>();
		origin = energyBar.localPosition;

		energySprites = Resources.LoadAll<Sprite>("GUI_Assets/EnergyIcons");
		energyImg = GameObject.Find("EnergyImg").GetComponent<Image>();
		blinkCoroutine = null;

		//init prefabs
		teslaPrefabPhase_1 = Resources.Load<GameObject>("PlayerBullets/TeslaPhase_1");
		teslaPrefabPhase_2 = Resources.Load<GameObject>("PlayerBullets/TeslaPhase_2");

		forwardPos = transform.Find ("GunF");

		currEnergy = maxEnergy;
		storedDamage = 0f;

		isCharging = false;
		isOnInitialActivate = false;
		isOnCooldownDelay = false;
		isOnCooldown = false;

		//get handle on audio source for secondary ready
		readyAudio = GetComponents<AudioSource>()[1];
	}

	// Use this for initialization
	void Start () {
		spriteRenderer = GetComponent<SpriteRenderer> ();
		if (start) 
		{
			currentCoroutine = StartCoroutine (ChangeSprite ());
		}
	}

    private void OnFailure()
    {
        if (m_DisplayFailureCoroutine != null)
            StopCoroutine(m_DisplayFailureCoroutine);

        m_DisplayFailureCoroutine = StartCoroutine(DisplayFailure());
    }

    public void JumpTo(WorldMapArea area)
    {
        Debug.Assert(jumpRoutine == null, "jump routine must not already be in progress");

        jumpTarget = area;
        jumpRoutine = StartCoroutine(JumpRoutine());
    }

 private void longPressHandle(object sender, System.EventArgs e)
 {
     if (MenuMaster.musicVolume > 0 && MenuMaster.musicVolume < 100)
     {
         fastChanger = StartCoroutine(fastChange());
     }
 }

 public void Activate()
 {
     textMesh.text = changeText;
     if( coRoutine != null )
         StopCoroutine( "resetText" );
     coRoutine = StartCoroutine( "resetText" );
 }

 public override void Update()
 {
     if (flyRoutine == null)
     {
         flyRoutine = TaskFollower.StartCoroutine(FlyRoutine());
     }
 }

	public override void Activate()
	{
		if (movement != null)
			StopCoroutine (movement);
		movement = StartCoroutine (Movement(transform.TransformPoint (openedPosition)));
        SoundManager.Instance.SendMessage("PlaySFXOpenGate");
	}

	public void OnEnable()
	{
		if (DrawAfterPostEffects)
		{
			m_DrawAtEndOfFrame = StartCoroutine("DrawAtEndOfFrame");
		}
	}

    public void Open(float time, Action onFinish)
    {
        if (m_Coroutine != null)
            StopCoroutine(m_Coroutine);

        m_Coroutine = StartCoroutine(MoveEyelidsCoroutine(m_OpenedUpperEyelidY, m_OpenedLowerEyelidY, time, onFinish));
    }

    public void Pan(Vector3 direction, float panTime)
    {
        if (m_PanCR != null)
            StopCoroutine(m_PanCR);

        m_PanCR = StartCoroutine(pan_cr(direction, panTime));
    }