using UnityEngine;  using System.Collections;  

public class DonePlayerMovement : MonoBehaviour  
{  
    public AudioClip shoutingClip;      // 玩家大喊的声音  
    public float turnSmoothing = 15f;   // 用于玩家平滑转向的值  
    public float speedDampTime = 0.1f;  // 用于控制从一个值变化到另一个的时间限制  


    private Animator anim;                
    private DoneHashIDs hash;           // 保存各种动画状态的hash  


    void Awake ()  
    {  
        anim = GetComponent<Animator>();  
        hash = GameObject.FindGameObjectWithTag(DoneTags.gameController).GetComponent<DoneHashIDs>();  

        // Set the weight of the shouting layer to 1.  
        anim.SetLayerWeight(1, 1f);  
    }  


    void FixedUpdate ()  
    {  
        // Cache the inputs.  
        float h = Input.GetAxis("Horizontal");  
        float v = Input.GetAxis("Vertical");  
        bool sneak = Input.GetButton("Sneak");  

        MovementManagement(h, v, sneak);  
    }  


    void Update ()  
    {  
        // Cache the attention attracting input.  
        bool shout = Input.GetButtonDown("Attract");  

        // Set the animator shouting parameter.  
        anim.SetBool(hash.shoutingBool, shout);  

        AudioManagement(shout);  
    }  


    void MovementManagement (float horizontal, float vertical, bool sneaking)  
    {  
        // Set the sneaking parameter to the sneak input.  
        anim.SetBool(hash.sneakingBool, sneaking);  

        // If there is some axis input...  
        if(horizontal != 0f || vertical != 0f)  
        {  
            // ... set the players rotation and set the speed parameter to 5.5f.  
            Rotating(horizontal, vertical);  
            anim.SetFloat(hash.speedFloat, 5.5f, speedDampTime, Time.deltaTime);  
        }  
        else  
            // Otherwise set the speed parameter to 0.  
            anim.SetFloat(hash.speedFloat, 0);  
    }  


    void Rotating (float horizontal, float vertical)  
    {  
        // Create a new vector of the horizontal and vertical inputs.  
        Vector3 targetDirection = new Vector3(horizontal, 0f, vertical);  

        // Create a rotation based on this new vector assuming that up is the global y axis.  
        Quaternion targetRotation = Quaternion.LookRotation(targetDirection, Vector3.up);  

        // Create a rotation that is an increment closer to the target rotation from the player's rotation.  
        Quaternion newRotation = Quaternion.Lerp(rigidbody.rotation, targetRotation, turnSmoothing * Time.deltaTime);  

        // Change the players rotation to this new rotation.  
        rigidbody.MoveRotation(newRotation);  
    }  


    void AudioManagement (bool shout)  
    {  
        // If the player is currently in the run state...  
        if(anim.GetCurrentAnimatorStateInfo(0).nameHash == hash.locomotionState)  
        {  
            // ... and if the footsteps are not playing...  
            if(!audio.isPlaying)  
                // ... play them.  
                audio.Play();  
        }  
        else  
            // Otherwise stop the footsteps.  
            audio.Stop();  

        // If the shout input has been pressed...  
        if(shout)  
            // ... play the shouting clip where we are.  
            AudioSource.PlayClipAtPoint(shoutingClip, transform.position);  
    }  
}  

void MovementManagement (float horizontal, float vertical, bool sneaking)  
{  
    // Set the sneaking parameter to the sneak input.  
    anim.SetBool(hash.sneakingBool, sneaking);  

    // If there is some axis input...  
    if(horizontal != 0f || vertical != 0f)  
    {  
        // ... set the players rotation and set the speed parameter to 5.5f.  
        Rotating(horizontal, vertical);  
        anim.SetFloat(hash.speedFloat, 5.5f, speedDampTime, Time.deltaTime);  
    }  
    else  
        // Otherwise set the speed parameter to 0.  
        anim.SetFloat(hash.speedFloat, 0);  
}  

