private IEnumerator FadeIn(TextMesh m)
    {
        float timeCounter = 0f;

        float fadeAwayTimeout = 1f;

        while (timeCounter < fadeAwayTimeout){

            float alpha = (1f * (timeCounter / fadeAwayTimeout));

            m.color = new Color(
                m.color.r,
                m.color.g,
                m.color.b,
                (alpha > 0) ? alpha : 0f
                );

            timeCounter += Time.deltaTime;

            yield return 0;
        }

        m.color = new Color(
            m.color.r,
            m.color.g,
            m.color.b,
            1f
            );
    }

 void Awake()
 {
     text = GetComponent<TextMesh>();
     meshrenderer = GetComponent<MeshRenderer>();
     meshrenderer.sortingLayerName = "ui";
     meshrenderer.enabled = false;
 }

	// Use this for initialization
	void Start () {

        buildSeq(nOpt);

		timer = GameObject.Find ("Timer").GetComponent<TextMesh> ();

	}

    // Use this for initialization
    void Start()
    {
        score = ScoreWorker.score;

        ResultLabel = GameObject.Find ("Score").GetComponent<TextMesh> ();
        DescLabel =   GameObject.Find ("Description").GetComponent<TextMesh> ();

        timer = (float)1.9;
        is_wait = true;

        int curr_max_score = 0;

        string r = Keeper.get_param ("MaxScore");

        curr_max_score = Convert.ToInt32 (r);

        if (curr_max_score < score)
        {
            curr_max_score = score;
        }

        Keeper.set_param ("MaxScore", Convert.ToString (curr_max_score));

        best_record =  Convert.ToInt32(Keeper.get_param ("MaxScore"));

        //best_record = Convert.ToInt32 (max_score);
        //best_record = max_score;
    }

    private IEnumerator CheckTerminals()
    {
        while (enabled)
        {
            IsNextToGenerator = false;
            IsNextToTerminal = false;
            foreach (Transform t in this.transform)
            {
                //print("distance of " + Vector3.Distance(Character.position, t.position));
                if (Vector3.Distance(Character.position, t.position) < TerminalDistance)
                {
                    if (t.name.ToLower().StartsWith("o2gen"))
                    {
                        IsNextToGenerator = true;
                        GeneratorName = t.name;
                        break;
                    }
                    else
                    {
                        IsNextToTerminal = true;
                        currentLabel = t.GetChild(0).GetComponent<TextMesh>();

                        EnumExtensions.TryParse<Terminal.TerminalType>(CurrentTerminalType, t.name.ToLower(), out CurrentTerminalType);
                        break;
                    }
                }
            }

            yield return new WaitForSeconds(.5f);
        }
    }

 void OnMouseEnter()
 {
     selected = true;
     tm = GetComponent<TextMesh>();
     startcolor = tm.color;
     tm.color = Color.white;
 }

	/*public PlayerHandler(int lvl, float ex, float health, float magic, string n){
		level = lvl;
		exp = ex;
		hp = health;
		mp = magic;
		playerName = n;
	}*/
	void Start(){
		nameMesh = GetComponentInChildren<TextMesh> ();
		nameMesh.text = Name;
		SetHpToMax ();
		SetMpToMax ();
		GM().setPos (this.gameObject);
	}

 void Start()
 {
     buttonText = GetComponentInChildren<TextMesh>();
     gameMan = GameObject.FindGameObjectWithTag("Manager").GetComponent<GameManager>();
     rend = GetComponent<Renderer>();
     rend.material.SetColor("_Color", gameMan.pColor[playerNum]);
 }

        void OnEnable()
        {
            foreach(Transform child in transform)
            {
                //Search for child Loading Background to get the mesh renderer for the background texture
                if(child.name == "Loading Background")
                {
                    m_MeshRenderer = child.GetComponent<MeshRenderer>();
                }
                if(child.name == "Loading Percent")
                {
                    m_LoadingText = child.GetComponent<TextMesh>();
                }
            }

            if(m_MeshRenderer == null)
            {
                Debug.LogError("Missing a gameobject with the name \'Loading Background\' and a \'MeshRenderer\' component.");
                gameObject.SetActive(false);
                return;
            }
            if(m_LoadingText == null)
            {
                Debug.LogError("Missing a gameobject with the name \'Loading Text\' and a \'TextMesh\' component.");
                gameObject.SetActive(false);
                return;
            }
            Material material = new Material(m_MeshRenderer.sharedMaterial);
            material.SetTexture("_MainTex", m_TextureToDisplay);
            m_MeshRenderer.material = material;
        }

    void Awake()
    {
        this.myTextMesh = this.GetComponent<TextMesh>();

        TransParentColor = this.myTextMesh.color;
        TransParentColor.a = 0.0f;
    }

	void Awake () {
    if (textAsset == null)
      return;

    string text = textAsset.text;
    text = text.Replace("\\n", System.Environment.NewLine);

    textAsset = null; // Required otherwise the clone will instantiate other clones
    GameObject clone = Instantiate(gameObject) as GameObject;
    TextMesh clone_text_mesh = clone.GetComponent<TextMesh>();

    string[] parts = text.Split(' ');
    text = "";
    string line = "";
    for (int i = 0; i < parts.Length; ++i)
    {
      clone_text_mesh.text = line + parts[i];
      if (clone_text_mesh.renderer.bounds.extents.x > maxWidth)
      {
        text += line.TrimEnd() + System.Environment.NewLine;
        line = "";
      }
      line += parts[i] + " ";
    }
    text += line.TrimEnd();

    text_mesh_ = GetComponent<TextMesh>();
    text_mesh_.text = text;

    Destroy(clone);
	}

 public TextSize(TextMesh tm)
 {
     textMesh = tm;
     renderer = tm.renderer;
     dict = new Hashtable();
     getSpace();
 }

 // Use this for initialization
 void Start()
 {
     if (course == null) {
         course = (Course.CourseCounter)GameObject.FindWithTag("course").GetComponent<Course.CourseCounter>();
     }
     text = (TextMesh) GetComponent<TextMesh> ();
 }

	void Start () {
		textMesh = GetComponent<TextMesh>();
		counter = 0;
		damageCounter = 0;
		lastHealth = 0;
		currentHealth = 0;
	}

    public void Init(string s)
    {
        animation = GetComponent<VillagerAnimation>();
		animation.Init (s);

        skinMaterial = GetComponentInChildren<MeshRenderer>().material;
        origColor = skinMaterial.color;

        // music stuff
        musicToggle = GetComponent<ToggleSuspend>();
        musicPattern = GetComponent<Pattern>();
        SetMusicPattern();
        musicSample = GetComponent<Sampler>();
        SetMusicSample();

		keyboardPosition = transform.localPosition;

        textMesh = GetComponentInChildren<TextMesh>();

        letter = s;
        textMesh.text = s;

		currentState = State.Idle;
		timeSinceLastDanced = Time.time;
    }

	// Use this for initialization
	private void Start ()
	{
		_dieTimer 	= new Timer(_duration);
		_text 		= GetComponent<TextMesh>();

		_dieTimer.Start();
	}

	void Start ()
	{
		slot1Data = transform.Find ("slot01").transform.Find ("data").gameObject.GetComponent<TextMesh>();
		slot1Text = transform.Find ("slot01").transform.Find ("text").gameObject.GetComponent<GameTextControl>();

		slot2Data = transform.Find ("slot02").transform.Find ("data").gameObject.GetComponent<TextMesh>();
		slot2Text = transform.Find ("slot02").transform.Find ("text").gameObject.GetComponent<GameTextControl>();

		slot3Data = transform.Find ("slot03").transform.Find ("data").gameObject.GetComponent<TextMesh>();
		slot3Text = transform.Find ("slot03").transform.Find ("text").gameObject.GetComponent<GameTextControl>();

		if(int.TryParse(LevelControl.CURRENT_LEVEL_CLASS.myName, out levelValue))
		{
			titleText = transform.Find ("levelTitle").transform.Find ("title").gameObject.GetComponent<GameTextControl>();

			if(LevelControl.CURRENT_LEVEL_CLASS.type == 0)
			{
				titleText.myKey = "ui_sign_mission";
				titleText.addText = " " + levelValue.ToString();
			}
			else if(LevelControl.CURRENT_LEVEL_CLASS.type == 1)
			{
				titleText.myKey = "ui_sign_bonus_mission";
				titleText.addText = " " + levelValue.ToString();
			}
		}
		//

		slot1Data.text = LevelControl.CURRENT_LEVEL_CLASS.movesLimitForStar.ToString();

		slot2Data.text = TimeScaleManager.getTimeString ((int) LevelControl.CURRENT_LEVEL_CLASS.timeLimitForStar);

		slot3Data.text = LevelControl.CURRENT_LEVEL_CLASS.scoreLimitForStar.ToString();

	}

    void Start()
    {
        roundDisplayMesh = gameObject.GetComponent<TextMesh>();

        currRound = 1;
        roundDisplayMesh.text = "Round: " + currRound.ToString();
    }

 // Use this for initialization
 void Start()
 {
     f_Timer = 5f;
     i_Score = 0;
     i_HighScore = GameData.i_HighScore;
     TEXTDISPLAY = GetComponent<TextMesh>();
 }

	//public static bool fade = false;
	void Start () {
		fade = false;
		anim = GetComponent<Animator>();
		spr = GetComponent<SpriteRenderer>();
		T = GetComponent<TextMesh>();
		//		spr.color = Color.red;
		//		Debug.Log(spr.color);
		//gameObject.GetComponent<Rigidbody2D>().simulated = false;
		instructions = new string[]{
			"Welcome to the quantum world. Things behave very differently here.", 
			"This is an electron in its wave state...",
			"To see the electron in its particle state, we need to take measurements. At each measurement we can see where the electron had been.",
			"Notice that the electron only appears along the wire. That's because this is a 1-D quantum wire. This also means you can't jump.",
			"Let's speed things up a little and see where the electron occurs most.",//4
			"The maximum amplitude of the wave at any point tells us the probability of finding the electron there.",
			"So at all times, the electron has the highest chance of being found in the middle...",
			"...and the least chance at the ends.",//7
			"The shape of the wave function is determined by the potential profile. We will discuss this in a later level.",
			"The electron's Total Energy is quantized in this world, which means it can only have discrete values.",
			"The electron is currently on the ground state (Energy Level 0).",//10
			"These are sources of light. When brought to a light machine, they emit photons. Photons can give energy to the electron.",//11
			"The color of a photon determines its energy. Lower wavelength (like blue and violet) means higher energy and vice-versa.",
			"Only the correct energy photon can change the electon's energy level. Bring the light sources in the right order to the light machine.",
			"The Total Energy has increased. The wavefunction changes for each energy level, so it now looks different.",//14
			"It now has a node, a point where there is no chance of the electron appearing. The number of nodes is equal to the energy level number.",
			"Get the remaining photons to finish the level. Press next to play."," "};

		T.text = instructions[tutorialManagerQ.i];
		T.text = ResolveTextSize(T.text,length);
		//Debug.Log(T.text);
		
	}