// Use this for initialization
 public override void Start()
 {
     base.Start();
     motor = GetComponent<CharacterMotor>();
     animator = GetComponentInChildren<Animator>();
     StartCoroutine("AI");
 }

 // Use this for initialization
 void Start()
 {
     Input.multiTouchEnabled = true;
     characterMotorScript = objPlayer.GetComponent<CharacterMotor>();
     characterJumpScript = objPlayer.GetComponent<CharacterJump2>();
     characterShotScript = objPlayer.GetComponent<CharacterShot>();
 }

 // Use this for initialization
 void Start()
 {
     chMotor =  GetComponent<CharacterMotor>();
     tr = transform;
     CharacterController ch = GetComponent<CharacterController>();
     dist = ch.height/2; // calculate distance to ground
 }

 // Use this for initialization
 void Start()
 {
     controller = gameObject.transform.root.GetComponent<CharacterController>();
     motor = gameObject.transform.root.GetComponent<CharacterMotor>();
     inventory = gameObject.transform.root.GetComponent<Inventory>();
     vitals = gameObject.transform.root.GetComponent<PlayerVitals>();
 }

	//setup
	void Awake()
	{
		//create single floorcheck in centre of object, if none are assigned
		if(!floorChecks)
		{
			floorChecks = new GameObject().transform;
			floorChecks.name = "FloorChecks";
			floorChecks.parent = transform;
			floorChecks.position = transform.position;
			GameObject check = new GameObject();
			check.name = "Check1";
			check.transform.parent = floorChecks;
			check.transform.position = transform.position;
			Debug.LogWarning("No 'floorChecks' assigned to PlayerMove script, so a single floorcheck has been created", floorChecks);
		}
		//assign player tag if not already
		if(tag != "Player")
		{
			tag = "Player";
			Debug.LogWarning ("PlayerMove script assigned to object without the tag 'Player', tag has been assigned automatically", transform);
		}
		//usual setup
		mainCam = GameObject.FindGameObjectWithTag("MainCamera").transform;
		dealDamage = GetComponent<DealDamage>();
		characterMotor = GetComponent<CharacterMotor>();
		rigid = GetComponent<Rigidbody>();
		aSource = GetComponent<AudioSource>();
		//gets child objects of floorcheckers, and puts them in an array
		//later these are used to raycast downward and see if we are on the ground
		floorCheckers = new Transform[floorChecks.childCount];
		for (int i=0; i < floorCheckers.Length; i++)
			floorCheckers[i] = floorChecks.GetChild(i);
	}

    // Use this for initialization
    void Awake()
    {
        _Game = GameObject.Find("Game");
        c_Game = _Game.GetComponentInChildren<Game>();

        motor = GetComponent<CharacterMotor>();
    }

    //Variables End___________________________________________________________
    // Use this for initialization
    void Start()
    {
        if(networkView.isMine == true)
        {

            myTransform = transform;

            cameraHead = myTransform.FindChild("CameraHead");

            motorScript = myTransform.GetComponent<CharacterMotor>();

            //Access the PlayerStats script and get the player's max speed.
            //This is their normal movement speed outside of the water.

            GameObject gManager = GameObject.Find("GameManager");

            PlayerStats statScript = gManager.GetComponent<PlayerStats>();

            normalSpeed = statScript.maxSpeed;
        }

        else
        {
            enabled = false;
        }
    }

	//setup
	void Awake()
	{		
		characterMotor = GetComponent<CharacterMotor>();
		dealDamage = GetComponent<DealDamage>();
		//avoid setup errors
		if(tag != "Enemy")
		{
			tag = "Enemy";
			Debug.LogWarning("'EnemyAI' script attached to object without 'Enemy' tag, it has been assign automatically", transform);
		}
		
		if(sightBounds)
		{
			sightTrigger = sightBounds.GetComponent<TriggerParent>();
			if(!sightTrigger)
				Debug.LogError("'TriggerParent' script needs attaching to enemy 'SightBounds'", sightBounds);
		}
		if(!sightBounds)
			Debug.LogWarning("Assign a trigger with 'TriggerParent' script attached, to 'SightBounds' or enemy will not be able to see", transform);
		
		if(attackBounds)
		{
			attackTrigger = attackBounds.GetComponent<TriggerParent>();
			if(!attackTrigger)
				Debug.LogError("'TriggerParent' script needs attaching to enemy 'attackBounds'", attackBounds);
		}
		else
			Debug.LogWarning("Assign a trigger with 'TriggerParent' script attached, to 'AttackBounds' or enemy will not be able to attack", transform);
	}

	// Use this for initialization
	void Start () {
		audioSource.clip = audio;
		mouse = player.GetComponent<MouseLook>();
		motor = player.GetComponent<CharacterMotor>();
		triggered = false;
		charControl = player.GetComponent<CharacterController>();
	}

    //setup
    void Awake()
    {
        if(transform.tag != "Enemy")
        {
            //add kinematic rigidbody
            if(!GetComponent<Rigidbody>())
                gameObject.AddComponent<Rigidbody>();
            GetComponent<Rigidbody>().isKinematic = true;
            GetComponent<Rigidbody>().useGravity = false;
            GetComponent<Rigidbody>().interpolation = RigidbodyInterpolation.Interpolate;
        }
        else
        {
            characterMotor = GetComponent<CharacterMotor>();
            enemyAI = GetComponent<EnemyAI>();
        }

        //get child waypoints, then detach them (so object can move without moving waypoints)
        foreach (Transform child in transform)
            if(child.tag == "Waypoint")
                waypoints.Add (child);

        foreach(Transform waypoint in waypoints)
            waypoint.parent = null;

        if(waypoints.Count == 0)
            Debug.LogError("No waypoints found for 'MoveToPoints' script. To add waypoints: add child gameObjects with the tag 'Waypoint'", transform);
    }

 // Use this for initialization
 protected virtual void Start()
 {
     SetInitialProperties();
     characterController = GetComponent<CharacterController>();
     control = GetComponent<Controller>();
     motor = GetComponent<CharacterMotor>();
 }

    void Start()
    {
        worldManager = (WorldManager)FindObjectOfType (typeof(WorldManager));
        guiManager = (GUIManager)FindObjectOfType (typeof(GUIManager));

        characterMotor=worldManager.getPlayer().GetComponent<CharacterMotor>();
    }

 // Use this for initialization
 private void OnEnable()
 {
     myTransform = transform;
     characterMotor = GetComponent<CharacterMotor>();
     characterController = GetComponent<CharacterController>();
     isFlying = false;
 }

    // Use this for initialization
    void Start()
    {
        motor = GetComponent(typeof(CharacterMotor)) as CharacterMotor;
        if (motor==null) Debug.Log("Motor is null!!");

        originalRotation = transform.localRotation;
    }

    void Awake()
    {
        cameraScript = GetComponent<MouseLook>();
        cameraScript2 = camera.GetComponent<MouseLook>();
        controllerScript = GetComponent<CharacterMotor>();
        shotScript = GetComponent<Shot>();

         if (photonView.isMine)
        {
            this.camera.camera.enabled=true;
            cameraScript.enabled = true;
            cameraScript2.enabled = true;
            controllerScript.canControl = true;
            shotScript.enabled=true;
        }
        else
        {
            this.camera.camera.enabled=false;
            cameraScript.enabled = false;
            cameraScript2.enabled = false;
            controllerScript.canControl = false;
            shotScript.enabled=false;
        }

        gameObject.name = gameObject.name + photonView.viewID.ID;
    }

 void Awake()
 {
     movement 	= pc.GetComponent <CharacterMotor> ();
     message 	= text.GetComponent <uiSystem> ();
     cam 		= holder.GetComponent <cameraScript> ();
     menu 		= holder.GetComponent <menuScript> ();
 }

