【Unity3D】Tank大战

1 需求实现

        项目代码见→坦克大战1.1.0

        1）人机交互

• 玩家通过 ↑ ↓ ← → 键（或 W、S、A、D）键控制己方坦克平移；
• 玩家通过滑动鼠标右键控制己方坦克左右旋转；
• 玩家通过鼠标左键（或空格键）控制己方坦克发射炮弹；
• 玩家通过 ESC 键控制窗口全屏和恢复；
• 玩家通过 Q 键控制退出游戏；

        2）相机

• 主相机跟随：主相机始终在玩家后上方的位置，并保持与玩家的相对位置不变；
• 次相机实现小地图：次相机俯拍战场，并将影像在屏幕右上角显示；
• 单击小地图，小地图全屏，再单击，小地图恢复，在全屏和恢复的过程中有缩放动效。

        3）坦克属性

• 坦克属性：血量、移动速度、旋转速度、颜色、初始位置、初始方位。

        4）炮弹属性

• 炮弹属性：伤害、飞行速度、冷却时间、射程、颜色。

        5）敌方坦克生成策略

• 敌方坦克根据能力值分三个级别，对应比例为 3：2：1，颜色分别为灰、浅蓝、黄；
• 敌方坦克初始生成 10 个，之后每隔 2 秒生成一个，总共 50 个坦克；
• 敌方坦克生成位置和朝向都是随机的，并且能够保证坦克位置不会重叠。

        6）敌方坦克作战策略

• 转向再开炮：玩家在敌方坦克 0.5 倍射程范围内，敌方坦克转向玩家，再向玩家开炮；
• 转向再靠近并开炮：玩家在敌方坦克 1 倍射程范围内，敌方坦克转向玩家，再向玩家移动，同时向玩家开炮
• 转向再靠近：玩家在敌方坦克 1.5 倍射程范围内，敌方坦克转向玩家，再向玩家移动；
• 随机巡逻：玩家在敌方坦克在 1.5 倍射程范围外，敌方坦克随机巡逻：将其 10 ~ 30米外的随机一处位置作为目标位置，转向目标位置，再向目标位置移动；如果到中途满足以上条件，则执行相应操作；如果不满足，继续向目标位置移动；如果中途发现前方 5 米范围内有友军，重新换一个目标位置继续巡逻；如果达到目标位置仍不满足以上条件，再换一个目标位置继续巡逻。

        7）血条

• 玩家血条显示在屏幕左上角，玩家被命中时，扣除相应血量，血量进度条向左滑动，血量比例更新；
• 敌方坦克血条显示在坦克的上方，随坦克一起运动，坦克被命中时，扣除相应血量，血量进度条向左滑动；
• 敌方坦克在运动时，其血条始终朝向主相机。

        8）杀敌计数

• 在屏幕左上角、玩家血条下方显示杀敌计数，每杀掉一个敌人，杀敌计数加 1，进度条向右滑动。

        9）摇杆

• 摇杆显示在屏幕左下角，拖拽摇杆可以控制己方坦克平移；
• ↑ ↓ ← → 键（或 W、S、A、D 键）除了能控制己方坦克平移，还能控制摇杆移动。

        10）死亡策略

• 坦克在死亡时，停止运动并停止发射炮弹，渐变为透明；
• 己方坦克死亡时，生成一个空对象替换己方坦克，使得玩家可以通过 ↑ ↓ ← → 键（或 W、S、A、D 键）及鼠标右键，继续查看战场。

2 相关技术栈

• Transform组件
• 人机交互
• 刚体组件Rigidbody
• 碰撞体组件Collider
• 物理射线
• 相机跟随
• Canvas渲染模式与锚点
• UGUI之Text
• UGUI之Image
• 血条
• UGUI回调函数
• 摇杆
• 退出全屏、退出游戏
• 相机

3 游戏对象

        1）游戏界面

        2）游戏对象层级结构

        Hierarchy 窗口游戏对象：

         预设体游戏对象：

        3）Transform组件参数

        1. Tank Transform 组件参数

        补充：Tank 游戏对象添加了刚体组件，并修改 Mass = 100，Drag = 1，AngularDrag = 0.5，Tank 作为预设体拖拽到 Assets/Resources/Prefabs 目录下，敌方坦克和己方坦克共用 Tank 预设体。

        2. 玩家 Blood RectTransform 组件参数

        补充：Value 的 ImageType 设置为 Filled，Fill Method 设置为 Horizontal，Fill Origin 设置为 Left。

        3. Kill RectTransform 组件参数

        补充：Value 的 ImageType 设置为 Filled，Fill Method 设置为 Horizontal，Fill Origin 设置为 Left。

        4. Stick RectTransform 组件参数

        5. 敌人 Blood RectTransform 组件参数

        补充： 敌人 Blood 的 Canvas 渲染模式是 World Space，Value 的 ImageType 设置为 Filled，Fill Method 设置为 Horizontal，Fill Origin 设置为 Right。

        6. Plane、Bullet、MinimapCamera Transform 组件参数

        补充：Bullet 作为预设体拖拽到 Assets/Resources/Prefabs 目录下，并且添加了刚体组件，己方坦克和敌方坦克使用的炮弹预设体都是 Bullet；MinimapCamera 是次相机，用于渲染小地图，其 Viewport Rect 为 (0.8, 0.7, 0.2, 0.3)，Culling Mask 中去掉勾选 UI 图层（不渲染敌人血条）。

4 游戏框架

        1）类图 

        2）代码目录

5 代码实现

        BaseCreater.cs

