devbox
很楠不爱3
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

使用团结引擎开发Unity 3D射击游戏_unity团结引擎

作者：很楠不爱3 | 2024-02-27 11:04:58

赞

踩

unity团结引擎

一、前言

       本案例是初级案例，意在引导想使用unity的初级开发者能较快的入门，体验unity开发的方便性和简易性能。

      本次我们将使用团结引擎进行开发，帮助想体验团结引擎的入门开发者进行较快的环境熟悉。

     本游戏是一个俯视角度的射击游戏。主角始终位于屏幕中心位置，玩家使用键盘控制主角移动，并可开枪射击场景中的敌人。玩家具有多种武器，如手枪、霰弹枪和自动步枪，玩家可以切换武器。敌人也会向玩家方向移动并射击玩家。当玩家角色或敌人的生命值减为零时则死亡。当玩家死亡后，游戏结束。

二、开发环境

        操作系统：Windows

        Unity 版本：团结引擎1.0.0

        团结引擎的安装参考《团结引擎的安装》

三、场景搭建

     3.1 创建项目

        使用团结引擎新建项目和使用Unity Hub一样。打开Tuanjie Hub，点击左上角【create project】按钮，选择【3D】模版，输入项目名称和项目保存路径，点击右下【Create project】按钮完成创建。

         3.2 搭建场景

        1. 我们创建一个plane作为地面 。在Hierarchy面板上依次【右键】-> 【3D Object】->【plane】，将【Plane】创命名为【Ground】，并将x、z缩放大小变为4。我们将地面颜色改成灰色。新建文件夹，命名为【Materals】用来存放材质。在材质文件夹右键，依次选择【Create】->【Material】, 并命名为【Ground】。修改材质颜色为灰色（颜色值：4B4747），并将材质拖拽到地面上。

        2. 同样， 我们创建一个胶囊体（Capsule）来作为主角，并命名为Player。创建一个立方体（Cube）放置在Player上，并调整到合适的位置。Cube将作为Player的正面，以便分辨方向。创建一个材质，命名为Face，改变材质样色为蓝色（也可以设置成自己喜欢的颜色），然后把这个材质赋值给Cube。

        3.  调整摄像机角度

        由于我们是俯视角度的射击游戏，因此需要调整摄像机的位置。选中摄像机，将摄像机调整到Player后方合适的位置。

        4. 创建敌人 

        敌人角色与玩家角色造型基本一致，只是将白色换成红色。我们复制场景中的Player（选中Player, 按 ctrl + D），命名为Enermy。然后创建一个材质Enermy, 然后将材质的颜色改为红色。把材质赋给场景中的Enermy物体。新建标签（Tag），命名为Enermy，将玩家Player的Tag设置为“Player”， Enermy 的Tag设置为“Enermy”，方便区分玩家和敌人。之后我们新建文件夹，命名为 Prefabs，将Enermy制作成预知体（直接把Hierarchy中的Enermy物体拖到Prefabs文件夹中）。

 四、编写脚本，实现功能

        上面基本场景已经搭建完毕，接下来我们就开始编写脚本，实现我们的游戏功能。

        4.1 让玩家动起来

        首先，我们来编写玩家脚本，让玩家动起来。新建文件夹，命名为【Scripts】，用来保存我自己编写的脚本文件。在【Scripts】右键->【Create】->【C# Script】，命名为Player。然后将Player脚本挂载到Player物体上。

         和《3D小球跑酷》类似，我们使用键盘来控制Player的移动。双击打开Player脚本，输入以下内容：

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class Player : MonoBehaviour
  6. {
  7.     public float speed = 10f;  // 玩家的移动速度
  8.     public int maxHp = 10;    // 玩家的最大血量
  9.  
  10.  
  11.     private int hp;      // 玩家的当前血量
  12.     private bool idDead = false;
  13.  
  14.  
  15.  
  16.     void Start()
  17.     {
  18.         hp = maxHp;  // 初始血量为最大值
  19.     }
  20.  
  21.     void Update()
  22.     {
  23.         if (!idDead)
  24.         {
  25.             Move();
  26.         }
  27.     }
  28.  
  29.     void Move()
  30.     {
  31.         var input = new Vector3(Input.GetAxis("Horizontal"), 0, Input.GetAxis("Vertical"));  // 接受键盘输入
  32.         input = input.normalized;
  33.         Vector3 currentPos = transform.position;
  34.         currentPos += input * speed * Time.deltaTime;
  35.  
  36.         if (input.magnitude > 0.1f)
  37.         {
  38.             transform.forward = input;   // 使玩家面向移动方向
  39.         }
  40.  
  41.         // 限制玩家的移动范围，范围为方圆20以内
  42.         const float distance = 20f;
  43.  
  44.         if (currentPos.x > distance)
  45.             currentPos.x = distance;
  46.  
  47.         if (currentPos.x < -distance)
  48.             currentPos.x = -distance;
  49.  
  50.         if(currentPos.z > distance)
  51.             currentPos.z = distance;
  52.  
  53.         if(currentPos.z < -distance)
  54.             currentPos.z = -distance;
  55.  
  56.         transform.position = currentPos;
  57.     }
  58. }

        保存脚本，运行游戏，按键盘上的方向键或者A、D、S、W键，可以看到Player朝着指定的方向移动起来了。