//	bool inReload { get { return animation[reloadAnimation.name].enabled; } }
//	bool inTransition { get { return animation[gunOffAnimation.name].enabled || animation[gunOnAnimation.name].enabled;	} }
//	bool inFire { get { return animation[fireAnimation.name].enabled; } }
	
	// Set up upper body animation
	/*private void SetupGunAnimation (AnimationClip animationClip) {
		AnimationState a = animation[animationClip.name];
				a.wrapMode = WrapMode.Once;
				a.layer = 1;
				a.AddMixingTransform(spine);
				a.AddMixingTransform(rightGun);
	}*/

	// Use this for initialization
	void Start () {
	//	if (gunOnAnimation == null || gunOffAnimation == null || reloadAnimation == null || fireAnimation == null || muzzleFlash == null)
			enabled = false;
			
	/*	SetupGunAnimation(gunOnAnimation);
			SetupGunAnimation(gunOffAnimation);
			SetupGunAnimation(reloadAnimation);*/
		
		// setup additive fire animation
		/*AnimationState fireAS = animation[fireAnimation.name];
				fireAS.wrapMode = WrapMode.Once;
				fireAS.layer = 101; // we put it in a separate layer than impact animations
				fireAS.blendMode = AnimationBlendMode.Additive;*/
		
		motor = GetComponent(typeof(CharacterMotor)) as CharacterMotor;
		
		LegController legC = GetComponent(typeof(LegController)) as LegController;
		IMotionAnalyzer[] motions = legC.motions;
		foreach (IMotionAnalyzer motion in motions) {
			if (motion.name == "RunForward")
				maxSpeedWithGun = motion.cycleSpeed;
			if (motion.name == "RunForwardNoGun")
				maxSpeedWithoutGun = motion.cycleSpeed;
			//if (motion.name == "RunForwardFastNoGun")
			//	maxSpeedWithoutGun = motion.cycleSpeed;
		}
		
		muzzleFlash.enabled = false;
	}

    private float y = 0.0f; // Storing camera angle

    #endregion Fields

    #region Methods

    // Use this for initialization
    void Awake()
    {
        motor = GetComponent<CharacterMotor>();
        game = GameObject.Find ("_GAMECORE").GetComponent<Game> ();
        if (!firstPersonCam) {
            firstPersonCam = (Camera)this.transform.FindChild ("PlayerView").GetComponent<Camera>();
        }
    }

	void Awake()
	{
        m_charController = gameObject.AddComponent<CharacterController>();
        m_charMotor = gameObject.AddComponent<CharacterMotor>();

        IsMoving = false;
        CanMove = true;
	} 

    public void Start()
    {
        theCharacterMotor = GetComponent<CharacterMotor> ();
        jumpTimeCounter = jumpTime;

        groundCheckObj = transform.FindChild ("GroundCheck").gameObject;
        groundCheck = groundCheckObj.GetComponent<Collider2D> ();
    }