耗時一周制作的第一人稱射擊游戲，希望能幫助到大家！

游戲展示

資源

鏈接：https://pan.baidu.com/s/15s8KSN_4JPAvD_fA8OIiCg
提取碼：1vod

代碼

AnimatorSetup.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class AnimatorSetup 
{
    public float speedDampTime = 0.1f;                      //速度阻尼時間
    public float angularSpeedDampTime = 0.7f;               //角速度阻尼時間
    public float angularResponseTime = 1f;                  //角度反應時間

    private Animator animator;
    private HashIDs hashIDs;

    public AnimatorSetup(Animator animator ,HashIDs hashIDs)
    {
        this.animator = animator;
        this.hashIDs = hashIDs;
    }

    public void Setup(float speed,float angular)
    {
        float angularSpeed = angular / angularResponseTime;
        animator.SetFloat(hashIDs.speedFloat, speed, speedDampTime, Time.deltaTime);
        animator.SetFloat(hashIDs.angularSpeedFloat, angularSpeed, angularSpeedDampTime, Time.deltaTime);
    }
}

FadeInOut.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

/// <summary>
/// 漸隱漸現效果
/// </summary>
public class FadeInOut : MonoBehaviour
{
    private float fadeSpeed = 1f;             //漸隱漸現的速率
    private bool sceneStarting = true;          //場景是否開始
    private RawImage rawImage;


    void Start()
    {
        RectTransform rectTransform = this.GetComponent<RectTransform>();
        //使背景滿屏
        rectTransform.sizeDelta = new Vector2(Screen.width, Screen.height);     
        rawImage = this.GetComponent<RawImage>();
        rawImage.uvRect = new Rect(0, 0, Screen.width, Screen.height);
        rawImage.enabled = true;
    }

    void Update()
    {
        if (sceneStarting)
        {
            StartScene();
        }
    }

    /// <summary>
    /// 漸隱效果
    /// </summary>
    private void FadeToClear()
    {
        rawImage.color = Color.Lerp(rawImage.color, Color.clear, fadeSpeed * Time.deltaTime);
    }

    /// <summary>
    /// 漸現效果
    /// </summary>
    private void FadeToBlack()
    {
        rawImage.color = Color.Lerp(rawImage.color, Color.black, fadeSpeed * Time.deltaTime);
    }

    /// <summary>
    /// 場景開始時漸隱
    /// </summary>
    private void StartScene()
    {
        FadeToClear();
        if (rawImage.color.a <= 0.05f)
        {
            rawImage.color = Color.clear;
            rawImage.enabled = false;
            sceneStarting = false;
        }
    }

    /// <summary>
    /// 場景結束時漸現
    /// </summary>
    public void EndScene()
    {
        rawImage.enabled = true;
        FadeToBlack();
        if (rawImage.color.a >= 0.95f)
        {
            SceneManager.LoadScene("Scene_1");
        }
    }
}

FPS_Camera.cs

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

[RequireComponent(typeof(Camera))]
public class FPS_Camera : MonoBehaviour
{
    public Vector2 mouseLookSensitivity = new Vector2(3, 3);    //滑鼠靈敏度
    public Vector2 rotationXLimit = new Vector2(-87, 87);       //上下旋轉限制
    public Vector2 rotationYLimit = new Vector2(-360, 360);     //左右旋轉限制
    public Vector3 positionOffset = new Vector3(0, 2, -0.2f);   //位置偏移

    private Vector2 currentMouseLook = Vector2.zero;            //當前滑鼠
    private float x_Angle = 0;                                  //X軸旋轉角度
    private float y_Angle = 0;                                  //Y軸旋轉角度
    private FPS_PlayerParameters parameters;                    //
    private Transform mTransform;                               //玩家實體

    private void Start()
    {
        parameters = GameObject.FindGameObjectWithTag(Tags.player).GetComponent<FPS_PlayerParameters>();
        mTransform = transform;
        mTransform.localPosition = positionOffset;
    }

    private void Update()
    {
        InputUpdate();
        LateUpdate();
    }

    private void LateUpdate()
    {
        //左右旋轉
        Quaternion xQuaternion = Quaternion.AngleAxis(y_Angle, Vector3.up);
        //上下旋轉
        Quaternion yQuaternion = Quaternion.AngleAxis(0, Vector3.left);
        //角色不旋轉
        mTransform.parent.rotation = xQuaternion * yQuaternion;

        yQuaternion = Quaternion.AngleAxis(x_Angle, Vector3.left);
        //攝像機旋轉
        mTransform.rotation = xQuaternion * yQuaternion;
    }

    /// <summary>
    /// 更新用戶輸入處理
    /// </summary>
    private void InputUpdate()
    {
        //如果滑鼠還沒有動作
        if(parameters.inputSmoothLook == Vector2.zero)
        {
            return;
        }
        GetMouseLook();
        //繞Y軸旋轉實際上是水平旋轉
        y_Angle += currentMouseLook.x;
        //繞X軸旋轉實際上是豎直旋轉
        x_Angle += currentMouseLook.y;
        //避免Y軸超出旋轉限制
        y_Angle = y_Angle < -360 ? y_Angle + 360 : y_Angle;
        y_Angle = y_Angle > 360 ? y_Angle - 360 : y_Angle;
        y_Angle = Mathf.Clamp(y_Angle, rotationYLimit.x, rotationYLimit.y);
        //避免X軸超出旋轉限制
        x_Angle = x_Angle < -360 ? x_Angle + 360 : x_Angle;
        x_Angle = x_Angle > 360 ? x_Angle - 360 : x_Angle;
        x_Angle = Mathf.Clamp(x_Angle, rotationXLimit.y, rotationXLimit.x);
    }

    /// <summary>
    /// 當前視角跟隨滑鼠移動
    /// </summary>
    private void GetMouseLook()
    {
        currentMouseLook.x = parameters.inputSmoothLook.x;
        currentMouseLook.y = parameters.inputSmoothLook.y;

        //視角旋轉加入靈敏度
        currentMouseLook.x *= mouseLookSensitivity.x;
        currentMouseLook.y *= mouseLookSensitivity.y;
    }
}

FPS_CrossHair.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class FPS_CrossHair : MonoBehaviour
{
    public float length;                            //長度
    public float width;                             //寬度
    public float distance;                          //間距
    public Texture2D crossHairTexture;              //2D紋理

    private GUIStyle lineStyle;                     //樣式
    private Texture texture;                        //紋理


    private void Start()
    {
        lineStyle = new GUIStyle();
        lineStyle.normal.background = crossHairTexture;
    }

    private void OnGUI()
    {
        //十字坐標左邊矩形
        GUI.Box(new Rect(Screen.width / 2 - distance / 2 - length, Screen.height / 2 - width / 2, length, width), texture, lineStyle);
        //十字坐標右邊矩形
        GUI.Box(new Rect(Screen.width / 2 + distance / 2, Screen.height / 2 - width / 2, length, width), texture, lineStyle);
        //十字坐標上邊矩形
        GUI.Box(new Rect(Screen.width / 2 - width / 2, Screen.height / 2 - distance / 2 - length, width, length), texture, lineStyle);
        //十字坐標下邊矩形
        GUI.Box(new Rect(Screen.width / 2 - width / 2, Screen.height / 2 + distance / 2, width, length), texture, lineStyle);
    }
}