using System;
using UnityEngine;

public class BaseCreater : MonoBehaviour {
	protected GameObject tankPrefab; // 坦克预设体
	protected Action dyingAction; // 死亡活动

	protected void LoadPrefab() { // 加载预设体
		tankPrefab = (GameObject) Resources.Load("Prefabs/Tank");
	}

	protected GameObject CreateTank(TankInfo info) { // 创建坦克
		GameObject tank = Instantiate(tankPrefab, info.tankInitPosition, Quaternion.Euler(info.tankInitRotation));
		tank.name = info.GetName();
		UpdateColor(tank, info.tankColor);
		return tank;
	}

	private void UpdateColor(GameObject tank, Color color) { // 更新坦克颜色
		ForAllChildren(tank, obj => {
			MeshRenderer renderer = obj.GetComponent<MeshRenderer>();
			if (renderer != null) {
				renderer.material.color = color;
			}
		});
	}

	private void ForAllChildren(GameObject obj, Action<GameObject> action) { // 每个子孙对象(包含自己)执行委托动作
		if (obj == null) {
			return;
		}
		foreach(Transform child in obj.GetComponentsInChildren<Transform>()) {
			action(child.gameObject);
		}
	}
}

        PlayerCreater.cs

using System;
using UnityEngine;
using UnityEngine.UI;

public class PlayerCreater : BaseCreater {
	[Header("坦克信息")]
	public TankInfo tankInfo;

	private void Awake() {
		LoadPrefab();
		tankInfo = TankParamsManager.GetInstance().GetPlayerTankInfo();
		GameObject tank = CreateTank(tankInfo);
		dyingAction += () => {
			Camera.main.GetComponent<CameraController>().PlayerDying(); // 玩家死亡, 相机重新跟随一个空对象
		};
		tank.AddComponent<PlayerController>()
			.SetDiedAction(dyingAction)
			.SetTankInfo(tankInfo);
	}
}

        说明：PlayerCreater 脚本组件挂在 PlayerCreater 游戏对象上。

        EnemyCreater.cs

using System;
using UnityEngine;

public class EnemyCreater : BaseCreater {
	protected GameObject bloodPrefab; // 血条预设体
	public EnemiesInfo enemiesInfo = null;

	private Transform player; // 玩家
	private KillHelper killHelper; // 杀敌助手
	private float waitTime = 0; // 距离上次坦克生成已等待的时间

	private void Awake() {
		LoadPrefab();
		enemiesInfo = new EnemiesInfo();
		killHelper = new KillHelper(enemiesInfo.GetTotalNum());
		dyingAction += () => {
			enemiesInfo.CurrDes();
			killHelper.KillEnemy();
		};
	}

	private void Start() {
		player = GameObject.Find("Player/Top").transform;
		CreateInitEnemies();
	}

	private void Update() {
		if (waitTime > EnemiesInfo.ENTER_INTERVAL && enemiesInfo.GetAppeardNum() < EnemiesInfo.TOTAL_NUM) {
			CreateTank();
			waitTime = 0;
		}
		waitTime += Time.deltaTime;
	}

	protected new void LoadPrefab() { // 加载预设体
		base.LoadPrefab();
		bloodPrefab = (GameObject) Resources.Load("Prefabs/Blood");
	}

	private void CreateInitEnemies() {
		for (int i = 0; i < EnemiesInfo.INIT_NUM; i++) {
			CreateTank();
		}
	}

	private GameObject CreateTank() { // 创建坦克
		int level = enemiesInfo.GetRandomLevel();
		TankInfo tankInfo = TankParamsManager.GetInstance().GetEnemyTankInfo(level);
		Vector3 position = GetEnemyPosition();
		Vector3 rotation = GetEnemyRotation();
		tankInfo.tankInitPosition = position;
		tankInfo.tankInitRotation = rotation;
		GameObject tank = CreateTank(tankInfo);
		CreateHealth(tank);
		tank.AddComponent<EnemyController>()
			.SetPlayer(player)
			.SetDiedAction(dyingAction)
			.SetTankInfo(tankInfo);
		enemiesInfo.CurrAdd();
		return tank;
	}

	private Vector3 GetEnemyPosition() { // 获取敌人随机位置
		Vector3 position = new Vector3(0f, 0.25f, 0f);
		do {
			position.x = UnityEngine.Random.Range(-49f, 49f);
			position.z = UnityEngine.Random.Range(-49f, 49f);
		} while (IsOccupied(position));
		return position;
	}

	private Vector3 GetEnemyRotation() { // 获取敌人随机方向
		int y = UnityEngine.Random.Range(0, 360);
		return new Vector3(0, y, 0);
	}

	private bool IsOccupied(Vector3 pos) { // 检测指定位置是否被占用
		Vector3 halfExtents = new Vector3(2, 0.1f, 2);
		return Physics.CheckBox(pos, halfExtents);
	}

	private void CreateHealth(GameObject tank) { // 创建血条
		Vector3 pos = tank.transform.position;
		Vector3 realPos = new Vector3(pos.x, pos.y + 1.5f, pos.z);
		GameObject blood = Instantiate(bloodPrefab, realPos, Quaternion.identity, tank.transform);
		blood.name = "Blood";
	}
}

        说明：EnemyCreater 脚本组件挂在 EnemyCreater 游戏对象上。

        TankController.cs

using System;
using UnityEngine;
using UnityEngine.UI;