注意：

        以上移动方式没有考虑阻挡，为放置玩家或者敌人移动到地面的边缘掉下去，我们使用了简单的方式来限定他们的可移动范围。

      4.2 相机跟随

        运行游戏，发现Player在移动时，相机是固定的。下面我们把相机改为随着Player移动而移动。在《3D小球跑酷》我们采用的是把相机直接作为Player的子物体的方式，这里我们采用另一中方式（当然，你也可以使用作为子物体的方式），就是编写相机跟随脚本。

        在Scripts文件夹下新建C#脚本，命名为FlowCamera。将脚本挂在到Camera上，双击打开脚本，输入以下代码：

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class FlowCamera : MonoBehaviour
  6. {
  7.     public Transform target;
  8.  
  9.     Vector3 offset;
  10.  
  11.     
  12.     void Start()
  13.     {
  14.         offset = transform.position - target.position;
  15.     }
  16.  
  17.     
  18.     void Update()
  19.     {
  20.         transform.position = target.position + offset ;
  21.     }
  22. }

        将Player物体拖拽到脚本参数target字段。保存再次运行游戏，发现相机已经可以跟随Player移动了。

      4.3 制作子弹

        创建一个球体，大小缩放为0.2倍。命名为Bullet， 这将作为我们发射的子弹。新建脚本Bullet,将脚本挂在到Bullet物体上。双击打开脚本，输入以下内容：

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class Bullet : MonoBehaviour
  6. {
  7.     public float lifeTime = 2f; // 子弹的生命周期
  8.     public float speed = 10f;  // 子弹的飞行速度
  9.  
  10.     float startTime; // 子弹的生成时间
  11.  
  12.  
  13.     // Start is called before the first frame update
  14.     void Start()
  15.     {
  16.         startTime = Time.time;
  17.     }
  18.  
  19.     // Update is called once per frame
  20.     void Update()
  21.     {
  22.         transform.position += speed * transform.forward * Time.deltaTime;
  23.  
  24.         // 超过一定时间后
  25.         if (startTime + lifeTime < Time.time)
  26.         { 
  27.             Destroy(gameObject); // 销毁子弹
  28.         }
  29.     }
  30.  
  31.     
  32. }

        将球体拖到Prefabs文件夹，做成预制体。

      4.4 实现武器系统

        下面我们实现一下Player切换武器的功能，这是我们游戏的一个重要功能。我们按Q键可以切换武器。武器有三种，分别是手枪（Pistol），自动步枪（Rifle）和散弹枪（shotgun）。

        新建脚本，命名为Weapon。双击打开脚本，输入以下内容：

  1. using System;
  2. using System.Collections;
  3. using System.Collections.Generic;
  4. using UnityEngine;
  5.  
  6. public class Weapon : MonoBehaviour
  7. {
  8.     public GameObject bulletPrefab;  // 子弹预制体
  9.  
  10.     public float pistolFireCD = 0.2f; // 手枪发射子弹的时间间隔
  11.     public float rifleFireCD = 0.1f;  // 自动步枪发射子弹的时间间隔
  12.     public float shotgunFireCD = 0.5f; // 散弹枪发射子弹的时间间隔
  13.  
  14.     float lastFireTime; // 上次开火时间
  15.  
  16.     public int curGun;  //当前使用的武器 0：手枪  1：自动步枪  2：散弹枪
  17.  
  18.     // 开火方法，由角色脚本调用, keyDown 表示按一下就发射一颗子弹， keyPressed 表示长按
  19.     public void Fire(bool keyDown, bool keyPressed)
  20.     {
  21.         switch (curGun)
  22.         {
  23.             case 0:
  24.                 if (keyDown)
  25.                 {
  26.                     PistolFire();
  27.                 }
  28.                 break;
  29.             case 1:
  30.                 if (keyDown)
  31.                 {
  32.                     ShotgunFire();
  33.                 }
  34.                 break;
  35.             case 2:
  36.                 if (keyPressed)
  37.                 {
  38.                     RifleFire();
  39.                 }
  40.                 break;
  41.             default:
  42.                 break;
  43.         }
  44.     }
  45.  
  46.     // 更换武器
  47.     public int ChangWeapon()
  48.     {
  49.         curGun += 1;
  50.         if (curGun >= 3)
  51.             curGun = 0;
  52.  
  53.         return curGun;
  54.     }
  55.  
  56.     // 手枪射击
  57.     private void PistolFire()
  58.     {
  59.         // 子弹发射时间间隔判定
  60.         if (lastFireTime + pistolFireCD > Time.time)
  61.         {
  62.             return;
  63.         }
  64.  
  65.         lastFireTime = Time.time;
  66.  
  67.         GameObject bullet = GameObject.Instantiate(bulletPrefab);
  68.         bullet.transform.position = transform.position + transform.forward * 1.0f;  // 子弹的位置，位于角色前方1米
  69.         bullet.transform.forward = transform.forward;  // 子弹的方向
  70.  
  71.     }
  72.  
  73.     // 自动步枪射击
  74.     private void RifleFire()
  75.     {
  76.         // 子弹发射时间间隔判定
  77.         if (lastFireTime + rifleFireCD > Time.time)
  78.         {
  79.             return;
  80.         }
  81.  
  82.         lastFireTime = Time.time;
  83.  
  84.         GameObject bullet = GameObject.Instantiate(bulletPrefab);
  85.         bullet.transform.position = transform.position + transform.forward * 1.0f;  // 子弹的位置，位于角色前方1米
  86.         bullet.transform.forward = transform.forward;  // 子弹的方向
  87.     }
  88.  
  89.     // 散弹枪射击,一次发射5颗子弹，子弹间隔10
  90.     private void ShotgunFire()
  91.     {
  92.         // 子弹发射时间间隔判定
  93.         if (lastFireTime + shotgunFireCD > Time.time)
  94.         {
  95.             return;
  96.         }
  97.  
  98.         lastFireTime = Time.time;
  99.  
  100.         for (int i = -2; i <= 2; i++)
  101.         {
  102.             GameObject bullet = GameObject.Instantiate(bulletPrefab);
  103.             var dir = Quaternion.Euler(0, i * 10, 0) * transform.forward;
  104.  
  105.             bullet.transform.position = transform.position + dir * 1.0f;  // 子弹的位置，位于角色前方1米
  106.             bullet.transform.forward = dir;  // 子弹的方向
  107.         }
  108.     }
  109. }

        修改Player脚本调用武器系统，使角色发射子弹。

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class Player : MonoBehaviour
  6. {
  7.     ......
  8.  
  9.     // 声明武器对象
  10.     private Weapon weapon;
  11.  
  12.     void Start()
  13.     {
  14.         hp = maxHp;  // 初始血量为最大值
  15.         weapon = GetComponent<Weapon>();  // 获取武器对象
  16.     }
  17.  
  18.     void Update()
  19.     {
  20.         if (!idDead)
  21.         {
  22.             Move();
  23.             Fire();  // 开火，发射子弹
  24.             ChangeWeapon(); // 切换武器
  25.         }
  26.     }
  27.  
  28.     void Move()
  29.     {
  30.         ......
  31.     }
  32.  
  33.     void Fire()
  34.     {
  35.         bool keyDown = Input.GetKeyDown(KeyCode.J);
  36.         bool keyPressed = Input.GetKey(KeyCode.J);
  37.         weapon.Fire(keyDown, keyPressed);
  38.     }
  39.  
  40.     void ChangeWeapon()
  41.     {
  42.         bool changWeapon = Input.GetKeyDown(KeyCode.Q);
  43.         if (changWeapon)
  44.             weapon.ChangWeapon();
  45.     }
  46. }

        将武器脚本（Weapon）挂载到Player物体上，同时把子弹预制体拖到武器脚本的bulletPrefab字段上。保存场景，运行游戏，按Q键可以切换枪支，按J键可以发射子弹。读者可以自行调整玩家的移动速度和子弹的发射速度，以获得更好的游戏体验。

      4.5 实现敌人的脚本

        敌人脚本和Player脚本类似，单敌人会始终朝着玩家前进，并朝着玩家发射子弹。在Scripts文件夹下新建脚本文件，命名为Enermy，并将其挂载到Enermy预制体上。双击打开脚本，输入以下内容：

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class Enermy : MonoBehaviour
  6. {
  7.     private Transform playerTransform;  // player 的 transform 组件
  8.  
  9.     public float speed = 2f;  // 敌人的移动速度
  10.     public int maxHp = 1;    // 敌人的最大血量
  11.  
  12.  
  13.     private int hp;      // 敌人的当前血量
  14.     private bool isDead = false;
  15.  
  16.     private Weapon weapon;
  17.  
  18.     void Start()
  19.     {
  20.         hp = maxHp;  // 初始血量为最大值
  21.         weapon = GetComponent<Weapon>();
  22.         playerTransform = GameObject.Find("Player").transform;
  23.     }
  24.  
  25.     void Update()
  26.     {
  27.         if (!isDead)
  28.         {
  29.             Move();
  30.             Fire();
  31.         }
  32.     }
  33.  
  34.     void Move()
  35.     {
  36.         Vector3 dir = playerTransform.position - transform.position;
  37.         var currentPos = transform.position + dir.normalized * speed * Time.deltaTime;
  38.  
  39.         // 限制敌人的移动范围，范围为方圆20以内
  40.         const float distance = 20f;
  41.  
  42.         if (currentPos.x > distance)
  43.             currentPos.x = distance;
  44.  
  45.         if (currentPos.x < -distance)
  46.             currentPos.x = -distance;
  47.  
  48.         if (currentPos.z > distance)
  49.             currentPos.z = distance;
  50.  
  51.         if (currentPos.z < -distance)
  52.             currentPos.z = -distance;
  53.  
  54.         transform.position = currentPos;
  55.         transform.forward = dir.normalized;
  56.     }
  57.  
  58.     void Fire()
  59.     {
  60.         weapon.Fire(true, true);
  61.     }
  62.  
  63.  
  64. }

        然后，把武器脚本挂载到Enermy预制体上，保存。再场景中放置几个敌人（直接把Enermy预制体拖到场景中即可），运行游戏，发现敌人开始朝着玩家移动，并不断发射子弹。

      4.6 子弹的碰撞逻辑

        虽然现在我们可以控制Player移动，并且能发射子弹，敌人也能够发射子弹，但是子弹碰到敌人或者Player都没有反应，接下来我们就开始添加子弹碰撞的逻辑。

        子弹和物体的碰撞分为以下几种情况：

        1)  Player的子弹击中敌人

        2）敌人的子弹击中Player

        3）玩家的子弹和Player的子弹碰撞

        4）Player的子弹不会击中Player，敌人的子弹也不会击中敌人。

        为了区分敌人子弹和Player的子弹，我们采用标签（Tag）来进行区分。我们新建两个标签，分别为PlayerBullet和EnermyBullet。选中之前的子弹预制体，重命名为PlayerBullet, 并将Tag设置为PlayerBullet。复制PlayerBullet，重命名为EnermyBullet,并将Tag设置为EnermyBullet。

       4.6.1 修改Enermy预制体

       双击Enermy预制体，将脚本Weapon上的BulletPrefab字段设置为EnermyBullet。保存退出。

      4.6.2 修改Bullet脚本

       双击Bullet脚本，添加碰撞逻辑。添加以下代码：

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class Bullet : MonoBehaviour
  6. {
  7.     .....
  8.  
  9.     private void OnTriggerEnter(Collider other)
  10.     {
  11.         if (CompareTag(other.tag))  // 如果子弹的tag和碰撞到的物体的Tag相同
  12.             return;
  13.  
  14.         Destroy(gameObject);
  15.     }
  16.  
  17. }

        4.6.3 修改Player脚本

        当敌人的子弹碰到玩家的时候，玩家血量减1，当血量为0时，玩家死亡，游戏结束。双击打来Player脚本，添加以下代码：

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class Player : MonoBehaviour
  6. {
  7.     ......
  8.  
  9.     private void OnTriggerEnter(Collider other)
  10.     {
  11.         if (other.CompareTag("EnermyBullet"))
  12.         {
  13.             if (hp <= 0) return;
  14.             hp--;
  15.             if (hp <= 0)
  16.             {
  17.                 idDead = true;
  18.                 Debug.Log("Game Over!");
  19.             }
  20.         }
  21.     }
  22. }

        4.6.4 修改Enermy脚本

        当玩家的子弹碰到敌人的时候，敌人血量减1。当敌人的血量为0时，敌人死亡。双击打开Enermy脚本，添加以下代码：

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class Enermy : MonoBehaviour
  6. {
  7.     ......
  8.  
  9.     private void OnTriggerEnter(Collider other)
  10.     {
  11.         if (other.CompareTag("PlayerBullet"))
  12.         {
  13.             if (hp <= 0) return;
  14.             hp--;
  15.             if (hp <= 0)
  16.             {
  17.                 Destroy(gameObject);
  18.             }
  19.         }
  20.     }
  21. }

           保存场景，运行游戏，发现子弹碰撞后并没有什么效果，这是因为我们没有添加刚体，并设置触发器。

        4.6.5 设置触发器

        选中敌人的子弹和Player的子弹的预制体，添加刚体组件（RigidBody），并勾选 Collider 上的Is Trigger 复选框。选择Enermy预制体，并勾选 Collider 上的Is Trigger 复选框。选择Player，并勾选 Collider 上的Is Trigger 复选框。保存场景再次运行游戏，发现Player 被击中之后，血量减少，当血量减少到0是，控制台输出“Game Over”。

        4.7 生成大量敌人

        现在我们的游戏已经初具模型了，单要手动把敌人预制体拖到场景中，如果要有许多敌人就显得太麻烦了，而且拖到场景中的敌人有限，杀完了就没有了。 我们要有一个可以源源不断生成敌人的机制，每隔一段时间就生成一个敌人，这样就可以一直玩下去了。

        在场景中新建一个空物体，命名为EnemySpawn，同时新建脚本文件，也命名为EnemySpawn，并挂载到EnemySpawn物体上。脚本内容如下：

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class EnermySpawn : MonoBehaviour
  6. {
  7.     public GameObject enermyPrefab;
  8.  
  9.     public float spawTimer = 2.0f;
  10.  
  11.     List<GameObject> enermies = new List<GameObject> ();
  12.     
  13.     void Update()
  14.     {
  15.         if (enermies.Count >= 10) return;  // 场景中最多10个敌人
  16.         spawTimer -= Time.deltaTime;
  17.         if (spawTimer <= 0)
  18.         {
  19.             spawTimer = 2.0f;
  20.  
  21.             GameObject enermy = Instantiate(enermyPrefab);
  22.             enermy.transform.position = new Vector3(-20, 1, -20);
  23.         }
  24.     }
  25. }

        保存脚本和场景，运行游戏，发现没隔2秒就会有一个敌人生成，并且场景中最多会有10个敌人，当场景中的敌人数量少于10个时，又会有新的敌人生成出来，这样就可以一直玩下去了。

五、结束语

        好了，射击游戏到这里就结束了，虽然还有很多不足，但作为初学者的练习案例，也用到了许多Unity的基础知识，希望您能够获得一些启发，对您的学习有所帮助。您也可以发挥自己的想想力，完善本案例，比如增加积分、音效等等，使游戏更加丰富。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/152359
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号