FPS_DoorControl.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class FPS_DoorControl : MonoBehaviour
{
    public int doorId;                                  //門編號
    public Vector3 fromPosition;                        //門初始位置
    public Vector3 toPosition;                          //門打開位置
    public float fadeSpeed = 5f;                        //門打開和關閉的速度
    public bool requiredKey = false;                    //門打開是否需要鑰匙
    public AudioClip doorSwitchClip;                    //門開關時的音效
    public AudioClip accessDeniedClip;                  //門拒絕打開時的音效

    private Transform door;                             //門
    private GameObject player;                          //玩家
    private AudioSource audioSources;                   //音頻源
    private FPS_PlayerInventory playerInventory;        //
    private int count;                                  //門附近人物個數

    /// <summary>
    /// 門附近人物個數屬性
    /// </summary>
    public int Count
    {
        get
        {
            return count;
        }
        set
        {
            //如果門附近有人物靠近或離開時
            if (count == 0 && value == 1 || count == 1 && value == 0) 
            {
                //播放門開關的音效
                audioSources.clip = doorSwitchClip;
                audioSources.Play();
            }
            count = value;
        }
    }

    /// <summary>
    /// 初始化
    /// </summary>
    private void Start()
    {
        if (transform.childCount > 0)
        {
            door = transform.GetChild(0);
        }
        player = GameObject.FindGameObjectWithTag(Tags.player);
        playerInventory = player.GetComponent<FPS_PlayerInventory>();
        audioSources = this.GetComponent<AudioSource>();
        door.localPosition = fromPosition;
    }

    private void Update()
    {
        if (Count > 0)
        {
            door.localPosition = Vector3.Lerp(door.localPosition, toPosition, fadeSpeed * Time.deltaTime);
        }
        else
        {
            door.localPosition = Vector3.Lerp(door.localPosition, fromPosition, fadeSpeed * Time.deltaTime);
        }
    }

    private void OnTriggerEnter(Collider other)
    {
        if (other.gameObject == player)
        {
            if (requiredKey)
            {
                if (playerInventory.HasKey(doorId))
                {
                    Count++;
                }
                else
                {
                    audioSources.clip = accessDeniedClip;
                    audioSources.Play();
                }
            }
            else
            {
                Count++;
            }
        }
        else if (other.gameObject.tag == Tags.enemy && other is CapsuleCollider)
            Count++;
    }


    private void OnTriggerExit(Collider other)
    {
        if(other.gameObject == player||(other.gameObject.tag == Tags.enemy && other is CapsuleCollider))
        {
            Count = Mathf.Max(0, Count - 1);
        }
    }
}

FPS_EnemyAI.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.AI;

public class FPS_EnemyAI : MonoBehaviour
{
    public float patrolSpeed = 2f;                           //巡邏速度
    public float chaseSpeed = 5f;                            //追逐速度
    public float chaseWaitTime = 5f;                         //追逐等待時間
    public float patrolWaitTime = 1f;                        //巡邏等待時間
    public Transform[] patrolWayPoint;                       //巡邏航路點

    private FPS_EnemySight enemySight;
    private NavMeshAgent navMeshAgent;
    private Transform player;
    private FPS_PlayerHealth playerHealth;
    private float chaseTimer;                                //追逐計時器
    private float patrolTimer;                               //巡邏計時器
    private int wayPointIndex = 0;                           //航路點索引

    private void Start()
    {
        enemySight = this.GetComponent<FPS_EnemySight>();
        navMeshAgent = this.GetComponent<NavMeshAgent>();
        player = GameObject.FindGameObjectWithTag(Tags.player).transform;
        playerHealth = player.GetComponent<FPS_PlayerHealth>();

    }

    private void Update()
    {
        if (enemySight.playerInSight && playerHealth.currentHp > 0)
        {
            Shooting();
        }
        else if (enemySight.playerPosition != enemySight.resetPosition && playerHealth.currentHp > 0)
        {
            Chasing();
        }
        else
        {
            patrolling();
        }
    }

    /// <summary>
    /// 射擊時不再移動
    /// </summary>
    private void Shooting()
    {            
       navMeshAgent.SetDestination(transform.position);    
    }

    /// <summary>
    /// 追擊玩家
    /// </summary>
    private void Chasing()
    {
        Vector3 sightingDeltaPos = enemySight.playerPosition - transform.position;
        if (sightingDeltaPos.sqrMagnitude > 4f) 
        {
            navMeshAgent.destination = enemySight.playerPosition;
            navMeshAgent.speed = chaseSpeed;
        }

        if (navMeshAgent.remainingDistance < navMeshAgent.stoppingDistance) 
        {
            chaseTimer += Time.deltaTime;
            if(chaseTimer> chaseWaitTime)
            {
                enemySight.playerPosition = enemySight.resetPosition;
                chaseTimer = 0;
            }
        }
        else
        {
            chaseTimer = 0;
        }
    }

    /// <summary>
    /// 巡邏狀態
    /// </summary>
    private void patrolling()
    {
        navMeshAgent.speed = patrolSpeed;
        if (navMeshAgent.destination == enemySight.resetPosition || navMeshAgent.remainingDistance < navMeshAgent.stoppingDistance)
        {
            patrolTimer += Time.deltaTime;
            if (patrolTimer >= patrolWaitTime)
            {
                if (wayPointIndex == patrolWayPoint.Length - 1)
                {
                    wayPointIndex = 0;
                }
                else
                {
                    wayPointIndex++;
                    
                }
            }
        }
        else
        {
            patrolTimer = 0;
        }
        navMeshAgent.destination = patrolWayPoint[wayPointIndex].position;
    }
}

FPS_EnemyAnimation.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.AI;

public class FPS_EnemyAnimation : MonoBehaviour
{
    public float deadZone = 5f;                     //空白區域

    private Transform player;
    private FPS_EnemySight enemySight;
    private NavMeshAgent navMeshAgent;
    private Animator animator;
    private HashIDs hashIDs;
    private AnimatorSetup animatorSetup;

    /// <summary>
    /// 初始化
    /// </summary>
    private void Start()
    {
        player = GameObject.FindGameObjectWithTag(Tags.player).transform;
        enemySight = this.GetComponent<FPS_EnemySight>();
        navMeshAgent = this.GetComponent<NavMeshAgent>();
        animator = this.GetComponent<Animator>();
        hashIDs = GameObject.FindGameObjectWithTag(Tags.gameController).GetComponent<HashIDs>();
        animatorSetup = new AnimatorSetup(animator, hashIDs);

        //將尋路代理的更新旋轉禁用
        navMeshAgent.updateRotation = false;
        //設定影片層級的權重
        animator.SetLayerWeight(1, 1f);
        animator.SetLayerWeight(2, 1f);
        //將角度轉換成弧度
        deadZone *= Mathf.Deg2Rad;
    }