public class TankController : MonoBehaviour {
	protected TankInfo tankInfo; // 坦克信息
	protected GameObject bulletPrefab; // 炮弹预设体
	protected Transform firePoint; // 开火点
	protected BloodHelper bloodHelper; // 血量助手
	protected float fireWaitTime = float.MaxValue; // 距离上次开火已等待的时间
	protected volatile bool isDying = false; // 死亡中
	protected Action diedAction; // 敌人死亡活动

	protected void LoadBullet() {
		bulletPrefab = (GameObject) Resources.Load("Prefabs/Bullet");
		firePoint = transform.Find("Top/Gun/FirePoint");
	}

	public TankController SetTankInfo(TankInfo info) {
		tankInfo = info;
		return this;
	}

	public TankController SetDiedAction(Action action) {
		diedAction = action;
		return this;
	}

	protected void Fire() { // 开炮
		if (fireWaitTime > tankInfo.bullet.bulletCoolTime) {
			BulletInfo info = tankInfo.bullet.Clone() as BulletInfo;
			info.SetFlyDir(transform.forward);
			GameObject bullet = Instantiate(bulletPrefab, firePoint.position, Quaternion.identity);
			bullet.AddComponent<BulletController>().SetBulletInfo(info);
			fireWaitTime = 0f;
		}
	}

	public void BuckleBlood(int damage) { // 扣血
		isDying = bloodHelper.BuckleBlood(damage);
	}

	public bool IsDying() {
		return isDying;
	}

	protected void Dying() { // 坦克死亡中, 渐变为透明
		ForAllChildren(gameObject, obj => {
			Renderer renderer = obj.GetComponent<Renderer>();
			if (renderer != null) {
				Color color = renderer.material.color;
				// 材质球的 Rendering Mode 需要设置为 Fade 或 Transparent, 渐变才会生效
				renderer.material.color = new Color(color.r, color.g, color.b, color.a - Time.deltaTime / 3);
			}
			Image image = obj.GetComponent<Image>();
			if (image != null) {
				Color color = image.color;
				image.color = new Color(color.r, color.g, color.b, color.a - Time.deltaTime / 3);
			}
		});
	}

	protected bool CheckFallDeath() { // 检验摔死
		if (!isDying && transform.position.y < -5) {
			isDying = true;
			Destroy(gameObject, 3);
			diedAction.Invoke();
			return true;
		}
		return false;
	}

	protected void ForAllChildren(GameObject obj, Action<GameObject> action) { // 每个子孙对象(包含自己)执行委托动作
		if (obj == null) {
			return;
		}
		foreach(Transform child in obj.GetComponentsInChildren<Transform>()) {
			action(child.gameObject);
		}
	}
}

        PlayerController.cs

using System;
using UnityEngine;
using UnityEngine.UI;

public class PlayerController : TankController {
	private MoveHelper moveHelper; // 交互助手
	private StickController stick; // 摇杆控制器

	private void Awake() {
		LoadBullet();
		stick = GameObject.Find("UI/Stick/Ball").GetComponent<StickController>();
		moveHelper = new MoveHelper(transform);
	}

	private void Start() {
		diedAction += () => {
			stick.PlayerDying();
		};
		moveHelper.Init(tankInfo.tankMoveSpeed, tankInfo.tankRotateSpeed);
		LoadBlood();
	}

	private void Update() {
		if (isDying || CheckFallDeath()) {
			Dying();
			return;
		}
		fireWaitTime += Time.deltaTime;
		moveHelper.Move();
		moveHelper.Rotate();
		if (Input.GetMouseButtonDown(0) && !stick.IsMouseInStickArea()
				|| Input.GetKeyDown(KeyCode.Space)) {
			Fire();
		}
	}

	private void LoadBlood() {
		Image bloodValueImg = GameObject.Find("UI/Blood/Progress/Value").GetComponent<Image>();
		Text bloodRateTxt = GameObject.Find("UI/Blood/Progress/Rate").GetComponent<Text>();
		bloodHelper = new BloodHelper(bloodValueImg, bloodRateTxt, tankInfo, diedAction);
	}

	public void Move(float hor, float ver) { // 坦克移动
		moveHelper.Move(hor, ver);
	}
}

        说明：PlayerController 脚本组件挂在 Player 游戏对象上。

        EnemyController.cs

using System;
using UnityEngine;
using UnityEngine.UI;

public class EnemyController : TankController {
	private Transform player; // 玩家
	private Transform top; // 炮头
	private Vector3 tempTarget; // 临时目标点，巡逻时使用
	private bool isFoundPlayer = false; // 是否发现了玩家
	private float findTargetTime = 0; // 巡逻时寻找目标花费的时间

	private void Awake() {
		LoadBullet();
		top = transform.Find("Top");
		Vector3 pos = top.position;
		tempTarget = new Vector3(pos.x, pos.y, pos.z);
	}

	private void Start(){
		LoadBlood();
	}

	private void Update() {
		if (isDying || CheckFallDeath()) {
			Dying();
			return;
		}
		bloodHelper.BloodLookAtCamera();
		float distance = GetDistance();
		if (distance < 1.5f * tankInfo.bullet.bulletFireRange) { // 发现了玩家
			if (distance < tankInfo.bullet.bulletFireRange / 2 || distance < 5) {
				Fire();
			} else if (distance < tankInfo.bullet.bulletFireRange) {
				MoveToTarget(player.position);
				Fire();
			} else {
				MoveToTarget(player.position);
			}
			isFoundPlayer = true;
			findTargetTime = 0;
		} else {
			Patrol();
			isFoundPlayer = false;
		}
		fireWaitTime += Time.deltaTime;
	}