void Rotating (float horizontal, float vertical)  
{  
    // 创建一个Vector3用于保存输入的水平位移方向  
    Vector3 targetDirection = new Vector3(horizontal, 0f, vertical);  

    // 根据上面的方向计算这个方向指向的角度  
    Quaternion targetRotation = Quaternion.LookRotation(targetDirection, Vector3.up);  

    // 创建一个从玩家当前方向旋转到目标方向的旋转增量  
    Quaternion newRotation = Quaternion.Lerp(rigidbody.rotation, targetRotation, turnSmoothing * Time.deltaTime);  

    // 修改玩家的方向  
    rigidbody.MoveRotation(newRotation);  
}  

using UnityEngine;  
using System.Collections;  

public class DoneEnemySight : MonoBehaviour  
{  
    // Number of degrees, centred on forward, for the enemy see. 
    public float fieldOfViewAngle = 110f; 
    // Whether or not the player is currently sighted.                 
    public bool playerInSight; 
    // Last place this enemy spotted the player.                          
    public Vector3 personalLastSighting;                

    // Reference to the NavMeshAgent component.  
    private NavMeshAgent nav;  
    // Reference to the sphere collider trigger component.                           
    private SphereCollider col;  
    // Reference to the Animator.                        
    private Animator anim; 
    // Reference to last global sighting of the player.                               
    private DoneLastPlayerSighting lastPlayerSighting; 
    // Reference to the player.   
    private GameObject player; 
    // Reference to the player's animator component.                          
    private Animator playerAnim; 
    // Reference to the player's health script.                          
    private DonePlayerHealth playerHealth;
    // Reference to the HashIDs.               
    private DoneHashIDs hash; 
    // Where the player was sighted last frame.                          
    private Vector3 previousSighting;                   


    void Awake ()  
    {  
        // Setting up the references.  
        nav = GetComponent<NavMeshAgent>();  
        col = GetComponent<SphereCollider>();  
        anim = GetComponent<Animator>();  
        lastPlayerSighting = GameObject.FindGameObjectWithTag(DoneTags.gameController).GetComponent<DoneLastPlayerSighting>();  
        player = GameObject.FindGameObjectWithTag(DoneTags.player);  
        playerAnim = player.GetComponent<Animator>();  
        playerHealth = player.GetComponent<DonePlayerHealth>();  
        hash = GameObject.FindGameObjectWithTag(DoneTags.gameController).GetComponent<DoneHashIDs>();  

        // Set the personal sighting and the previous sighting to the reset position.  
        personalLastSighting = lastPlayerSighting.resetPosition;  
        previousSighting = lastPlayerSighting.resetPosition;  
    }  


    void Update ()  
    {  
        // If the last global sighting of the player has changed...  
        if(lastPlayerSighting.position != previousSighting)  
            // ... then update the personal sighting to be the same as the global sighting.  
            personalLastSighting = lastPlayerSighting.position;  

        // Set the previous sighting to the be the sighting from this frame.  
        previousSighting = lastPlayerSighting.position;  

        // If the player is alive...  
        if(playerHealth.health > 0f)  
            // ... set the animator parameter to whether the player is in sight or not.  
            anim.SetBool(hash.playerInSightBool, playerInSight);  
        else  
            // ... set the animator parameter to false.  
            anim.SetBool(hash.playerInSightBool, false);  
    }  