    private void Update()
    {
        NavAnimSetup();
    }

    private void OnAnimatorMove()
    {
        //設定尋路代理的速度
        navMeshAgent.velocity = animator.deltaPosition / Time.deltaTime;
        //通過影片的旋轉來控制敵人AI的旋轉
        transform.rotation = animator.rootRotation;
    }


    private void NavAnimSetup()
    {
        float speed;
        float angle;
        //如果玩家在敵人視野內
        if (enemySight.playerInSight)
        {
            speed = 0;
            angle = FindAngle(transform.forward, player.transform.position - transform.position, transform.up);
        }
        else
        {
            speed = Vector3.Project(navMeshAgent.desiredVelocity, transform.forward).magnitude;
            angle = FindAngle(transform.forward, navMeshAgent.desiredVelocity, transform.up);
            if (Mathf.Abs(angle) < deadZone)
            {
                transform.LookAt(transform.position + navMeshAgent.desiredVelocity);
                angle = 0;
            }
        }
        animatorSetup.Setup(speed, angle);
    }

    /// <summary>
    /// 尋找玩家的角度
    /// </summary>
    /// <param name="fromVector"></param>
    /// <param name="toVector"></param>
    /// <param name="upVector"></param>
    /// <returns></returns>
    private float FindAngle(Vector3 fromVector, Vector3 toVector, Vector3 upVector)
    {
        if (toVector == Vector3.zero)
            return 0;
        //角度
        float angle = Vector3.Angle(fromVector, toVector);
        //法向量
        //兩個向量的叉積，兩個向量的叉積生成第三個向量， 該向量垂直于兩個輸入向量，結果的大小等于： 將兩個輸入的大小相乘，然后乘以輸入之間角度的正弦值， 可以使用“左手規則”確定結果向量的方向，
        Vector3 normal = Vector3.Cross(fromVector, toVector);
        //Mathf.Sign:當 f 為正數或零時，回傳值為 1，當 f 為負數時，回傳值為 -1，
        //Vector3.Dot:兩個向量的點積，點積是一個浮點值，它等于 將兩個向量的大小相乘，然后乘以向量之間角度的余弦值，
        //帶有方向的角度
        angle *= Mathf.Sign(Vector3.Dot(normal, upVector));
        //將角度轉為弧度
        angle *= Mathf.Deg2Rad;
        return angle;
    }
}

FPS_EnemyHealth.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.AI;

public class FPS_EnemyHealth : MonoBehaviour
{
    public float hp = 100;

    private Animator animator;
    private HashIDs hashIDs;
    private bool isDead = false;

    private void Start()
    {
        animator = this.GetComponent<Animator>();
        hashIDs = GameObject.FindGameObjectWithTag(Tags.gameController).GetComponent<HashIDs>();
    }

    /// <summary>
    /// 收到傷害
    /// </summary>
    public void TakeDamage(float damage)
    {
        hp -= damage;
        if (hp < 0 && isDead == false)
        {
            isDead = true;
            this.GetComponent<CapsuleCollider>().enabled = false;
            this.GetComponent<NavMeshAgent>().enabled = false;
            this.GetComponent<FPS_EnemySight>().enabled = false;
            this.GetComponent<FPS_EnemyAnimation>().enabled = false;
            this.GetComponent<FPS_EnemyAI>().enabled = false;
            this.GetComponent<FPS_EnemyShoot>().enabled = false;
            this.GetComponentInChildren<Light>().enabled = false;
            this.GetComponentInChildren<LineRenderer>().enabled = false;

            animator.SetBool(hashIDs.playerInSightBool, false);
            animator.SetBool(hashIDs.deadBool, true);
        }
    }
}

FPS_EnemyShoot.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class FPS_EnemyShoot : MonoBehaviour
{
    public float maxDamage = 60;                       //最大傷害
    public float minDamage = 30;                       //最小傷害
    public AudioClip shotClip;                         //射擊音頻
    public float flashIntensity = 3f;                  //閃光強度
    public float fadeSpeed = 10f;                      //漸變速度
                                                       
    private Animator animator;                         //
    private HashIDs hashIDs;                           //
    private LineRenderer laserShotLine;                //激光射線
    private Light laserShotLight;                      //激光發射光
    private SphereCollider collider;                   //
    private Transform player;                          //
    private FPS_PlayerHealth playerHealth;             //
    private bool shooting;                             //是否正在射擊
    private float scaledDamage;                        //傷害的取值范圍


    private void Start()
    {
        animator = this.GetComponent<Animator>();
        hashIDs = GameObject.FindGameObjectWithTag(Tags.gameController).GetComponent<HashIDs>();
        laserShotLine = this.GetComponentInChildren<LineRenderer>();
        laserShotLight = laserShotLine.gameObject.GetComponent<Light>();
        collider = this.GetComponentInChildren<SphereCollider>();
        player = GameObject.FindGameObjectWithTag(Tags.player).transform;
        playerHealth = player.GetComponent<FPS_PlayerHealth>();
        laserShotLine.enabled = false;
        //光照強度設定為0
        laserShotLight.intensity = 0f;
        shooting = false;
        scaledDamage = maxDamage - minDamage;
    }


    private void Update()
    {
        float shot = animator.GetFloat(hashIDs.shotFloat);
        if (shot > 0.05f && shooting == false)
        {
            Shoot();
        }
        if (shot < 0.05)
        {
            shooting = false;
            laserShotLine.enabled = false;
        }
        laserShotLight.intensity = Mathf.Lerp(laserShotLight.intensity, 0f, fadeSpeed * Time.deltaTime);
    }

    private void OnAnimatorIK(int layerIndex)
    {
        float aimWeight = animator.GetFloat(hashIDs.aimWidthFloat);
        animator.SetIKPosition(AvatarIKGoal.RightHand, player.position + Vector3.up * 1.5f);
        animator.SetIKPositionWeight(AvatarIKGoal.RightHand, aimWeight);
    }

    /// <summary>
    /// 射擊
    /// </summary>
    private void Shoot()
    {
        shooting = true;
        //距離百分比
        float fractionalDistance = (collider.radius - Vector3.Distance(transform.position, player.position)) / collider.radius;
        //當前傷害值
        float damage = scaledDamage * fractionalDistance + minDamage;
        playerHealth.TakeDamage(damage);
        ShootEffects();
    }

    /// <summary>
    /// 射擊特效
    /// </summary>
    private void ShootEffects()
    {
        laserShotLine.SetPosition(0, laserShotLine.transform.position);
        laserShotLine.SetPosition(1, player.position + Vector3.up * 1.5f);
        laserShotLine.enabled = true;
        laserShotLight.intensity = flashIntensity;
        AudioSource.PlayClipAtPoint(shotClip, laserShotLine.transform.position);
    }
}