	public EnemyController SetPlayer(Transform transform) {
		player = transform;
		return this;
	}

	protected new void Fire() { // 开炮
		if (LookAtTarget(player.position)) {
			base.Fire();
		}
	}

	private bool LookAtTarget(Vector3 target) { // 转向目标
		Vector3 dir = target - top.position;
		float angle = Vector3.Angle(dir, top.forward);
		if (angle > 5) {
			int axis = Vector3.Dot(Vector3.Cross(dir, top.forward), Vector3.up) > 0 ? -1 : 1;
			GetComponent<Rigidbody>().angularVelocity = axis * Vector3.up * tankInfo.tankRotateSpeed;
			return false;
		}
		GetComponent<Rigidbody>().angularVelocity = Vector3.zero;
		return true;
	}

	private void MoveToTarget(Vector3 target) { // 向目标移动
		if (LookAtTarget(target)) {
			Vector3 dir = (target - top.position).normalized;
			GetComponent<Rigidbody>().velocity = tankInfo.tankMoveSpeed * dir;
			findTargetTime += Time.deltaTime;
		}
	}

	private void Patrol() { // 巡逻
		GetNextPatrolTarget();
		MoveToTarget(tempTarget);
	}

	private float GetDistance() { // 获取坦克距离玩家的距离
		if (player == null) {
			return float.MaxValue;
		}
		return Vector3.Distance(player.position, top.position);
	}

	private void GetNextPatrolTarget() { // 获取下一个巡逻目标点
		if (isFoundPlayer || Vector3.Distance(tempTarget, top.position) < 0.1f
				|| ForwardHasFriends() && findTargetTime > 1) {
			float angle = top.eulerAngles.y + UnityEngine.Random.Range(-120f, 120f);
			angle = angle * Mathf.PI / 180f;
			float radius = UnityEngine.Random.Range(10f, 30f);
			tempTarget.x = Mathf.Clamp(top.position.x + radius * Mathf.Cos(angle), -49, 49);
			tempTarget.z = Mathf.Clamp(top.position.z + radius * Mathf.Sin(angle), -49, 49);
			findTargetTime = 0;
		}
	}

	private bool ForwardHasFriends() { // 前方有友军
		return Physics.BoxCast(top.position, new Vector3(1, 0.5f, 1), top.forward, top.rotation, 5,  ~(1 << 8));
	}

	private void LoadBlood() {
		Transform blood = transform.Find("Blood");
		Image bloodValueImg = blood.Find("Value").GetComponent<Image>();
		bloodHelper = new BloodHelper(bloodValueImg, null, tankInfo, diedAction);
		bloodHelper.setTransform(blood);
	}
}

        说明：EnemyController 脚本组件挂在 Enemy 游戏对象上。

        BulletController.cs

using UnityEngine;

public class BulletController : MonoBehaviour {
	private BulletInfo bulletInfo; // 炮弹信息
	private bool isDying = false;

	private void Start () {
		GetComponent<MeshRenderer>().material.color = bulletInfo.bulletColor;
		float lifeTime = bulletInfo.bulletFireRange / bulletInfo.bulletSpeed; // 存活时间
		Destroy(gameObject, lifeTime);
	}

	private void Update () {
		transform.GetComponent<Rigidbody>().velocity = bulletInfo.GetFlyDir() * bulletInfo.bulletSpeed;
	}

	private void OnCollisionEnter(Collision other) {
		TankController tankController = other.gameObject.GetComponent<TankController>();
		if (isDying || tankController == null || tankController.IsDying()) {
			return;
		}
		if (isHitEnemy(bulletInfo.GetName(), other.gameObject.name)
				|| isHitPlayer(bulletInfo.GetName(), other.gameObject.name)) {
			tankController.BuckleBlood(bulletInfo.bulletDamage);
			if (tankController.IsDying()) {
				Destroy(other.gameObject, 3f);
			}
		}
		isDying = true;
		Destroy(gameObject, 0.3f);
	}

	public void SetBulletInfo(BulletInfo info) {
		bulletInfo = info;
	}

	private bool isHitEnemy(string bulletName, string roleName) { // 击中敌军
		return "PlayerBullet".Equals(bulletName) && "Enemy".Equals(roleName);
	}

	private bool isHitPlayer(string bulletName, string roleName) { // 击中玩家
		return "EnemyBullet".Equals(bulletName) && "Player".Equals(roleName);
	}
}

        说明：BulletController 脚本组件挂在 Bullet 游戏对象上。

        CameraController.cs

using UnityEngine;
 
public class CameraController : MonoBehaviour {
	protected Transform player; // 玩家
	protected Transform visitor; // 游客
	protected Vector3 relaPlayerPos; // 相机在玩家坐标系中的位置

	protected void InitPlayer() {
		GameObject obj = GameObject.Find("Player/Top");
		if (obj != null) {
			player = obj.transform;
			CompCameraPos(player);
		}
	}

	public void PlayerDying() { // 玩家死亡时, 游客替换玩家的位置, 使相机跟随游客
		GameObject visitorObj = new GameObject("Visitor");
		visitorObj.AddComponent<VisitorController>();
		visitor = visitorObj.transform;
		visitor.position = player.position;
		visitor.rotation = player.rotation;
		player = null;
	}

	protected Transform getVisitor() { // 给小地图相机使用
		GameObject visitorObj = GameObject.Find("Visitor");
		if (visitorObj != null) {
			return visitorObj.transform;
		}
		return visitor;
	}

