void Start () {
        root = GameObject.Find("UI Root");
        gm = GameObject.Find("GameManager").GetComponent<GameManager>();
        nameLabel = root.transform.Find("Avg_Panel/Label_Name").GetComponent<UILabel>();
        dialogLabel = root.transform.Find("Avg_Panel/Label_Dialog").GetComponent<UILabel>();
        nameLabel.fontSize = 22;
	}

 void Start()
 {
     tParent = transform.parent;
     networkView = tParent.GetComponent <NetworkView>();
     gameObject.SetActive(networkView.isMine);
     gm = GameManager.Instance;
 }

	private void Init(){
		this.gameManager = GameObject.Find ("GameManager").GetComponent<GameManager> ();
		this.player = GameObject.Find ("Player").GetComponent<PlayerScript> ();
		this.enemy = GameObject.Find ("Enemy").GetComponent<EnemyScript> ();
		this.mPlayerShieldHP = Constants.ShieldPoint;
		this.mEnemyShieldHP = Constants.ShieldPoint;
	}

 // Use this for initialization
 void Start()
 {
     PlayerCam = GameObject.FindGameObjectWithTag("MainCamera").GetComponent<Camera>(); // Find the Camera's GameObject from its tag
     _GameManager = gameObject.GetComponent<GameManager>();
     _player1AI = _GameManager.player1AI;
     _player2AI = _GameManager.player2AI;
 }

    // Update is called once per frame
    void Update()
    {
        if (gManager == null) {
            gManager=GameManager.Instance();
        }
        //Debug.Log (interactions.getIsGrabbed());
        if (gManager.currentLevel != GameManager.LevelStatus.planting) {
            gameObject.SetActive(false);
        }

        Debug.Log (this.name + " " + interactions.getIsGrabbed ());
        if (interactions.getIsGrabbed()&&!downTime&&!gManager.isHandGrabbing())
        {
            //Debug.Log("I have seeds");
            GameObject newObject;
            newObject= (GameObject)(Instantiate(thisIsABagOf,interactions.getCursorPosition(), Quaternion.identity));

            newObject.SendMessage("SetGrabbed", SendMessageOptions.DontRequireReceiver);
            downTime= true;
            someTime= Time.time;
        }
        if (!interactions.getIsGrabbed()&&downTime&&(Time.time-someTime)>1)

        {
            downTime= false;
        }
    }

 public void Initialize(float speed, GameObject player, GameManager manager)
 {
     SetSpeed (speed);
     this.player = player;
     this.manager = manager;
     scored = false;
 }

 // Use this for initialization
 void Start()
 {
     if (GameObject.Find("GameManager"))
     {
         gameManager = GameObject.Find("GameManager").GetComponent<GameManager>();
     }
 }

 void OnEnable()
 {
     if (gm == null)
     {
         gm = GameObject.FindGameObjectWithTag("GM").GetComponent<GameManager>();
     }
 }

 private void CreateScorePanel(GameManager.LevelScore levelScore)
 {
     var spi = Instantiate(ScorePanelItemPrefab);
     spi.GetComponentInChildren<Text>().text = string.Format("Level {0}{3}Score: {1}{3}Faults: {4}{3}{2}",
         levelScore.LevelNumber, levelScore.Score, levelScore.Time.Minutes+"m " + levelScore.Time.Seconds + "s " + levelScore.Time.Milliseconds + "ms", Environment.NewLine, levelScore.Faults);
     spi.transform.SetParent(ScoresPanel);
 }

    // tile map
    public TileMapData(int x_size, int y_size)
    {
        this.size_x = x_size;
        this.size_y = y_size;

        map_tiles = new DTile[size_x, size_y];

        // gameManager Stuff
        go = GameObject.Find("GameManager(Clone)");
        gameManagerScript = go.GetComponent<GameManager>();

         //   Debug.Log("ITs not null");

        // Construct Data map with Tiles from XML

        // Example without XML
        for (int x = 0; x < size_x; x++)
        {
            for (int y = 0; y < size_y; y++)
            {
                map_tiles[x, y] = new DBuildTile(x, y);
            }
        }

        if (gameManagerScript.getWaypoints() != null) {
            List<Vector2> wayPointsList = gameManagerScript.getWaypoints();
            // add path to tile
        //    Debug.Log("Starting Pathing");
            int mini;
            int maxi;
            for (int i = 0; i < wayPointsList.Count - 1; i++)
            {
                Vector2 current = wayPointsList[i];
                Vector2 next = wayPointsList[i + 1];
                // vertical
                if (current.x == next.x)
                {
                    // loop from start to next mark path tile
                    int x = (int)current.x;
                    mini = Mathf.Min((int)current.y, (int)next.y);
                    maxi = Mathf.Max((int)current.y, (int)next.y);
                    for (int y = mini; y < maxi + 1; y++)
                    {
                        map_tiles[x, y] = new DWalkableTile(x, y);
                    }
                }
                // horizontal
                else {
                    int y = (int)current.y;
                    mini = Mathf.Min((int)current.x, (int)next.x);
                    maxi = Mathf.Max((int)current.x, (int)next.x);
                    // loop from start to next mark
                    for (int x = mini; x < maxi + 1; x++)
                    {
                        map_tiles[x, y] = new DWalkableTile(x, y);
                    }
                }
            }
        }
    }

	void Awake ()
	{
		onFire = false;
		announcerAudio = GetComponents<AudioSource> () [1];
		playerAttack = GetComponent<PlayerAttack> ();

		canvas = GameObject.Find ("HUDCanvas");
		//Debug.Log ("PlayerHealthUI_" + playerAttack.playerNum);

		inGameHealthUI = canvas.GetComponent<RectTransform> ().Find ("PlayerHealthUI_" + playerAttack.playerNum)
			.GetComponent<InGameHealthUI>();
		inGameHealthUI.playerHealth = this;
		rigid = GetComponent<Rigidbody> ();
		gm = GameObject.Find ("GameManager").GetComponent<GameManager> ();
		uim = GameObject.Find ("GameManager").GetComponent<UI_Manager> ();
		joystickNum = playerAttack.joystickNum;
		damageReduction = 1;
		allgrounds = GameObject.FindGameObjectsWithTag("Island");
		anim = GetComponent <Animation> ();
		playerAudio = GetComponent <AudioSource> ();
		playerMovement = GetComponent <PlayerMovement> ();

		//playerShooting = GetComponentInChildren <PlayerShooting> ();
		currentHealth = startingHealth;
		SetupHealthUI ();
	}

    // Use this for initialization
    void Start()
    {
        gm = FindObjectOfType<GameManager>();

        rigidbody = GetComponent<Rigidbody2D>();
        ResetBall();
    }

 // Use this for initialization
 void Start()
 {
     SilhouetteBG = gameObject.transform.GetChild(0).GetComponent<RectTransform>();
     Boat = GameObject.Find("Boat");
     mGame = GameObject.FindGameObjectWithTag("Manager").GetComponent<GameManager>();
     //SilhouetteCanvas = SilhouetteCanvasObj.GetComponent<
 }

 public MultiplayerRaceMode(GameManager gameInstance, int laps, int noOfCheckpoints, RaceTrack raceTrack, Car localCar)
     : base(gameInstance, laps, noOfCheckpoints, raceTrack, localCar)
 {
     this.Mode = Mode.Multiplayer;
     players.AddRange(gameInstance.GetService<ServerClient>().Players.Values);
     AddLapTriggers();
 }

 /// <summary>
 /// Inicia o jogador
 /// </summary>
 void Start()
 {
    playerPhysics = GetComponent<PlayerPhysics>();
    animator = GetComponent<Animator>();
    manager = Camera.main.GetComponent<GameManager>();
    animator.SetLayerWeight(0, 0);
 }

 // Use this for initialization
 void Start()
 {
     transform.eulerAngles = Vector3.up * 90;
     playerPhysics = GetComponent<PlayerPhysics> ();
     animator = GetComponent<Animator> ();
     manager = Camera.main.GetComponent<GameManager>();
 }

 // Use this for initialization
 void Start()
 {
     //Set empty color inputs; get references to PM and GM
     activeColors = new List<InputColor>();
     PM = (PhotonManager) GameObject.FindGameObjectWithTag("PhotonManager").GetComponent<PhotonManager>();
     GM = (GameManager) GameObject.FindGameObjectWithTag("GameManager").GetComponent<GameManager>();
 }

    public void DropAll()
    {
        for (int i = 0; i < tileRow.Length; i++)
        {
            tileRow[i].DropTiles();
        }

        foreach(Obstacle obs in obstacles) {
            if(obs != null) {
                obs.Drop();
                obs.GetComponent<SpriteRenderer>().sortingOrder = -10;

                SpriteRenderer[] spriteRenderers = obs.GetComponentsInChildren<SpriteRenderer>();

                for (int i = 0; i < spriteRenderers.Length; i++)
                {
                    spriteRenderers[i].sortingOrder = -10;
                }
            }
        }

        foreach(Collectible coll in collectibles) {
            if(coll != null) {
                coll.Drop();
                coll.GetComponent<SpriteRenderer>().sortingOrder = -10;
            }
        }

        Gem gem = gameObject.GetComponentInChildren<Gem>();
        if(gem != null) {
            gem.Drop();
            gm = GameObject.FindObjectOfType<GameManager>();
            gm.GemDropped();
        }
    }

 void Start()
 {
     manager = GameManager.find();
     text = GetComponent<TextMesh>();
     antiAliasLevel = manager.antiAliasLevel;
     updateText();
 }

 void Awake()
 {
     var manager = GameObject.Find("_Managers");
     GameManager = manager.GetComponent<GameManager>();
     SceneManager = manager.GetComponent<SceneManager>();
     MusicManager = manager.GetComponent<MusicManager>();
 }