FPS_EnemySight.cs

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.AI;

public class FPS_EnemySight : MonoBehaviour
{
    public float fieldOfViewAngle = 110f;                           //敵人視場角度
    public bool playerInSight;                                      //玩家是否在視線中
    public Vector3 playerPosition;                                  //玩家位置
    public Vector3 resetPosition = Vector3.zero;                    //初始位置

    private NavMeshAgent nav;                                       //
    private SphereCollider listenRange;                             //
    private Animator anim;                                          //
    private GameObject player;                                      //
    private FPS_PlayerHealth playerHealth;                          //
    private HashIDs hashIDs;                                        //
    private FPS_PlayerContorller playerContorller;                  //

    /// <summary>
    /// 初始化
    /// </summary>
    private void Start()
    {
        nav = this.GetComponent<NavMeshAgent>();
        listenRange = this.GetComponentInChildren<SphereCollider>();
        anim = this.GetComponent<Animator>();
        player = GameObject.FindGameObjectWithTag(Tags.player);
        playerHealth = player.GetComponent<FPS_PlayerHealth>();
        hashIDs = GameObject.FindGameObjectWithTag(Tags.gameController).GetComponent<HashIDs>();
        playerContorller = player.GetComponent<FPS_PlayerContorller>();
        FPS_GunScript.PlayerShootEvent += ListenPlayer;
    }

    private void Update()
    {
        if (playerHealth.currentHp > 0)
        {
            anim.SetBool(hashIDs.playerInSightBool, playerInSight);
        }
        else
        {
            anim.SetBool(hashIDs.playerInSightBool, false);
        }
    }

    private void OnTriggerStay(Collider other)
    {
        if(other.gameObject == player)
        {
            playerInSight = false;
            //敵人指向玩家的方向
            Vector3 direction = other.transform.position - transform.position;
            //敵人視角的角度
            float angele = Vector3.Angle(direction, transform.forward);
            //如果玩家與敵人之間的夾角小于敵人視角的一半
            if (angele < fieldOfViewAngle * 0.5)
            {
                RaycastHit raycastHit; 
                //定義射線的引數
                if (Physics.Raycast(transform.position + transform.up, direction.normalized, out raycastHit, listenRange.radius))
                {
                    //如果射線射到的碰撞體為玩家
                    if(raycastHit.collider.gameObject == player)
                    {
                        playerInSight = true;
                        playerPosition = player.transform.position;
                    }
                }
            }
            //當玩家有腳步聲時，偵聽玩家位置
            if (playerContorller.State == PlayerState.Walk || playerContorller.State == PlayerState.Run) 
            {
                ListenPlayer();
            }
        }
    }

    private void OnTriggerExit(Collider other)
    {
        playerInSight = false;
    }

    /// <summary>
    /// 偵聽玩家的位置
    /// </summary>
    private void ListenPlayer()
    {
        //如果玩家與敵人之間的距離小于偵聽檢測器的半徑時
        if (Vector3.Distance(player.transform.position, transform.position) <= listenRange.radius) 
        {
            playerPosition = player.transform.position;
        }
    }


    private void OnDestroy()
    {
        FPS_GunScript.PlayerShootEvent -= ListenPlayer;
    }
}

FPS_Exit.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

public class FPS_Exit : MonoBehaviour
{
    public float timeToInactivePlayer = 1f;      //玩家在出口處停留時間
    public float timeToResatrt = 3f;             //游戲重新開始時間
    public Text victoryText;                     //通過完成文本

    private GameObject player;                   //玩家
    private bool playerInExit;                   //是否進入出口
    private float timer;                         //計時器
    private FadeInOut fader;                     //
    

    private void Start()
    {
        player = GameObject.FindGameObjectWithTag(Tags.player);
        fader = GameObject.FindGameObjectWithTag(Tags.fader).GetComponent<FadeInOut>();
        playerInExit = false;
        victoryText.gameObject.SetActive(false);
    }

    private void Update()
    {
        if (playerInExit)
        {
            InExitActivation();
        }
    }

    private void OnTriggerEnter(Collider other)
    {
        if(other.gameObject == player)
        {
            playerInExit = true;
        }
    }

    private void OnTriggerExit(Collider other)
    {
        if(other.gameObject == player)
        {
            playerInExit = false;
            timer = 0;
        }
    }

    /// <summary>
    /// 進入出口激活
    /// </summary>
    private void InExitActivation() 
    {
        timer += Time.deltaTime;
        if(timer >= timeToInactivePlayer)
        {
            player.GetComponent<FPS_PlayerHealth>().DisableInput();
            victoryText.gameObject.SetActive(true);
            victoryText.text = "通關成功";            
        }
        if(timer >= timeToResatrt)
        {
            fader.EndScene();
            victoryText.enabled = false;
            victoryText.gameObject.SetActive(false);
        }
    }
}

FPS_GunScript.cs

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

//定義委托
public delegate void PlayerShoot();

public class FPS_GunScript : MonoBehaviour
{
    public static event PlayerShoot PlayerShootEvent;       //玩家射擊事件
    public float FireRate = 0.12f;                          //射擊速度
    public float damage = 20;                               //傷害值
    public float reloadTime = 1.5f;                         //裝彈時間
    public float flashRate = 0.02f;                         //開火特效時間
    public AudioClip fireAudio;                             //開火音效
    public AudioClip relaodAudio;                           //裝彈音效
    public AudioClip damageAudio;                           //收到傷害音效
    public AudioClip dryFireAudio;                          //空彈射擊音效
    public GameObject explosion;                            //爆炸特效
    public int bulletCount = 30;                            //彈夾中子彈數量
    public int chargerBulletCount = 180;                    //可裝填子彈數量
    public Text bullentText;                                //子彈數量文本

    public string reloadAnim = "Reload";                    //裝彈
    public string idleAnim = "Idle";                        //站立
    public string walkAnim = "Walk";                        //行走
    public string runAnim = "Run";                          //奔跑
    public string jumpAnim = "Jump";                        //跳躍
    public string fireAnim = "Single_Shot";                 //單發

    private Animation anim;                                 //影片
    private float nextFireTime;                             //下一次射擊時間
    private MeshRenderer flash;                             //
    private int currentBulletCount;                         //當前彈夾中子彈數量
    private int currentChargerBulletCount;                  //當前可裝填子彈數量
    private FPS_PlayerParameters parameters;                //
    private FPS_PlayerContorller playerContorller;          //
    

    /// <summary>
    /// 初始化
    /// </summary>
    private void Start()
    {
        parameters = GameObject.FindGameObjectWithTag(Tags.player).GetComponent<FPS_PlayerParameters>();
        playerContorller = GameObject.FindGameObjectWithTag(Tags.player).GetComponent<FPS_PlayerContorller>();
        anim = this.GetComponent<Animation>();
        flash = this.transform.Find("muzzle_flash").GetComponent<MeshRenderer>();
        flash.enabled = false;
        currentBulletCount = bulletCount;
        currentChargerBulletCount = chargerBulletCount;
        bullentText.text = currentBulletCount + "/" + currentChargerBulletCount;
    }