	// 求以origin为原点, locX, locY, locZ 为坐标轴的本地坐标系中的向量 vec 在世界坐标系中对应的向量
	protected Vector3 transformVecter(Vector3 vec, Vector3 origin, Vector3 locX,  Vector3 locY,  Vector3 locZ) {
		return vec.x * locX + vec.y * locY + vec.z * locZ + origin;
	}

	protected void CompCameraPos(Transform target) { // 计算相机位置
	}
}

        MainCameraController.cs

using UnityEngine;
 
public class MainCameraController : CameraController {
	private float targetDistance = 30f; // 相机看向玩家前方的位置
 
	private void Start() {
		relaPlayerPos = new Vector3(0, 8, -12);
		InitPlayer();
	}
 
	private void LateUpdate() {
		if (player != null) {
			CompCameraPos(player);
		} else if (visitor == null) {
			visitor = getVisitor();
		} else {
			CompCameraPos(visitor);
		}
	}

	protected new void CompCameraPos(Transform target) { // 计算相机坐标
		transform.position = transformVecter(relaPlayerPos, target.position, target.right, target.up, target.forward);
		if (transform.position.y < 0) { // 避免坦克翻面时相机朝天
			transform.position = new Vector3(transform.position.x, -transform.position.y, transform.position.z);
		}
		Vector3 lookPos = target.position + target.forward * targetDistance;
		if (lookPos .y > 1) { // 避免坦克扬起时相机朝天
			lookPos = new Vector3(lookPos.x, 1, lookPos.z);
		}
		transform.rotation = Quaternion.LookRotation(lookPos - transform.position);
	}
}

        说明：MainCameraController 脚本组件挂在 MainCamera 游戏对象上。 

        MinimapCameraController.cs

using UnityEngine;

public class MinimapCameraController : CameraController {
	private CameraController mainCamera;
	private bool isFullscreen = false; // 小地图相机是否全屏
	private Rect minViewport; // 小地图视口位置和大小（相对值）
	private Rect fullViewport; // 全屏时视口位置和大小（相对值）
	private Rect targetViewport; // 目标视口大小, 用于动效
	private float switchRectInternal = 0.3f; // 切换小地图尺寸时间间隔
	private float switchWaitTime = float.MaxValue; // 切换小地图等待时间
	private bool isSwitching = false; // 切换中, 用于标记执行切换动效中
 
	private void Start() {
		mainCamera = Camera.main.GetComponent<CameraController>();
		minViewport = GetComponent<Camera>().rect;
		fullViewport = new Rect(0, 0, 1, 1);
		relaPlayerPos = new Vector3(0, 50, 0);
		InitPlayer();
	}
 
	private void Update() {
		switchWaitTime += Time.deltaTime;
		if (switchWaitTime > switchRectInternal && !isSwitching) {
			SwitchRect();
		}
		if (isSwitching) {
			SwitchAnimation();
		}
	}
 
	private void LateUpdate() {
		if (player != null) {
			CompCameraPos(player);
		} else if (visitor == null) {
			visitor = getVisitor();
		} else {
			CompCameraPos(visitor);
		}
	}

	private void SwitchRect() { // 切换小地图尺寸
		if (Input.GetMouseButtonDown(0) && IsClickMinimap()) {
			if (isFullscreen) { // 小地图缩小
				targetViewport = minViewport;
			} else { // 小地图放大
				targetViewport = fullViewport;
			}
			isFullscreen = !isFullscreen;
			isSwitching = true;
			switchWaitTime = 0;
		}
	}

	private void SwitchAnimation() { // 切换动效
		Rect rect = GetComponent<Camera>().rect;
		rect.position = Vector2.Lerp(rect.position, targetViewport.position, 0.5f);
		rect.size = Vector2.Lerp(rect.size, targetViewport.size, 0.5f);
		GetComponent<Camera>().rect = rect;
		if (Vector2.Distance(rect.position, targetViewport.position) < 0.01f) {
			GetComponent<Camera>().rect = targetViewport;
			isSwitching = false;
		}
	}

	protected new void CompCameraPos(Transform target) { // 计算相机坐标
		transform.position = target.position + relaPlayerPos;
	}
 
	public bool IsClickMinimap() { // 是否单击到小地图区域
		Vector3 pos = Input.mousePosition;
		if (isFullscreen || isSwitching) {
			return true;
		}
		if (pos.x / Screen.width > minViewport.xMin && pos.y / Screen.height > minViewport.yMin) {
			return true;
		}
		return false;
	}
}

        说明：MinimapCameraController 脚本组件挂在 MinimapCamera 游戏对象上。

        VisitorController.cs

using UnityEngine;

public class VisitorController : MonoBehaviour {
	private MoveHelper moveHelper; // 交互助手

	private void Awake() {
		moveHelper = new MoveHelper(transform);
		moveHelper.Init(6, 10);
	}

	private void Update() {
		moveHelper.Move();
		moveHelper.Rotate();
	}
}

        说明：VisitorController 脚本组件挂在 Visitor 游戏对象上。

        StickController.cs

using UnityEngine;
using UnityEngine.EventSystems;

public class StickController : MonoBehaviour, IDragHandler, IEndDragHandler {
	private Vector3 originPos; // 鼠标开始拖拽时位置
	private Vector3 currPos; // 鼠标当前位置
	private float radius; // 遥杆半径
	private PlayerController player; // 玩家控制器
	private Vector3 dire = Vector3.zero; // 摇杆球的方位

	private void Start () {
		originPos = transform.position;
		radius = 50;
		player = GameObject.Find("Player").GetComponent<PlayerController>();
	}