    void OnTriggerStay (Collider other)  
    {  
        // If the player has entered the trigger sphere...  
        if(other.gameObject == player)  
        {  
            // By default the player is not in sight.  
            playerInSight = false;  

            // Create a vector from the enemy to the player and store the angle between it and forward.  
            Vector3 direction = other.transform.position - transform.position;  
            float angle = Vector3.Angle(direction, transform.forward);  

            // If the angle between forward and where the player is, is less than half the angle of view...  
            if(angle < fieldOfViewAngle * 0.5f)  
            {  
                RaycastHit hit;  

                // ... and if a raycast towards the player hits something...  
                if(Physics.Raycast(transform.position + transform.up, direction.normalized, out hit, col.radius))  
                {  
                    // ... and if the raycast hits the player...  
                    if(hit.collider.gameObject == player)  
                    {  
                        // ... the player is in sight.  
                        playerInSight = true;  

                        // Set the last global sighting is the players current position.  
                        lastPlayerSighting.position = player.transform.position;  
                    }  
                }  
            }  

            // Store the name hashes of the current states.  
            int playerLayerZeroStateHash = playerAnim.GetCurrentAnimatorStateInfo(0).nameHash;  
            int playerLayerOneStateHash = playerAnim.GetCurrentAnimatorStateInfo(1).nameHash;  

            // If the player is running or is attracting attention...  
            if(playerLayerZeroStateHash == hash.locomotionState || playerLayerOneStateHash == hash.shoutState)  
            {  
                // ... and if the player is within hearing range...  
                if(CalculatePathLength(player.transform.position) <= col.radius)  
                    // ... set the last personal sighting of the player to the player's current position.  
                    personalLastSighting = player.transform.position;  
            }  
        }  
    }  


    void OnTriggerExit (Collider other)  
    {  
        // If the player leaves the trigger zone...  
        if(other.gameObject == player)  
            // ... the player is not in sight.  
            playerInSight = false;  
    }  


    float CalculatePathLength (Vector3 targetPosition)  
    {  
        // Create a path and set it based on a target position.  
        NavMeshPath path = new NavMeshPath();  
        if(nav.enabled)  
            nav.CalculatePath(targetPosition, path);  

        // Create an array of points which is the length of the number of corners in the path + 2.  
        Vector3 [] allWayPoints = new Vector3[path.corners.Length + 2];  

        // The first point is the enemy's position.  
        allWayPoints[0] = transform.position;  

        // The last point is the target position.  
        allWayPoints[allWayPoints.Length - 1] = targetPosition;  

        // The points inbetween are the corners of the path.  
        for(int i = 0; i < path.corners.Length; i++)  
        {  
            allWayPoints[i + 1] = path.corners[i];  
        }  

        // Create a float to store the path length that is by default 0.  
        float pathLength = 0;  

        // Increment the path length by an amount equal to the distance between each waypoint and the next.  
        for(int i = 0; i < allWayPoints.Length - 1; i++)  
        {  
            pathLength += Vector3.Distance(allWayPoints[i], allWayPoints[i + 1]);  
        }  

        return pathLength;  
    }  
}  

using UnityEngine;  
using System.Collections;  

public class DoneEnemyAI : MonoBehaviour  
{  
    public float patrolSpeed = 2f; 
    // The nav mesh agent's speed when chasing.                         
    public float chaseSpeed = 5f;
    // The amount of time to wait when the last sighting is reached.                               
    public float chaseWaitTime = 5f;
    // The amount of time to wait when the patrol way point is reached.                          
    public float patrolWaitTime = 1f; 
    // An array of transforms for the patrol route.                      
    public Transform[] patrolWayPoints;                      

    // Reference to the EnemySight script.
    private DoneEnemySight enemySight;  
    // Reference to the nav mesh agent.                       
    private NavMeshAgent nav;
    // Reference to the player's transform.                               
    private Transform player; 
    // Reference to the PlayerHealth script.                               
    private DonePlayerHealth playerHealth; 
    // Reference to the last global sighting of the player.                     
    private DoneLastPlayerSighting lastPlayerSighting;    
    // A timer for the chaseWaitTime.    
    private float chaseTimer;  
    // A timer for the patrolWaitTime.                               
    private float patrolTimer;
    // A counter for the way point array.                                
    private int wayPointIndex;                            