    private void Update()
    {
        if (parameters.isInputReload)
        {
            Reload();
        }
        if (parameters.isInputFire && !anim.IsPlaying(reloadAnim))
        {
            Fire();
        }
        else if (!anim.IsPlaying(reloadAnim))
        {
            StateAnim(playerContorller.State);
        }
    }

    /// <summary>
    /// 裝彈影片
    /// </summary>
    private void ReloadAnimation()
    {
        anim.Stop(reloadAnim);
        anim[reloadAnim].speed = anim[reloadAnim].clip.length / reloadTime;
        anim.Rewind(reloadAnim);
        anim.Play(reloadAnim);
    }

    /// <summary>
    /// 裝填完成計算子彈數目協程
    /// </summary>
    /// <returns></returns>
    private IEnumerator ReloadFinish()
    {
        yield return new WaitForSeconds(reloadTime);
        if (currentChargerBulletCount > bulletCount - currentBulletCount)
        {
            currentChargerBulletCount -= bulletCount - currentBulletCount;
            currentBulletCount = bulletCount;
        }
        else
        {
            currentBulletCount += currentChargerBulletCount;
            currentChargerBulletCount = 0;
        }
        bullentText.text = currentBulletCount + "/" + currentChargerBulletCount;
    }

    /// <summary>
    /// 裝彈
    /// </summary>
    private void Reload()
    {
        if (!anim.IsPlaying(reloadAnim))
        {
            if (currentChargerBulletCount > 0)
            {
                StartCoroutine(ReloadFinish());
                ReloadAnimation();
                AudioSource.PlayClipAtPoint(relaodAudio, transform.position);
            }
            else
            {
                anim.Rewind(fireAnim);
                anim.Play(fireAnim);
                AudioSource.PlayClipAtPoint(dryFireAudio, transform.position);
            }
        }
    }

    /// <summary>
    /// 開火特效協程
    /// </summary>
    /// <returns></returns>
    private IEnumerator Flash()
    {
        flash.enabled = true;
        yield return new WaitForSeconds(flashRate);
        flash.enabled = false;
    }

    /// <summary>
    /// 開火
    /// </summary>
    private void Fire()
    {
        if (Time.time > nextFireTime)
        {
            if (currentBulletCount <= 0)
            {
                Reload();
                nextFireTime = Time.time + reloadTime;
                return;
            }
            nextFireTime = Time.time + FireRate;
            currentBulletCount--;
            bullentText.text = currentBulletCount + "/" + currentChargerBulletCount;
            anim.Rewind(fireAnim);
            anim.Play(fireAnim);
            StartCoroutine(Flash());
            AudioSource.PlayClipAtPoint(fireAudio, transform.position);
            DamageEmeny();
            if (PlayerShootEvent != null)
            {
                PlayerShootEvent();
            }

        }
    }

    /// <summary>
    /// 傷害敵人
    /// </summary>
    private void DamageEmeny()
    {
        Ray ray = Camera.main.ScreenPointToRay(new Vector3(Screen.width / 2, Screen.height / 2, 0));

        RaycastHit hit;
        if (Physics.Raycast(ray, out hit))
        {
            if (hit.transform.tag == Tags.enemy && hit.collider is CapsuleCollider) 
            {
                AudioSource.PlayClipAtPoint(damageAudio, transform.position);
                GameObject go = Instantiate(explosion, hit.point, Quaternion.identity);
                Destroy(go, 3);
                hit.transform.GetComponent<FPS_EnemyHealth>().TakeDamage(damage);
            }
        }
    }

    /// <summary>
    /// 播放玩家影片狀態
    /// </summary>
    /// <param name="animName"></param>
    private void PlayStateAnim(string animName)
    {
        if (!anim.IsPlaying(animName))
        {
            anim.Rewind(animName);
            anim.Play(animName);
        }
    }

    /// <summary>
    /// 根據玩家動作切換影片
    /// </summary>
    /// <param name="playerState"></param>
    private void StateAnim(PlayerState State)
    {
        switch (State)
        {
            case PlayerState.Idle:
                PlayStateAnim(idleAnim);
                break;
            case PlayerState.Walk:
                PlayStateAnim(walkAnim);
                break;
            case PlayerState.Crouch:
                break;
            case PlayerState.Run:
                PlayStateAnim(runAnim);
                break;
        }
        
    }
}

FPS_Input.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// 用戶輸入
/// </summary>
public class FPS_Input : MonoBehaviour
{
    /// <summary>
    /// 自定義軸
    /// </summary>
    public class FPS_InputAxis
    {
        public KeyCode positive;    //正向軸
        public KeyCode negative;    //負向軸
    }
    //按鍵字典初始化
    public Dictionary<string, KeyCode> buttons = new Dictionary<string, KeyCode>();
    //自定義軸字典初始化
    public Dictionary<string, FPS_InputAxis> axises = new Dictionary<string, FPS_InputAxis>();
    //unity自帶軸集合初始化
    public List<string> unityAxises = new List<string>();

    private void Start()
    {
        SetupDefaults();
    }

    /// <summary>
    /// 初始化按鍵、自定義軸、unity自帶軸
    /// 根據型別設定默認按鍵
    /// </summary>
    /// <param name="type"></param>
    private void SetupDefaults(string type = "")
    {
        //如果型別是空字串或者型別是按鍵
        if(type == ""||type == "Button")
        {
            //如果還沒有添加任何一個按鍵
            if (buttons.Count == 0)
            {
                AddButton("Fire", KeyCode.Mouse0);              //開火，滑鼠左鍵
                AddButton("Reload", KeyCode.R);                 //換彈，鍵盤R鍵
                AddButton("Jump", KeyCode.Space);               //跳躍，鍵盤空格鍵
                AddButton("Crouch", KeyCode.C);                 //蹲伏，鍵盤C鍵
                AddButton("Sprint", KeyCode.LeftShift);         //沖刺，鍵盤左Shift

            }
        }
        //如果型別是空字串或者型別是自定義軸
        if (type == "" || type == "Axis")
        {
            //如果還沒有添加任何一個自定義軸
            if (axises.Count == 0)
            {
                AddAxis("Horizontal", KeyCode.W, KeyCode.S);    //水平軸，鍵盤W，S鍵
                AddAxis("Vertical", KeyCode.A, KeyCode.D);      //豎直軸，鍵盤A，D鍵
            }
        }
        //如果型別是空字串或者型別是unity自帶軸
        if (type == "" || type == "UnityAxis")
        {
            //如果還沒有添加任何一個unity自帶軸
            if (unityAxises.Count == 0)
            {
                AddUnityAxis("Mouse X");
                AddUnityAxis("Mouse Y");
                AddUnityAxis("Horizontal");
                AddUnityAxis("Vertical");
            }
        }
    }