	private void Update () {
		if (player != null && !Vector3.zero.Equals(dire)) {
			player.Move(dire.x, dire.y);
		}
	}

	public void OnDrag(PointerEventData eventData) {
		Vector3 vec = Input.mousePosition - originPos;
		dire = vec.normalized * Mathf.Min(vec.magnitude / radius, 1);
		UpdateStick(dire);
	}

	public void OnEndDrag(PointerEventData eventData) {
		transform.position = originPos;
		dire = Vector3.zero;
	}

	public void UpdateStick(Vector3 dire) { // 更新摇杆位置
		transform.position = originPos + dire * radius;
	}

	public void PlayerDying() {
		player = null;
		UpdateStick(Vector3.zero);
	}

	public bool IsMouseInStickArea() { // 鼠标在Stick区域
		Vector3 pos = Input.mousePosition;
		return pos.x < 150 && pos.y < 150;
	}
}

        说明：StickController 脚本组件挂在 Stick 游戏对象上。

        BloodHelper.cs

using System;
using UnityEngine;
using UnityEngine.UI;

public class BloodHelper {
	private Transform transform; // 血条Transform
	private Image bloodValueImg; // 血条Image
	private Text bloodRateTxt; // 血量比率Text
	private TankInfo tankInfo; // 坦克信息
	private Action diedAction; // 死亡活动

	public BloodHelper(Image bloodValueImg, Text bloodRateTxt, TankInfo tankInfo, Action diedAction) {
		this.bloodValueImg = bloodValueImg;
		this.bloodRateTxt = bloodRateTxt;
		this.tankInfo = tankInfo;
		this.diedAction = diedAction;
		bloodValueImg.fillAmount = 1;
		if (bloodRateTxt != null) {
			bloodRateTxt.text = "" + tankInfo.GetFullBlood() + " / " + tankInfo.GetFullBlood();
		}
	}

	public bool BuckleBlood(int damage) { // 扣血
		bloodValueImg.fillAmount = tankInfo.BuckleBlood(damage);
		if (bloodRateTxt != null) {
			bloodRateTxt.text = "" + tankInfo.GetCurrBlood() + " / " + tankInfo.GetFullBlood();
		}
		bool isDying = tankInfo.IsDying();
		if (isDying) {
			diedAction.Invoke();
		}
		return isDying;
	}

	public void setTransform(Transform transform) {
		this.transform = transform;
	}

	public void BloodLookAtCamera() { // 血条朝向相机
		Vector3 cameraPos = Camera.main.transform.position;
		Vector3 target = new Vector3(cameraPos.x, transform.position.y, cameraPos.z);
		transform.LookAt(target);
	}
}

        KillHelper.cs

using UnityEngine;
using UnityEngine.UI;

public class KillHelper {
	private Image killValueImg; // 杀敌Image
	private Text killRateTxt; // 杀敌比率Text
	private int enemiesNum; // 敌人总数
	private int currKillEnemies; // 当前杀敌数

	public KillHelper(int enemiesNum) {
		this.enemiesNum = enemiesNum;
		currKillEnemies = 0;
		killValueImg = GameObject.Find("UI/Kill/Progress/Value").GetComponent<Image>();
		killRateTxt = GameObject.Find("UI/Kill/Progress/Rate").GetComponent<Text>();
		UpdateUI();
	}

	public void KillEnemy() { // 杀敌
		lock(this) {
			currKillEnemies++;
			UpdateUI();
		}
	}

	private void UpdateUI() {
		killValueImg.fillAmount = 1.0f * currKillEnemies / enemiesNum;
		killRateTxt.text = "" + currKillEnemies + " / " + enemiesNum;
	}
}

        MoveHelper.cs

using UnityEngine;

public class MoveHelper {
	private Transform transform; // 交互对象的变换组件
	protected StickController stick; // 摇杆控制器
	private Vector3 predownMousePoint; // 鼠标右键按下时的位置
	private Vector3 currMousePoint; // 鼠标右键滑动过程中的位置
	private float moveSpeed; // 移动速度
	private float rotateSpeed; // 旋转速度

	public MoveHelper(Transform transform) {
		this.transform = transform;
		stick = GameObject.Find("UI/Stick/Ball").GetComponent<StickController>();
	}

	public void Init(float moveSpeed, float rotateSpeed) {
		this.moveSpeed = moveSpeed;
		this.rotateSpeed = rotateSpeed;
	}

	public void Move() { // 移动
		float hor = Input.GetAxis("Horizontal");
        float ver = Input.GetAxis("Vertical");
		Move(hor, ver);
		if (Mathf.Abs(hor) > float.Epsilon || Mathf.Abs(ver) > float.Epsilon) {
			updateStick(hor, ver);
		}
	}

	public void Move(float hor, float ver) { // 移动
		if (Mathf.Abs(hor) > float.Epsilon || Mathf.Abs(ver) > float.Epsilon) {
			Rigidbody rigidbody = transform.GetComponent<Rigidbody>();
			if (rigidbody != null) {
				Vector3 vec = transform.forward * ver + transform.right * hor;
				rigidbody.velocity = vec * moveSpeed;
			} else {
				transform.Translate(new Vector3(hor, 0, ver) * Time.deltaTime * moveSpeed);
			}
			RestrictBoundary();
		}
	}

