public WaitingState(StateMachine sm, CameraManager cam, Game game, float time, Team TeamOnSuper)
     : base(sm, cam, game)
 {
     this.remainingTime = time;
     this.TeamOnSuper = TeamOnSuper;
     this.onWiningPoints = false;
 }

 protected void gvwCamera_RowDeleting(object sender, GridViewDeleteEventArgs e)
 {
     string id = gvwCamera.DataKeys[e.RowIndex].Value.ToString();
     CameraManager cm = new CameraManager();
     cm.DeleteCamera(id, Session["userid"].ToString());
     Query();
 }

    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void Awake()
    {
        cameraManager = GameObject.Find("_CameraTarget").GetComponent<CameraManager>();

        m_groc.gameObject.SetActive(false);
        m_verd.gameObject.SetActive(false);
    }

 private void Start()
 {
     if (!string.IsNullOrEmpty(this.PoseStd) && base.gameObject.animation)
     {
         base.gameObject.animation.CrossFade(this.PoseStd);
     }
     this.cameraMgr = Tools.GetSafeComponent<CameraManager>(base.gameObject);
     this.navAgent = Tools.GetSafeComponent<NavMeshAgent>(base.gameObject);
     this.navAgent.radius = 0.2f;
     this.navAgent.speed = 2.8f;
     this.navAgent.acceleration = 40960f;
     this.navAgent.autoRepath = false;
     this.navAgent.obstacleAvoidanceType = ObstacleAvoidanceType.NoObstacleAvoidance;
     this.navAgent.updateRotation = false;
     GameObject gameObject = Res.Load<GameObject>("Skill/st_002", false);
     if (gameObject != null)
     {
         this.attackArea = (UnityEngine.Object.Instantiate(gameObject) as GameObject);
         if (this.attackArea != null)
         {
             this.attackArea.transform.parent = base.transform;
             this.attackArea.transform.localPosition = Vector3.zero;
             this.attackArea.transform.localRotation = Quaternion.identity;
             this.attackArea.transform.localScale = Vector3.one;
             this.attackArea.layer = base.gameObject.layer;
         }
     }
 }

 // Use this for references
 void Awake() {
     cameraManager = GameObject.FindGameObjectWithTag("CameraManager").GetComponent<CameraManager>();
     rigBody = GetComponent<Rigidbody>();
     Collider[] colliders = GetComponents<Collider>();
     standingColl = colliders[0];
     crouchingColl = colliders[1];
 }

 private void OnCameraChange(CameraManager.CameraMode cameraMode)
 {
     if (cameraMode == CameraManager.CameraMode.IVA) {
         isActive = true;
         activatedAt = DateTime.Now;
     } else
         isActive = false;
 }

 public override void StartStep()
 {
     FindObjectOfType<GameUIManager>().gameObject.SetActive(false);
     mainCamera = Camera.main;
     cameraManager = mainCamera.gameObject.GetComponent<CameraManager>();
     cameraManager.enabled = false;
     mainCamera.DOShakePosition(duration, strenght, vibrato).OnComplete(OnShakeComplete);
 }

 public override void StartStep()
 {
     mainCamera = Camera.main;
     cameraManager = mainCamera.gameObject.GetComponent<CameraManager>();
     cameraManager.enabled = false;
     mainCamera.gameObject.transform.DOMoveY(toMove, duration).SetEase(ease);
     EndStep();
 }

	private void Awake()
	{
		camManager = Camera.mainCamera.GetComponent<CameraManager>();
		cController = GetComponent<CharacterController>();
		animator = GetComponent<Animator>();

		camManager.player = this;
	}

	public override void StartScene (System.Action endCallback, CameraManager cameraManager)
	{
		base.StartScene (endCallback, cameraManager);
		Character character = Menu.Instance.GetCharacterByType(CharacterType.Ataraxia);
		character.PositionTo (initPositionCharacter.position);
		Invoke (Helpers.NameOf(StartDialog),timeToStartMessage);

	}

	protected virtual void Awake()
	{
		playerManager = GameObject.FindWithTag("Player").GetComponent<PlayerManager>();
		cam = GameObject.Find("Camera");
		cameraManager = GameObject.Find("Camera").GetComponent<CameraManager>();
		playerCanvasManager = GameObject.Find("PlayerCanvas").GetComponent<PlayerCanvasManager>();
		StartCoroutine(StartMovie());
	}

    void Awake()
    {
        playerCamera = GameObject.Find("Player Camera").GetComponent<Camera>();
        minimapCamera = GameObject.Find("Minimap Camera").GetComponent<Camera>();
        currPlayer = playerCamera.transform.parent.gameObject.GetComponent<Player>();
        world = GameObject.Find("World");

        cameraMgr = GameObject.FindObjectOfType<CameraManager>();
    }

 public ConnectionManager(WebcamServer s)
 {
     server = s;
     camManager = new CameraManager();
     clients = new List<string>();
     udpSender = new UdpClient();
     udpListener = new UdpClient(1112);
     udpListener.BeginReceive(new AsyncCallback(OnReceive), udpListener);
 }

    // Use this for initialization
    void Awake()
    {
        cm = GetComponentInParent<CameraManager>();

        if (activator1 != null)
        {
            //store activator gameObject in a temporary variable for when null we can retrieve later
            GameObject temp = activator1;
            //  Checks for a trigger collider; If the game object in the activator slot
            // is not trigger, but has a child that is a trigger, the child becomes the activator
            if (activator1.transform.childCount > 0)
            {
                Collider[] _activator1 = activator1.gameObject.GetComponentsInChildren<Collider>();
                activator1 = null;

                foreach (Collider c in _activator1)
                {
                    if (c.isTrigger == true)
                        activator1 = c.gameObject;
                }

                if (activator1 == null)
                    activator1 = temp;

            }
        }
        //do the same thing if a second activator exists
        if (activator2 != null)
        {
            GameObject temp = activator2;
            if (activator2.transform.childCount > 0)
            {
                Collider[] _activator2 = activator2.gameObject.GetComponentsInChildren<Collider>();
                activator2 = null;

                foreach (Collider c in _activator2)
                {
                    if (c.isTrigger == true)
                        activator2 = c.gameObject;
                }

                if (activator2 == null)
                    activator2 = temp;

            }
        }

        //listening for "checkpoint" to swap cameras
        Messenger.AddListener<GameObject,Transform>(listeningForSetCam, SetCam);
        //listening for "playerdied" to switch the follow targets to the alive player
        Messenger.AddListener<string>(listeningForReTarget, SetTarget);
        Messenger.MarkAsPermanent(listeningForSetCam);
        Messenger.MarkAsPermanent(listeningForReTarget);
        if (!startCam)
            gameObject.SetActive(false);
    }

    void Start()
    {
		turnsCompleted = 0;
        gameManager = this;
        currentPlayers = new LinkedList<Entity>();
        currentTurn = JANITOR;
        cameraManager = GetComponent<CameraManager>();
        uiManager = GameObject.FindObjectOfType<UIManager>();
        turnsLeft = turnsPerPlayer;
    }

	public virtual void StartScene (Action endCallback, CameraManager cameraManager)
	{
		isOver = false;
		End = endCallback;
		this.cameraManager = cameraManager;
		if(camera != null)
			this.cameraManager.SetCamera3D(camera);
		else
			this.cameraManager.SetDefault ();
	}

 public static CameraManager GetCameraManager()
 {
     if(cameraManager == null)
     {
         cameraManager = cameraManagerGameObject.AddComponent<CameraManager>();
     }
     else
         return null;
     return cameraManager;
 }

    // Use this for initialization
    void Awake()
    {
        cm = GetComponentInParent<CameraManager>();

        Messenger.AddListener<string,string>(listeningForSetCam, SetCam);
        Messenger.AddListener<string>(listeningForReTarget, SetTarget);
        Messenger.MarkAsPermanent(listeningForSetCam);
        Messenger.MarkAsPermanent(listeningForReTarget);
        if (!startCam)
            gameObject.SetActive(false);
    }

        /// <summary>
        /// Create a state with a 3D scene and a camera.
        /// </summary>
        /// <param name="camera">Camera to use on this scene.</param>
        public YnState3D(BaseCamera camera)
            : base()
        {
            if (camera != null)
                _cameraManager = new CameraManager(camera);
            else
                _cameraManager = new CameraManager();

            _scene = new YnScene3D();
            _basicObjects = new YnBasicCollection();
        }

    void Awake()
    {
        if (cameraManager == null)
            cameraManager = GetComponent<CameraManager>();

        backKiller = transform.Find ("BackKiller");
        fallingKiller = transform.Find ("FallingKiller");

        backKillerCollider = backKiller.GetComponent<Collider2D>();
        fallingKillerCollider = fallingKiller.GetComponent<Collider2D>();
    }