    /// <summary>
    /// 添加按鍵
    /// </summary>
    /// <param name="n"></param>
    /// <param name="k"></param>
    private void AddButton(string n, KeyCode k)
    {
        if (buttons.ContainsKey(n))
        {
            buttons[n] = k;
        }
        else
        {
            buttons.Add(n, k);
        }
    }

    /// <summary>
    /// 添加自定義軸
    /// </summary>
    /// <param name="n"></param>
    /// <param name="pk"></param>
    /// <param name="nk"></param>
    private void AddAxis(string n, KeyCode pk, KeyCode nk)
    {
        if (axises.ContainsKey(n))
        {
            axises[n] = new FPS_InputAxis { positive = pk, negative = nk };
        }
        else
        {
            axises.Add(n, new FPS_InputAxis { positive = pk, negative = nk });
        }
    }

    /// <summary>
    /// 添加unity自帶軸
    /// </summary>
    /// <param name="n"></param>
    private void AddUnityAxis(string n)
    {
        if (!unityAxises.Contains(n))
        {
            unityAxises.Add(n);
        }
    }

    /// <summary>
    /// 獲取按鍵的按下
    /// </summary>
    /// <param name="button"></param>
    /// <returns></returns>
    public bool GetButton(string button)
    {
        if (buttons.ContainsKey(button))
        {
            return Input.GetKey(buttons[button]);
        }
        return false;
    }

    /// <summary>
    /// 獲取按鍵開始按下的幀
    /// </summary>
    /// <param name="button"></param>
    /// <returns></returns>
    public bool GetButtonDown(string button)
    {
        if (buttons.ContainsKey(button))
        {
            return Input.GetKeyDown(buttons[button]);
        }
        return false;
    }

    /// <summary>
    /// 獲取軸的輸入，[-1,1]之間的float型別
    /// </summary>
    /// <param name="axis"></param>
    /// <returns></returns>
    public float GetAxis(string axis)
    {
        if (axises.ContainsKey(axis))
        {
            return Input.GetAxis(axis);
        }
        else if (unityAxises.Contains(axis))
        {
            return Input.GetAxis(axis);
        }
        else
            return 0;
    }

    /// <summary>
    /// 獲取軸的輸入，回傳-1，0，1中的一個值
    /// </summary>
    /// <param name="axis"></param>
    /// <returns></returns>
    public float GetAxisRaw(string axis)
    {
        if (axises.ContainsKey(axis))
        {
            float val = 0;
            if (Input.GetKey(axises[axis].positive))
            {
                val = 1;
            }
            if (Input.GetKey(axises[axis].negative))
            {
                val = -1;
            }
            return val;
        }
        else if (unityAxises.Contains(axis))
        {
            return Input.GetAxisRaw(axis);
        }
        else
        {
            return 0;
        }
    }
}

FPS_KeyPickUp.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class FPS_KeyPickUp : MonoBehaviour
{
    public AudioClip keyClip;                               //鑰匙音效
    public int keyId;                                       //鑰匙編號
                                                            
    private GameObject player;                              //玩家
    private FPS_PlayerInventory playerInventory;            //背包


    private void Start()
    {
        player = GameObject.FindGameObjectWithTag(Tags.player);
        playerInventory = player.GetComponent<FPS_PlayerInventory>();
    }

    private void OnTriggerEnter(Collider other)
    {
        if(other.gameObject == player)
        {
            AudioSource.PlayClipAtPoint(keyClip, transform.position);
            playerInventory.AddKey(keyId);
            Destroy(this.gameObject);
        }
    }
}

FPS_LaserDamage.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class FPS_LaserDamage : MonoBehaviour
{
    public int damage = 20;                        //傷害值
    public float damageDelay = 1;                  //傷害延遲時間
                                                   
    private float lastDamageTime = 0;              //上一次收到傷害的時間
    private GameObject player;                     //玩家

    private void Start()
    {
        player = GameObject.FindGameObjectWithTag(Tags.player);
    }

    private void OnTriggerStay(Collider other)
    {
        if(other.gameObject == player && Time.time > lastDamageTime + damageDelay)
        {
            player.GetComponent<FPS_PlayerHealth>().TakeDamage(damage);
            lastDamageTime = Time.time;
        }
    }
}

FPS_PlayerContorller.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public enum PlayerState
{
    None,                   //初始狀態
    Idle,                   //站立
    Walk,                   //行走
    Crouch,                 //蹲伏
    Run                     //奔跑
}

public class FPS_PlayerContorller : MonoBehaviour
{
    private PlayerState state = PlayerState.None;

    /// <summary>
    /// 人物狀態設定
    /// </summary>
    public PlayerState State
    {
        get
        {
            if (runing)
            {
                state = PlayerState.Run;
            }
            else if (walking)
            {
                state = PlayerState.Walk;
            }
            else if (crouching)
            {
                state = PlayerState.Crouch;
            }
            else
            {
                state = PlayerState.Idle;
            }
            return state;
        }
    }

    public float sprintSpeed = 10f;                         //沖刺速度
    public float sprintJumpSpeed = 8f;                      //沖刺跳躍速度
    public float normalSpeed = 6f;                          //正常速度
    public float normalJumpSpeed = 7f;                      //正常跳躍速度
    public float crouchSpeed = 2f;                          //蹲伏速度
    public float crouchJumpSpeed = 6f;                      //蹲伏跳躍速度
    public float crouchDeltaHeight = 0.5f;                  //蹲伏下降高度
    public float gravity = 20f;                             //重力
    public float cameraMoveSpeed = 8f;                      //相機跟隨速度
    public AudioClip jumpAudio;                             //跳躍音效

    public float currentSpeed;                              //當前速度
    public float currentJumnSpeed;                          //當前跳躍速度

    private Transform mainCamera;                           //主攝像物件
    private float standardCamHeight;                        //相機標準高度
    private float crouchingCamHeight;                       //蹲伏時相機高度
    private bool grounded = false;                          //是否在地面上
    private bool walking = false;                           //是否在行走
    private bool crouching = false;                         //是否在蹲伏
    private bool stopCrouching = false;                     //是否停止蹲伏
    private bool runing = false;                            //是否在奔跑
    private Vector3 normalControllerCenter = Vector3.zero;  //角色控制器中心
    private float normalControllerHeight = 0f;              //角色控制器高度
    private float timer = 0;                                //計時器
    private CharacterController characterController;        //角色控制器組件
    private AudioSource audioSource;                        //音頻源組件
    private FPS_PlayerParameters parameters;                //FPS_Parameters組件
    private Vector3 moveDirection = Vector3.zero;           //移動方向