    void Awake ()  
    {  
        // Setting up the references.  
        enemySight = GetComponent<DoneEnemySight>();  
        nav = GetComponent<NavMeshAgent>();  
        player = GameObject.FindGameObjectWithTag(DoneTags.player).transform;  
        playerHealth = player.GetComponent<DonePlayerHealth>();  
        lastPlayerSighting = GameObject.FindGameObjectWithTag(DoneTags.gameController).GetComponent<DoneLastPlayerSighting>();  
    }  


    void Update ()  
    {  
        // If the player is in sight and is alive...  
        if(enemySight.playerInSight && playerHealth.health > 0f)  
            // ... shoot.  
            Shooting();  

        // If the player has been sighted and isn't dead...  
        else if(enemySight.personalLastSighting != lastPlayerSighting.resetPosition && playerHealth.health > 0f)  
            // ... chase.  
            Chasing();  

        // Otherwise...  
        else  
            // ... patrol.  
            Patrolling();  
    }  


    void Shooting ()  
    {  
        // Stop the enemy where it is.  
        nav.Stop();  
    }  


    void Chasing ()  
    {  
        // Create a vector from the enemy to the last sighting of the player.  
        Vector3 sightingDeltaPos = enemySight.personalLastSighting - transform.position;  

        // If the the last personal sighting of the player is not close...  
        if(sightingDeltaPos.sqrMagnitude > 4f)  
            // ... set the destination for the NavMeshAgent to the last personal sighting of the player.  
            nav.destination = enemySight.personalLastSighting;  

        // Set the appropriate speed for the NavMeshAgent.  
        nav.speed = chaseSpeed;  

        // If near the last personal sighting...  
        if(nav.remainingDistance < nav.stoppingDistance)  
        {  
            // ... increment the timer.  
            chaseTimer += Time.deltaTime;  

            // If the timer exceeds the wait time...  
            if(chaseTimer >= chaseWaitTime)  
            {  
                // ... reset last global sighting, the last personal sighting and the timer.  
                lastPlayerSighting.position = lastPlayerSighting.resetPosition;  
                enemySight.personalLastSighting = lastPlayerSighting.resetPosition;  
                chaseTimer = 0f;  
            }  
        }  
        else  
            // If not near the last sighting personal sighting of the player, reset the timer.  
            chaseTimer = 0f;  
    }  


    void Patrolling ()  
    {  
        // Set an appropriate speed for the NavMeshAgent.  
        nav.speed = patrolSpeed;  

        // If near the next waypoint or there is no destination...  
        if(nav.destination == lastPlayerSighting.resetPosition || nav.remainingDistance < nav.stoppingDistance)  
        {  
            // ... increment the timer.  
            patrolTimer += Time.deltaTime;  

            // If the timer exceeds the wait time...  
            if(patrolTimer >= patrolWaitTime)  
            {  
                // ... increment the wayPointIndex.  
                if(wayPointIndex == patrolWayPoints.Length - 1)  
                    wayPointIndex = 0;  
                else  
                    wayPointIndex++;  

                // Reset the timer.  
                patrolTimer = 0;  
            }  
        }  
        else  
            // If not near a destination, reset the timer.  
            patrolTimer = 0;  

        // Set the destination to the patrolWayPoint.  
        nav.destination = patrolWayPoints[wayPointIndex].position;  
    }  
}  

using UnityEngine;  
using System.Collections;  

public class DoneEnemyShooting : MonoBehaviour  
{  
    // The maximum potential damage per shot.
    public float maximumDamage = 120f; 
    // The minimum potential damage per shot.                     
    public float minimumDamage = 45f;  
    // An audio clip to play when a shot happens.                   
    public AudioClip shotClip; 
    // The intensity of the light when the shot happens.                           
    public float flashIntensity = 3f; 
    // How fast the light will fade after the shot.                    
    public float fadeSpeed = 10f;                       

