Unity3D FPS Game（第一人称射击游戏）

耗时一周制作的第一人称射击游戏，希望能帮助到大家！

游戏展示

资源

链接：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";              //主摄像机
}

一个坚持学习，坚持成长，坚持分享的人，即使再不聪明，也一定会成为优秀的人！

整理不易，如果看完觉得有所收获的话，记得一键三连哦，谢谢！