	public void Rotate() { // 旋转
		if (Input.GetMouseButtonDown(1)) {
			predownMousePoint = Input.mousePosition;
		} else if (Input.GetMouseButton(1)) {
			currMousePoint = Input.mousePosition;
			Vector3 vec = currMousePoint - predownMousePoint;
			Rigidbody rigidbody = transform.GetComponent<Rigidbody>();
			if (rigidbody != null) {
				rigidbody.angularVelocity = Vector3.up * rotateSpeed * vec.x;
			} else {
				transform.Rotate(Vector3.up * vec.x * Time.deltaTime * rotateSpeed);
			}
			predownMousePoint = currMousePoint;
		}
	}

	private void updateStick(float hor, float ver) { // 更新摇杆
		Vector3 dire = new Vector3(hor, ver, 0);
		dire =  dire.normalized * Mathf.Min(dire.magnitude, 1);
		stick.UpdateStick(dire);
	}

	private void RestrictBoundary() { // 限制边界
		Vector3 pos = transform.position;
		if (Mathf.Abs(pos.x) > 49) {
			transform.position = new Vector3(Mathf.Sign(pos.x) * 49, pos.y, pos.z);
		} else if (Mathf.Abs(pos.z) > 49) {
			transform.position = new Vector3(pos.x, pos.y, Mathf.Sign(pos.z) * 49);
		}
	}
}

        TankInfo.cs

using System;
using UnityEngine;

[Serializable]
public class TankInfo : ICloneable {
	[Header("坦克满血量")]
	[Range(30, 100)]
	public int fullBlood = 30;

	[Header("坦克移动速度")]
	[Range(1, 5)]
	public float tankMoveSpeed = 3f;

	[Header("坦克旋转速度")]
	[Range(1, 4)]
	public float tankRotateSpeed = 2f;

	[Header("坦克颜色")]
	public Color tankColor = Color.green;

	[Header("坦克初始位置")]
	public Vector3 tankInitPosition = new Vector3(0f, 0.25f, 0f);

	[Header("坦克初始方位")]
	public Vector3 tankInitRotation = new Vector3(0, 0, 0);

	[Header("炮弹信息")]
	public BulletInfo bullet;

	private String name = "Enemy"; // 坦克角色名
	private int currBlood = 30; // 坦克当前血量

	public TankInfo(String name) {
		this.name = name;
		bullet = new BulletInfo(name + "Bullet");
	}

	public object Clone() { // 克隆坦克
		TankInfo info = new TankInfo(this.name);
		info.fullBlood = this.fullBlood;
		info.tankMoveSpeed = this.tankMoveSpeed;
		info.tankRotateSpeed = this.tankRotateSpeed;
		info.tankColor = this.tankColor;
		info.tankInitPosition = this.tankInitPosition;
		info.tankInitRotation = this.tankInitRotation;
		info.bullet = this.bullet.Clone() as BulletInfo;
		info.SetCurrBlood(this.currBlood);
		return info;
	}

	public void SetCurrBlood(int blood) { // 设置当前血量
		currBlood = blood;
	}

	public int GetCurrBlood() { // 获取当前血量
		return currBlood;
	}

	public int GetFullBlood() { // 获取满血量
		return fullBlood;
	}

	public float BuckleBlood(int damage) { // 扣血, 返回剩余血量比例
		currBlood = Math.Max(currBlood - damage, 0);
		return 1.0f * currBlood / fullBlood;
	}

	public bool IsDying() {
		return currBlood == 0;
	}

	public String GetName() {
		return name;
	}
}

        BulletInfo.cs

using System;
using UnityEngine;

[Serializable]
public class BulletInfo : ICloneable {
	[Header("炮弹伤害")]
	[Range(2, 10)]
	public int bulletDamage = 2;

	[Header("炮弹飞行速度")]
	[Range(5, 20)]
	public int bulletSpeed = 10;

	[Header("炮弹冷却时间")]
	[Range(0.1f, 1.5f)]
	public float bulletCoolTime = 0.3f;

	[Header("炮弹射程")]
	[Range(5, 15)]
	public float bulletFireRange = 10;

	[Header("炮弹颜色")]
	public Color bulletColor = Color.red;

	private String name = "EnemyBullet"; // 炮弹名

	private Vector3 flyDir; // 炮弹飞行方向

	public BulletInfo(String name) {
		this.name = name;
	}

	public void SetFlyDir(Vector3 flyDir) {
		this.flyDir = flyDir;
	}

	public Vector3 GetFlyDir() {
		return flyDir;
	}

	public String GetName() {
		return name;
	}

	public object Clone() { // 克隆炮弹
		BulletInfo info = new BulletInfo(this.name);
		info.bulletDamage = this.bulletDamage;
		info.bulletSpeed = this.bulletSpeed;
		info.bulletCoolTime = this.bulletCoolTime;
		info.bulletFireRange = this.bulletFireRange;
		info.bulletColor = this.bulletColor;
		return info;
	}
}

        EnemiesInfo.cs

using UnityEngine;

public class EnemiesInfo {
	public const int TOTAL_NUM = 50; // 敌人总数
	public const int INIT_NUM = 10; // 敌人初始入场个数
	public const int ENTER_INTERVAL = 2; // 敌人入场时间间隔

	public const int LEVEL_1_WEIGHT = 3; // 一级敌人个数权重
	public const int LEVEL_2_WEIGHT = 2; // 二级敌人个数权重
	public const int LEVEL_3_WEIGHT = 1; // 三级敌人个数权重

	private volatile int appeardNum = 0; // 已入场的敌人数
	private volatile int currentNum = 0; // 当前敌人数
	private int totalWeight; // 总权重

	public EnemiesInfo() {
		totalWeight = LEVEL_1_WEIGHT + LEVEL_2_WEIGHT + LEVEL_3_WEIGHT;
	}