    // Reference to the animator.  
    private Animator anim;  
    // Reference to the HashIDs script.                        
    private DoneHashIDs hash;  
    // Reference to the laser shot line renderer.                            
    private LineRenderer laserShotLine; 
    // Reference to the laser shot light.                  
    private Light laserShotLight; 
    // Reference to the sphere collider.                       
    private SphereCollider col;
    // Reference to the player's transform.                          
    private Transform player;  
    // Reference to the player's health.                           
    private DonePlayerHealth playerHealth;  
    // A bool to say whether or not the enemy is currently shooting.              
    private bool shooting;
    // Amount of damage that is scaled by the distance from the player.                                
    private float scaledDamage;                         


    void Awake ()  
    {  
        // Setting up the references.  
        anim = GetComponent<Animator>();  
        laserShotLine = GetComponentInChildren<LineRenderer>();  
        laserShotLight = laserShotLine.gameObject.light;  
        col = GetComponent<SphereCollider>();  
        player = GameObject.FindGameObjectWithTag(DoneTags.player).transform;  
        playerHealth = player.gameObject.GetComponent<DonePlayerHealth>();  
        hash = GameObject.FindGameObjectWithTag(DoneTags.gameController).GetComponent<DoneHashIDs>();  

        // The line renderer and light are off to start.  
        laserShotLine.enabled = false;  
        laserShotLight.intensity = 0f;  

        // The scaledDamage is the difference between the maximum and the minimum damage.  
        scaledDamage = maximumDamage - minimumDamage;  
    }  


    void Update ()  
    {  
        // Cache the current value of the shot curve.  
        float shot = anim.GetFloat(hash.shotFloat);  

        // If the shot curve is peaking and the enemy is not currently shooting...  
        if(shot > 0.5f && !shooting)  
            // ... shoot  
            Shoot();  

        // If the shot curve is no longer peaking...  
        if(shot < 0.5f)  
        {  
            // ... the enemy is no longer shooting and disable the line renderer.  
            shooting = false;  
            laserShotLine.enabled = false;  
        }  

        // Fade the light out.  
        laserShotLight.intensity = Mathf.Lerp(laserShotLight.intensity, 0f, fadeSpeed * Time.deltaTime);  
    }  


    void OnAnimatorIK (int layerIndex)  
    {  
        // Cache the current value of the AimWeight curve.  
        float aimWeight = anim.GetFloat(hash.aimWeightFloat);  

        // Set the IK position of the right hand to the player's centre.  
        anim.SetIKPosition(AvatarIKGoal.RightHand, player.position + Vector3.up * 1.5f);  

        // Set the weight of the IK compared to animation to that of the curve.  
        anim.SetIKPositionWeight(AvatarIKGoal.RightHand, aimWeight);  
    }  


    void Shoot ()  
    {  
        // The enemy is shooting.  
        shooting = true;  

        // The fractional distance from the player, 1 is next to the player, 0 is the player is at the extent of the sphere collider.  
        float fractionalDistance = (col.radius - Vector3.Distance(transform.position, player.position)) / col.radius;  

        // The damage is the scaled damage, scaled by the fractional distance, plus the minimum damage.  
        float damage = scaledDamage * fractionalDistance + minimumDamage;  

        // The player takes damage.  
        playerHealth.TakeDamage(damage);  

        // Display the shot effects.  
        ShotEffects();  
    }  


    void ShotEffects ()  
    {  
        // Set the initial position of the line renderer to the position of the muzzle.  
        laserShotLine.SetPosition(0, laserShotLine.transform.position);  

        // Set the end position of the player's centre of mass.  
        laserShotLine.SetPosition(1, player.position + Vector3.up * 1.5f);  

        // Turn on the line renderer.  
        laserShotLine.enabled = true;  

        // Make the light flash.  
        laserShotLight.intensity = flashIntensity;  

        // Play the gun shot clip at the position of the muzzle flare.  
        AudioSource.PlayClipAtPoint(shotClip, laserShotLight.transform.position);  
    }  
}