    /// <summary>
    /// 初始化
    /// </summary>
    private void Start()
    {
        crouching = false;
        walking = false;
        runing = false;
        currentSpeed = normalSpeed;
        currentJumnSpeed = normalJumpSpeed;
        mainCamera = GameObject.FindGameObjectWithTag(Tags.mainCamera).transform;
        standardCamHeight = mainCamera.position.y;
        crouchingCamHeight = standardCamHeight - crouchDeltaHeight;
        audioSource = this.GetComponent<AudioSource>();
        characterController = this.GetComponent<CharacterController>();
        parameters = this.GetComponent<FPS_PlayerParameters>();
        normalControllerCenter = characterController.center;
        normalControllerHeight = characterController.height;
    }

    private void FixedUpdate()
    {
        MoveUpdate();
        AudioManager();
    }

    /// <summary>
    /// 任務移動控制更新
    /// </summary>
    private void MoveUpdate()
    {
        //如果在地面上
        if (grounded)
        {
            //自身坐標軸的y軸對應世界坐標軸的z軸
            moveDirection = new Vector3(parameters.inputMoveVector.x, 0, parameters.inputMoveVector.y);
            //將 direction 從本地空間變換到世界空間
            moveDirection = transform.TransformDirection(moveDirection);
            moveDirection *= currentSpeed;
            //如果玩家輸入跳躍
            if (parameters.isInputJump)
            {
                //獲取跳躍速度
                CurrentSpeed();
                moveDirection.y = currentJumnSpeed;
                //播放跳躍音頻
                AudioSource.PlayClipAtPoint(jumpAudio, transform.position);
            }
        }
        //受重力下落
        moveDirection.y -= gravity * Time.deltaTime;
        //CollisionFlags 是 CharacterController.Move 回傳的位掩碼，
        //其概述您的角色與其他任何物件的碰撞位置，
        CollisionFlags flags = characterController.Move(moveDirection * Time.deltaTime);
        /*
        CollisionFlags.CollidedBelow   底部發生了碰撞"flags & CollisionFlags.CollidedBelow"回傳1;
        CollisionFlags.CollidedNone    沒發生碰撞"flags & CollisonFlags.CollidedNone"回傳1;
        CollisionFlags.CollidedSides   四周發生碰撞"flags & CollisionFlags.CollidedSides"回傳1;
        CollisionFlags.CollidedAbove   頂端發生了碰撞"flags & CollisionFlags.CollidedAbove"回傳1;        
        */
        //表示在地面上，grounded為true
        grounded = (flags & CollisionFlags.CollidedBelow) != 0;
        //如果在地面上且有移動的輸入
        if (Mathf.Abs(moveDirection.x) > 0 && grounded || Mathf.Abs(moveDirection.z) > 0 && grounded) 
        {
            if (parameters.isInputSprint)
            {
                walking = false;
                crouching = false;
                runing = true;
            }
            else if (parameters.isInputCrouch)
            {
                walking = false;
                crouching = true;
                runing = false;
            }
            else
            {
                walking = true;
                crouching = false;
                runing = false;
            }
        }
        else
        {
            if (walking)
            {
                walking = false;
            }
            if (runing)
            {
                runing = false;
            }
            if (parameters.isInputCrouch)
            {
                crouching = true;
            }
            else
            {
                crouching = false;
            }
        }
        //蹲伏狀態下的角色控制器中心與高度
        if (crouching)
        {
            characterController.height = normalControllerHeight - crouchDeltaHeight;
            characterController.center = normalControllerCenter - new Vector3(0, crouchDeltaHeight / 2, 0);
        }
        else
        {
            characterController.height = normalControllerHeight;
            characterController.center = normalControllerCenter;
        }
        CurrentSpeed();
        CrouchUpdate();
    }

    /// <summary>
    /// 根據人物的狀態對其速度進行定義
    /// </summary>
    private void CurrentSpeed()
    {
        switch (State)
        {
            case PlayerState.Idle:
                currentSpeed = normalSpeed;
                currentJumnSpeed = normalJumpSpeed;
                break;
            case PlayerState.Walk:
                currentSpeed = normalSpeed;
                currentJumnSpeed = normalJumpSpeed;
                break;
            case PlayerState.Crouch:
                currentSpeed = crouchSpeed;
                currentJumnSpeed = crouchJumpSpeed;
                break;
            case PlayerState.Run:
                currentSpeed = sprintSpeed;
                currentJumnSpeed = sprintJumpSpeed;
                break;
        }
    }

    /// <summary>
    /// 根據人物狀態對其腳步聲進行定義
    /// </summary>
    private void AudioManager()
    {
        if(State == PlayerState.Walk)
        {
            //設定音頻源的音高，行走時緩慢
            audioSource.pitch = 0.8f;
            if (!audioSource.isPlaying)
            {
                audioSource.Play();
            }
        }
        else if(State == PlayerState.Run)
        {
            //設定音頻源的音高，奔跑時急促
            audioSource.pitch = 1.3f;
            if (!audioSource.isPlaying)
            {
                audioSource.Play();
            }
        }
        else
        {
            audioSource.Stop();
        }
    }

    /// <summary>
    /// 蹲伏下降與蹲伏上升時相機位置更新
    /// </summary>
    private void CrouchUpdate()
    {
        if (crouching)
        {
            if (mainCamera.localPosition.y > crouchingCamHeight)
            {
                if(mainCamera.localPosition.y-(crouchDeltaHeight * Time.deltaTime * cameraMoveSpeed)< crouchingCamHeight)
                {
                    mainCamera.localPosition = new Vector3(mainCamera.localPosition.x, crouchingCamHeight, mainCamera.localPosition.z); 
                }
                else
                {
                    mainCamera.localPosition -= new Vector3(0, crouchDeltaHeight * Time.deltaTime * cameraMoveSpeed, 0);
                }
            }
            else
            {
                mainCamera.localPosition = new Vector3(mainCamera.localPosition.x, crouchingCamHeight, mainCamera.localPosition.z);
            }
        }
        else
        {
            if (mainCamera.localPosition.y < standardCamHeight)
            {
                if(mainCamera.localPosition.y + (crouchDeltaHeight * Time.deltaTime * cameraMoveSpeed) > standardCamHeight)
                {
                    mainCamera.localPosition = new Vector3(mainCamera.localPosition.x, standardCamHeight, mainCamera.localPosition.z);
                }
                else
                {
                    mainCamera.localPosition += new Vector3(0, crouchDeltaHeight * Time.deltaTime * cameraMoveSpeed, 0);
                }
            }
            else
            {
                mainCamera.localPosition = new Vector3(mainCamera.localPosition.x, standardCamHeight, mainCamera.localPosition.z);
            }
        }
    }
}

FPS_PlayerHealth.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

public class FPS_PlayerHealth : MonoBehaviour
{
    public bool isDead;                         //是否死亡
    public float resetAfterDeathTime = 5;       //死亡后重置時間
    public AudioClip deathClip;                 //死亡時音效
    public AudioClip damageClip;                //受傷害時音效
    public float maxHp = 100;                   //生命值上限
    public float currentHp = 100;               //當前生命值
    public float recoverSpeed = 1;              //回復生命值速度
    public Text hpText;