	public void CurrAdd() {
		lock(this) {
			appeardNum ++;
			currentNum ++;
		}
	}

	public void CurrDes() {
		lock(this) {
			currentNum --;
		}
	}

	public int GetRandomLevel() {
		float random = Random.Range(0f, totalWeight);
		if (random < LEVEL_1_WEIGHT) {
			return 1;
		}
		if (random < LEVEL_1_WEIGHT + LEVEL_2_WEIGHT) {
			return 2;
		}
		return 3;
	}

	public int GetAppeardNum() {
		return appeardNum;
	}

	public int GetTotalNum() {
		return TOTAL_NUM;
	}
}

        TankParamsManager.cs

using UnityEngine;

public class TankParamsManager {
	private const int MIN_ENEMY_LEVEL = 1;
	private const int MAX_ENEMY_LEVEL = 3;
	private static TankParamsManager tankParamsManager;
	private TankInfo LEVEL_0 = new TankInfo("Player"); // 玩家
	private TankInfo LEVEL_1 = new TankInfo("Enemy"); // 敌军1级
	private TankInfo LEVEL_2 = new TankInfo("Enemy"); // 敌军2级
	private TankInfo LEVEL_3 = new TankInfo("Enemy"); // 敌军3级

	private TankParamsManager() {
		Level0Params();
		Level1Params();
		Level2Params();
		Level3Params();
	}

	public static TankParamsManager GetInstance() {
		if (tankParamsManager == null) {
			tankParamsManager = new TankParamsManager();
		}
		return tankParamsManager;
	}

	public TankInfo GetPlayerTankInfo() {
		return LEVEL_0.Clone() as TankInfo;
	}

	public TankInfo GetEnemyTankInfo(int level) {
		level = Camp(level, MIN_ENEMY_LEVEL, MAX_ENEMY_LEVEL);
		switch (level) {
			case 1:
				return LEVEL_1.Clone() as TankInfo;
			case 2:
				return LEVEL_2.Clone() as TankInfo;
			case 3:
				return LEVEL_3.Clone() as TankInfo;
		}
		return LEVEL_1;
	}

	private void Level0Params() {
		LEVEL_0.fullBlood = 500;
		// LEVEL_0.fullBlood = 2;
		LEVEL_0.tankColor = Color.green;
		LEVEL_0.tankMoveSpeed = 4;
		LEVEL_0.tankRotateSpeed = 2;
		LEVEL_0.SetCurrBlood(LEVEL_0.fullBlood);
		LEVEL_0.bullet.bulletDamage = 10;
		LEVEL_0.bullet.bulletColor = Color.red;
		LEVEL_0.bullet.bulletCoolTime = 0.15f;
		LEVEL_0.bullet.bulletFireRange = 15;
		LEVEL_0.bullet.bulletSpeed = 10;
	}

	private void Level1Params() {
		LEVEL_1.fullBlood = 30;
		LEVEL_1.tankColor = Color.gray;
		LEVEL_1.tankMoveSpeed = 1;
		LEVEL_1.tankRotateSpeed = 0.85f;
		LEVEL_1.SetCurrBlood(LEVEL_1.fullBlood);
		LEVEL_1.bullet.bulletDamage = 2;
		LEVEL_1.bullet.bulletColor = Color.gray;
		LEVEL_1.bullet.bulletCoolTime = 2f;
		LEVEL_1.bullet.bulletFireRange = 10;
		LEVEL_1.bullet.bulletSpeed = 5;
	}

	private void Level2Params() {
		LEVEL_2.fullBlood = 40;
		LEVEL_2.tankColor = Color.cyan;
		LEVEL_2.tankMoveSpeed = 1.3f;
		LEVEL_2.tankRotateSpeed = 0.9f;
		LEVEL_2.SetCurrBlood(LEVEL_2.fullBlood);
		LEVEL_2.bullet.bulletDamage = 3;
		LEVEL_2.bullet.bulletColor = Color.gray;
		LEVEL_2.bullet.bulletCoolTime = 1.7f;
		LEVEL_2.bullet.bulletFireRange = 11;
		LEVEL_2.bullet.bulletSpeed = 6;
	}

	private void Level3Params() {
		LEVEL_3.fullBlood = 50;
		LEVEL_3.tankColor = Color.yellow;
		LEVEL_3.tankMoveSpeed = 1.6f;
		LEVEL_3.tankRotateSpeed = 1f;
		LEVEL_3.SetCurrBlood(LEVEL_3.fullBlood);
		LEVEL_3.bullet.bulletDamage = 4;
		LEVEL_3.bullet.bulletColor = Color.yellow;
		LEVEL_3.bullet.bulletCoolTime = 1.4f;
		LEVEL_3.bullet.bulletFireRange = 12;
		LEVEL_3.bullet.bulletSpeed = 7;
	}

	private int Camp(int value, int min, int max) {
		if (value > max) {
			return max;
		}
		if (value < min) {
			return min;
		}
		return value;
	}
}

        WindowController.cs

using UnityEngine;

public class WindowController : MonoBehaviour {
	private bool fullscreen = true; // 全屏

	private void Update () {
		if (Input.GetKeyDown(KeyCode.Escape)) {
			fullscreen = !fullscreen;
			Screen.fullScreen = fullscreen;
		}
		if (Input.GetKeyDown(KeyCode.Q)) {
			Application.Quit();
		}
	}
}

        说明：WindowController 脚本组件挂在 Window 游戏对象上。 

6 运行效果

今天的文章【Unity3D】Tank大战分享到此就结束了，感谢您的阅读。