|
耗时一周制作的第一人称射击游戏，希望能帮助到大家！
文章目录
游戏展示
资源
代码
AnimatorSetup.cs
FadeInOut.cs
FPS_Camera.cs
FPS_CrossHair.cs
FPS_DoorControl.cs
FPS_EnemyAI.cs
FPS_EnemyAnimation.cs
FPS_EnemyHealth.cs
FPS_EnemyShoot.cs
FPS_EnemySight.cs
FPS_Exit.cs
FPS_GunScript.cs
FPS_Input.cs
FPS_KeyPickUp.cs
FPS_LaserDamage.cs
FPS_PlayerContorller.cs
FPS_PlayerHealth.cs
FPS_PlayerInput.cs
FPS_PlayerInventory.cs
FPS_PlayerParameters.cs
HashIDs.cs
Tags.cs
游戏展示
   
资源
链接：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;
///
/// 渐隐渐现效果
///
public class FadeInOut : MonoBehaviour
{
private float fadeSpeed = 1f; //渐隐渐现的速率
private bool sceneStarting = true; //场景是否开始
private RawImage rawImage;
void Start()
{
RectTransform rectTransform = this.GetComponent();
//使背景满屏
rectTransform.sizeDelta = new Vector2(Screen.width, Screen.height);
rawImage = this.GetComponent();
rawImage.uvRect = new Rect(0, 0, Screen.width, Screen.height);
rawImage.enabled = true;
}
void Update()
{
if (sceneStarting)
{
StartScene();
}
}
///
/// 渐隐效果
///
private void FadeToClear()
{
rawImage.color = Color.Lerp(rawImage.color, Color.clear, fadeSpeed * Time.deltaTime);
}
///
/// 渐现效果
///
private void FadeToBlack()
{
rawImage.color = Color.Lerp(rawImage.color, Color.black, fadeSpeed * Time.deltaTime);
}
///
/// 场景开始时渐隐
///
private void StartScene()
{
FadeToClear();
if (rawImage.color.a
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();
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;
}
///
/// 更新用户输入处理
///
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 = Mathf.Clamp(y_Angle, rotationYLimit.x, rotationYLimit.y);
//避免X轴超出旋转限制
x_Angle = x_Angle 360 ? x_Angle - 360 : x_Angle;
x_Angle = Mathf.Clamp(x_Angle, rotationXLimit.y, rotationXLimit.x);
}
///
/// 当前视角跟随鼠标移动
///
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; //门附近人物个数
///
/// 门附近人物个数属性
///
public int Count
{
get
{
return count;
}
set
{
//如果门附近有人物靠近或离开时
if (count == 0 && value == 1 || count == 1 && value == 0)
{
//播放门开关的音效
audioSources.clip = doorSwitchClip;
audioSources.Play();
}
count = value;
}
}
///
/// 初始化
///
private void Start()
{
if (transform.childCount > 0)
{
door = transform.GetChild(0);
}
player = GameObject.FindGameObjectWithTag(Tags.player);
playerInventory = player.GetComponent();
audioSources = this.GetComponent();
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();
navMeshAgent = this.GetComponent();
player = GameObject.FindGameObjectWithTag(Tags.player).transform;
playerHealth = player.GetComponent();
}
private void Update()
{
if (enemySight.playerInSight && playerHealth.currentHp > 0)
{
Shooting();
}
else if (enemySight.playerPosition != enemySight.resetPosition && playerHealth.currentHp > 0)
{
Chasing();
}
else
{
patrolling();
}
}
///
/// 射击时不再移动
///
private void Shooting()
{
navMeshAgent.SetDestination(transform.position);
}
///
/// 追击玩家
///
private void Chasing()
{
Vector3 sightingDeltaPos = enemySight.playerPosition - transform.position;
if (sightingDeltaPos.sqrMagnitude > 4f)
{
navMeshAgent.destination = enemySight.playerPosition;
navMeshAgent.speed = chaseSpeed;
}
if (navMeshAgent.remainingDistance
enemySight.playerPosition = enemySight.resetPosition;
chaseTimer = 0;
}
}
else
{
chaseTimer = 0;
}
}
///
/// 巡逻状态
///
private void patrolling()
{
navMeshAgent.speed = patrolSpeed;
if (navMeshAgent.destination == enemySight.resetPosition || navMeshAgent.remainingDistance
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;
///
/// 初始化
///
private void Start()
{
player = GameObject.FindGameObjectWithTag(Tags.player).transform;
enemySight = this.GetComponent();
navMeshAgent = this.GetComponent();
animator = this.GetComponent();
hashIDs = GameObject.FindGameObjectWithTag(Tags.gameController).GetComponent();
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)
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();
hashIDs = GameObject.FindGameObjectWithTag(Tags.gameController).GetComponent();
}
///
/// 收到伤害
///
public void TakeDamage(float damage)
{
hp -= damage;
if (hp
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();
hashIDs = GameObject.FindGameObjectWithTag(Tags.gameController).GetComponent();
laserShotLine = this.GetComponentInChildren();
laserShotLight = laserShotLine.gameObject.GetComponent();
collider = this.GetComponentInChildren();
player = GameObject.FindGameObjectWithTag(Tags.player).transform;
playerHealth = player.GetComponent();
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
float aimWeight = animator.GetFloat(hashIDs.aimWidthFloat);
animator.SetIKPosition(AvatarIKGoal.RightHand, player.position + Vector3.up * 1.5f);
animator.SetIKPositionWeight(AvatarIKGoal.RightHand, aimWeight);
}
///
/// 射击
///
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();
}
///
/// 射击特效
///
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; //
///
/// 初始化
///
private void Start()
{
nav = this.GetComponent();
listenRange = this.GetComponentInChildren();
anim = this.GetComponent();
player = GameObject.FindGameObjectWithTag(Tags.player);
playerHealth = player.GetComponent();
hashIDs = GameObject.FindGameObjectWithTag(Tags.gameController).GetComponent();
playerContorller = player.GetComponent();
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
//如果射线射到的碰撞体为玩家
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;
}
///
/// 侦听玩家的位置
///
private void ListenPlayer()
{
//如果玩家与敌人之间的距离小于侦听检测器的半径时
if (Vector3.Distance(player.transform.position, transform.position)
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();
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;
}
}
///
/// 进入出口激活
///
private void InExitActivation()
{
timer += Time.deltaTime;
if(timer >= timeToInactivePlayer)
{
player.GetComponent().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; //
///
/// 初始化
///
private void Start()
{
parameters = GameObject.FindGameObjectWithTag(Tags.player).GetComponent();
playerContorller = GameObject.FindGameObjectWithTag(Tags.player).GetComponent();
anim = this.GetComponent();
flash = this.transform.Find("muzzle_flash").GetComponent();
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);
}
}
///
/// 装弹动画
///
private void ReloadAnimation()
{
anim.Stop(reloadAnim);
anim[reloadAnim].speed = anim[reloadAnim].clip.length / reloadTime;
anim.Rewind(reloadAnim);
anim.Play(reloadAnim);
}
///
/// 装填完成计算子弹数目协程
///
///
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;
}
///
/// 装弹
///
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);
}
}
}
///
/// 开火特效协程
///
///
private IEnumerator Flash()
{
flash.enabled = true;
yield return new WaitForSeconds(flashRate);
flash.enabled = false;
}
///
/// 开火
///
private void Fire()
{
if (Time.time > nextFireTime)
{
if (currentBulletCount
PlayerShootEvent();
}
}
}
///
/// 伤害敌人
///
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().TakeDamage(damage);
}
}
}
///
/// 播放玩家动画状态
///
///
private void PlayStateAnim(string animName)
{
if (!anim.IsPlaying(animName))
{
anim.Rewind(animName);
anim.Play(animName);
}
}
///
/// 根据玩家动作切换动画
///
///
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;
///
/// 用户输入
///
public class FPS_Input : MonoBehaviour
{
///
/// 自定义轴
///
public class FPS_InputAxis
{
public KeyCode positive; //正向轴
public KeyCode negative; //负向轴
}
//按键字典初始化
public Dictionary buttons = new Dictionary();
//自定义轴字典初始化
public Dictionary axises = new Dictionary();
//unity自带轴集合初始化
public List unityAxises = new List();
private void Start()
{
SetupDefaults();
}
///
/// 初始化按键、自定义轴、unity自带轴
/// 根据类型设置默认按键
///
///
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");
}
}
}
///
/// 添加按键
///
///
///
private void AddButton(string n, KeyCode k)
{
if (buttons.ContainsKey(n))
{
buttons[n] = k;
}
else
{
buttons.Add(n, k);
}
}
///
/// 添加自定义轴
///
///
///
///
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 });
}
}
///
/// 添加unity自带轴
///
///
private void AddUnityAxis(string n)
{
if (!unityAxises.Contains(n))
{
unityAxises.Add(n);
}
}
///
/// 获取按键的按下
///
///
///
public bool GetButton(string button)
{
if (buttons.ContainsKey(button))
{
return Input.GetKey(buttons[button]);
}
return false;
}
///
/// 获取按键开始按下的帧
///
///
///
public bool GetButtonDown(string button)
{
if (buttons.ContainsKey(button))
{
return Input.GetKeyDown(buttons[button]);
}
return false;
}
///
/// 获取轴的输入，[-1,1]之间的float类型
///
///
///
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;
}
///
/// 获取轴的输入，返回-1，0，1中的一个值
///
///
///
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();
}
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().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;
///
/// 人物状态设置
///
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; //移动方向
///
/// 初始化
///
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();
characterController = this.GetComponent();
parameters = this.GetComponent();
normalControllerCenter = characterController.center;
normalControllerHeight = characterController.height;
}
private void FixedUpdate()
{
MoveUpdate();
AudioManager();
}
///
/// 任务移动控制更新
///
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();
}
///
/// 根据人物的状态对其速度进行定义
///
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;
}
}
///
/// 根据人物状态对其脚步声进行定义
///
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();
}
}
///
/// 蹲伏下降与蹲伏上升时相机位置更新
///
private void CrouchUpdate()
{
if (crouching)
{
if (mainCamera.localPosition.y > crouchingCamHeight)
{
if(mainCamera.localPosition.y-(crouchDeltaHeight * Time.deltaTime * cameraMoveSpeed)
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
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();
fPS_Camera = GameObject.FindGameObjectWithTag(Tags.mainCamera).GetComponent();
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
PlayerDead();
}
else
{
LevelReset();
}
}
}
///
/// 受到伤害
///
public void TakeDamage(float damage)
{
if (isDead)
return;
//播放受伤音频
AudioSource.PlayClipAtPoint(damageClip, transform.position);
//将值限制在 0 与 1 之间并返回其伤害值
BleedBehavior.BloodAmount += Mathf.Clamp01(damage / currentHp);
currentHp -= damage;
}
///
/// 禁用输入
///
public void DisableInput()
{
//将敌人相机禁用
transform.Find("Player_Camera/WeaponCamera").gameObject.SetActive(false);
this.GetComponent().enabled = false;
this.GetComponent().enabled = false;
this.GetComponent().enabled = false;
if (GameObject.Find("BulletCount") != null)
{
GameObject.Find("BulletCount").SetActive(false);
}
fPS_Camera.enabled = false;
}
///
/// 玩家死亡
///
public void PlayerDead()
{
isDead = true;
DisableInput();
AudioSource.PlayClipAtPoint(deathClip, transform.position);
}
///
/// 关卡重置
///
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
{
///
/// 锁定鼠标属性
///
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();
input = GameObject.FindGameObjectWithTag(Tags.gameController).GetComponent();
}
private void Update()
{
InitialInput();
}
///
/// 输入参数赋值初始化
///
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 keysArr; //钥匙列表
private void Start()
{
keysArr = new List();
}
///
/// 添加钥匙
///
public void AddKey(int keyId)
{
if (!keysArr.Contains(keyId))
{
keysArr.Add(keyId);
}
}
///
/// 是否有对应门的钥匙
///
///
///
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;
///
/// 封装标签
///
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"; //主摄像机
}
一个坚持学习，坚持成长，坚持分享的人，即使再不聪明，也一定会成为优秀的人！
整理不易，如果看完觉得有所收获的话，记得一键三连哦，谢谢！
|