    private float timer;                        //計時器
    private FadeInOut fader;                    //FadeInOut組件
    private FPS_Camera fPS_Camera;

    private void Start()
    {
        currentHp = maxHp;
        fader = GameObject.FindGameObjectWithTag(Tags.fader).GetComponent<FadeInOut>();
        fPS_Camera = GameObject.FindGameObjectWithTag(Tags.mainCamera).GetComponent<FPS_Camera>();
        BleedBehavior.BloodAmount = 0;
        hpText.text = "生命值：" + Mathf.Round(currentHp) + "/" + Mathf.Round(maxHp);
    }

    private void Update()
    {
        if (!isDead)
        {
            currentHp += recoverSpeed * Time.deltaTime;
            hpText.text = "生命值：" + Mathf.Round(currentHp) + "/" + Mathf.Round(maxHp);
            if (currentHp > maxHp)
            {
                currentHp = maxHp;
            }
        }
        if (currentHp < 0)
        {
            if (!isDead)
            {
                PlayerDead();
            }
            else
            {
                LevelReset();
            }
        }
    }

    /// <summary>
    /// 受到傷害
    /// </summary>
    public void TakeDamage(float damage)
    {
        if (isDead)
            return;
        //播放受傷音頻
        AudioSource.PlayClipAtPoint(damageClip, transform.position);
        //將值限制在 0 與 1 之間并回傳其傷害值
        BleedBehavior.BloodAmount += Mathf.Clamp01(damage / currentHp);
        currentHp -= damage;
    }

    /// <summary>
    /// 禁用輸入
    /// </summary>
    public void DisableInput()
    {
        //將敵人相機禁用
        transform.Find("Player_Camera/WeaponCamera").gameObject.SetActive(false);
        this.GetComponent<AudioSource>().enabled = false;
        this.GetComponent<FPS_PlayerContorller>().enabled = false;
        this.GetComponent<FPS_PlayerInput>().enabled = false;
        if (GameObject.Find("BulletCount") != null)
        {
            GameObject.Find("BulletCount").SetActive(false);
        }
        fPS_Camera.enabled = false;
    }

    /// <summary>
    /// 玩家死亡
    /// </summary>
    public void PlayerDead()
    {
        isDead = true;

        DisableInput();
        AudioSource.PlayClipAtPoint(deathClip, transform.position);
    }

    /// <summary>
    /// 關卡重置
    /// </summary>
    public void LevelReset()
    {
        timer += Time.deltaTime;
        if (timer > resetAfterDeathTime)
        {
            fader.EndScene();
        }
    }
}

FPS_PlayerInput.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;


public class FPS_PlayerInput : MonoBehaviour
{
    /// <summary>
    /// 鎖定滑鼠屬性
    /// </summary>
    public bool LockCursor
    {
        get
        {
            //如果滑鼠是處于鎖定狀態，回傳true
            return Cursor.lockState == CursorLockMode.Locked ? true : false;
        }
        set
        {
            Cursor.visible = value;
            Cursor.lockState = value ? CursorLockMode.Locked : CursorLockMode.None;
        }
    }

    private FPS_PlayerParameters parameters;
    private FPS_Input input;

    private void Start()
    {
        LockCursor = true;
        parameters = this.GetComponent<FPS_PlayerParameters>();
        input = GameObject.FindGameObjectWithTag(Tags.gameController).GetComponent<FPS_Input>();
    }

    private void Update()
    {
        InitialInput();
    }

    /// <summary>
    /// 輸入引數賦值初始化
    /// </summary>
    private void InitialInput()
    {
        parameters.inputMoveVector = new Vector2(Input.GetAxis("Horizontal"), Input.GetAxis("Vertical"));
        parameters.inputSmoothLook = new Vector2(Input.GetAxisRaw("Mouse X"), Input.GetAxisRaw("Mouse Y"));
        parameters.isInputCrouch = input.GetButton("Crouch");
        parameters.isInputFire = input.GetButton("Fire");
        parameters.isInputJump = input.GetButton("Jump");
        parameters.isInputReload = input.GetButtonDown("Reload");
        parameters.isInputSprint = input.GetButton("Sprint");
    }
}

FPS_PlayerInventory.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class FPS_PlayerInventory : MonoBehaviour
{

    private List<int> keysArr;          //鑰匙串列

    private void Start()
    {
        keysArr = new List<int>();
    }

    /// <summary>
    /// 添加鑰匙
    /// </summary>
    public void AddKey(int keyId)
    {
        if (!keysArr.Contains(keyId))
        {
            keysArr.Add(keyId);
        }
    }

    /// <summary>
    /// 是否有對應門的鑰匙
    /// </summary>
    /// <param name="doorId"></param>
    /// <returns></returns>
    public bool HasKey(int doorId)
    {
        if (keysArr.Contains(doorId))
            return true;
        return false;
    }
}

FPS_PlayerParameters.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

//當你添加的一個用了RequireComponent組件的腳本，
//需要的組件將會自動被添加到game object（游戲物體），
//這個可以有效的避免組裝錯誤
[RequireComponent(typeof(CharacterController))]


public class FPS_PlayerParameters : MonoBehaviour
{
    [HideInInspector]
    public Vector2 inputSmoothLook;     //相機視角
    [HideInInspector]
    public Vector2 inputMoveVector;     //人物移動
    [HideInInspector]
    public bool isInputFire;            //是否開火
    [HideInInspector]
    public bool isInputReload;          //是否換彈
    [HideInInspector]
    public bool isInputJump;            //是否跳躍
    [HideInInspector]
    public bool isInputCrouch;          //是否蹲伏
    [HideInInspector]
    public bool isInputSprint;          //是否沖刺

}

HashIDs.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class HashIDs : MonoBehaviour
{
    public int deadBool;
    public int speedFloat;
    public int playerInSightBool;
    public int shotFloat;
    public int aimWidthFloat;
    public int angularSpeedFloat;

    private void Awake()
    {
        deadBool = Animator.StringToHash("Dead");
        speedFloat = Animator.StringToHash("Speed");
        playerInSightBool = Animator.StringToHash("PlayerInSight");
        shotFloat = Animator.StringToHash("Shot");
        aimWidthFloat = Animator.StringToHash("AimWidth");
        angularSpeedFloat = Animator.StringToHash("AngularSpeed");
    }
}

Tags.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// 封裝標簽
/// </summary>
public class Tags
{
    public const string player = "Player";                      //玩家
    public const string gameController = "GameController";      //游戲控制器
    public const string enemy = "Enemy";                        //敵人
    public const string fader = "Fader";                        //淡入淡出的畫布
    public const string mainCamera = "MainCamera";              //主攝像機
}

一個堅持學習，堅持成長，堅持分享的人，即使再不聰明，也一定會成為優秀的人！

整理不易，如果看完覺得有所識訓的話，記得一鍵三連哦，謝謝！