• Unity_Demo | 中世纪风3D-RPG游戏

    ❥ 由于大三期末N个大课设轮番轰炸，停下了手里的好多事。

    故时隔一月余久，我又去继续催化RPG小游戏Demo了。

    ❥ 此次短暂优化之后，基本的战斗系统、对话系统和背包系统已具雏形，

    画面渲染也较为惹眼舒适了。

    ❥ 不知不觉，实习已近一月，在mentor的指导和同事的帮助下，成功接手并完成了一些开发业务单，明天开始为期两周左右的GameJam了，暂且搁置这一Demo探索。

    ❥ 等新鲜的-科技风-元素塔防出炉之后，再来和大家分享可以试玩的作品。

    ❥ 先有蛋还是先有鸡？反正先发B站才方便插视频URL hh~

    RPG小Demo_哔哩哔哩_视频链接

    ⭐️部分场景展示：

    ⭐️项目的架构大致如下：

    在此次的 Demo 制作中，借用了 Unity Asset Store 的一些免费资源，效果还是不错的

    比如下面这个 Free SkyBox，可以呈现一个基础的3D天空场景 

    其实还是比较 beautiful 的对不对？ 这样的对目前来说其实也够用了

    将 Materials 中的 Skybox 拖进 Hierarchy 中即可产生效果，主要是Unity的版本要 > 2019.4.0 

    在初步制作的时候，我们需要在基础之上对一些 Bug 进行纠错 (主要是效果展现上的差距和程序上的不完善)，最终不断丰富我们的表现效果。

    要考虑的东西有很多：

    ⭐️比如如何设计角色移动和攻击方式 (在 Unity 客户端中，可以像我一样利用鼠标响应，点击即立刻前往，点击并拖拽光标能朝着光标拖拽的方向即时丝滑移动。当停止移动并在攻击范围之内，即可点击敌人进行攻击。移动Move() 与 攻击Combat() 的细节逻辑处理也是一个重要的东西，是利用了混合树结合代码逻辑解决的)；

    ⭐️比如死亡的对象要进行销毁，使它不再具有物理意义，也要注意不要让死亡的NPC跟随我们的角色移动，避免造成一种混乱的现象。

    ⭐️比如一个有地势差异的比较大的场景混合各种小场景，如何比较好的处理角色能否移动，这个时候我们就要利用 Bake烘焙 辅助处理，通过控制 Navigation 中 Bake 的属性值来准确控制表现效果，如下图：

    NavMesh 与 Bake 具体可以参考下面两篇文章：

    Unity | 深入了解NavMeshAgent_米莱虾的博客-CSDN博客_navmeshagent 详解

    Unity | Navmesh自动寻路运行报错分析与解决方案_米莱虾的博客-CSDN博客

    ⭐️比如我们如何将视角绑定在角色身上或者别的想要被绑定的 target 上，这就要用到跟随相机，在 Camera 下挂载 Follow Camera，将 Follow Camera 调整到距离 target 合适的位置上并且与我们的目标绑定(挂载)，从而达到一个视角跟随主人公移动的效果，但其实没几行代码...

    1. using System.Collections;
    2. using System.Collections.Generic;
    3. using UnityEngine;
    4.  
    5. namespace RPG.Core
    6. {
    7.     public class FollowCamera : MonoBehaviour
    8.     {
    9.         [SerializeField] Transform target;
    10.  
    11.         void LateUpdate()
    12.         {
    13.             transform.position = target.position;
    14.         }
    15.     }
    16. }

    其他一些具体的细节以及优化有机会再和大家分享，下面呈现部分重要的代码

    ⭐️Fighter.cs (主要是我们角色战斗逻辑的一些处理)

    1. using UnityEngine;
    2. using RPG.Movement;
    3. using RPG.Core;
    4. using GameDevTV.Saving;
    5. using RPG.Attributes;
    6. using RPG.Stats;
    7. using System.Collections.Generic;
    8. using GameDevTV.Utils;
    9. using System;
    10. using GameDevTV.Inventories;
    11.  
    12. namespace RPG.Combat
    13. {
    14.     public class Fighter : MonoBehaviour, IAction
    15.     {
    16.         [SerializeField] float timeBetweenAttacks = 1f;
    17.         [SerializeField] Transform rightHandTransform = null;
    18.         [SerializeField] Transform leftHandTransform = null;
    19.         [SerializeField] WeaponConfig defaultWeapon = null;
    20.         [SerializeField] float autoAttackRange = 4f;
    21.  
    22.         Health target;
    23.         Equipment equipment;
    24.         float timeSinceLastAttack = Mathf.Infinity;
    25.         WeaponConfig currentWeaponConfig;
    26.         LazyValue currentWeapon;
    27.  
    28.         private void Awake() {
    29.             currentWeaponConfig = defaultWeapon;
    30.             currentWeapon = new LazyValue(SetupDefaultWeapon);
    31.             equipment = GetComponent();
    32.             if (equipment)
    33.             {
    34.                 equipment.equipmentUpdated += UpdateWeapon;
    35.             }
    36.         }
    37.  
    38.         private Weapon SetupDefaultWeapon()
    39.         {
    40.             return AttachWeapon(defaultWeapon);
    41.         }
    42.  
    43.         private void Start() 
    44.         {
    45.             currentWeapon.ForceInit();
    46.         }
    47.  
    48.         private void Update()
    49.         {
    50.             timeSinceLastAttack += Time.deltaTime;
    51.  
    52.             if (target == null) return;
    53.             if (target.IsDead()) 
    54.             {
    55.                 target = FindNewTargetInRange();
    56.                 if (target == null) return;
    57.             }
    58.  
    59.             if (!GetIsInRange(target.transform))
    60.             {
    61.                 GetComponent().MoveTo(target.transform.position, 1f);
    62.             }
    63.             else
    64.             {
    65.                 GetComponent().Cancel();
    66.                 AttackBehaviour();
    67.             }
    68.         }
    69.  
    70.         public void EquipWeapon(WeaponConfig weapon)
    71.         {
    72.             currentWeaponConfig = weapon;
    73.             currentWeapon.value = AttachWeapon(weapon);
    74.         }
    75.  
    76.         private void UpdateWeapon()
    77.         {
    78.             var weapon = equipment.GetItemInSlot(EquipLocation.Weapon) as WeaponConfig;
    79.             if (weapon == null)
    80.             {
    81.                 EquipWeapon(defaultWeapon);
    82.             }
    83.             else
    84.             {
    85.                 EquipWeapon(weapon);
    86.             }
    87.         }
    88.  
    89.         private Weapon AttachWeapon(WeaponConfig weapon)
    90.         {
    91.             Animator animator = GetComponent();
    92.             return weapon.Spawn(rightHandTransform, leftHandTransform, animator);
    93.         }
    94.  
    95.         public Health GetTarget()
    96.         {
    97.             return target;
    98.         } 
    99.  
    100.         public Transform GetHandTransform(bool isRightHand)
    101.         {
    102.             if (isRightHand)
    103.             {
    104.                 return rightHandTransform;
    105.             }
    106.             else
    107.             {
    108.                 return leftHandTransform;
    109.             }
    110.         }
    111.  
    112.         private void AttackBehaviour()
    113.         {
    114.             transform.LookAt(target.transform);
    115.             if (timeSinceLastAttack > timeBetweenAttacks)
    116.             {
    117.                 // This will trigger the Hit() event.
    118.                 TriggerAttack();
    119.                 timeSinceLastAttack = 0;
    120.             }
    121.         }
    122.  
    123.         private Health FindNewTargetInRange()
    124.         {
    125.             Health best = null;
    126.             float bestDistance = Mathf.Infinity;
    127.             foreach (var candidate in FindAllTargetsInRange())
    128.             {
    129.                 float candidateDistance = Vector3.Distance(
    130.                     transform.position, candidate.transform.position);
    131.                 if (candidateDistance < bestDistance)
    132.                 {
    133.                     best = candidate;
    134.                     bestDistance = candidateDistance;
    135.                 }
    136.             }
    137.             return best;
    138.         }
    139.  
    140.         private IEnumerable FindAllTargetsInRange()
    141.         {
    142.             RaycastHit[] raycastHits = Physics.SphereCastAll(transform.position,
    143.                                                 autoAttackRange, Vector3.up);
    144.             foreach (var hit in raycastHits)
    145.             {
    146.                 Health health = hit.transform.GetComponent();
    147.                 if (health == null) continue;
    148.                 if (health.IsDead()) continue;
    149.                 if (health.gameObject == gameObject) continue;
    150.                 yield return health;
    151.             }
    152.         }
    153.  
    154.         private void TriggerAttack()
    155.         {
    156.             GetComponent().ResetTrigger("stopAttack");
    157.             GetComponent().SetTrigger("attack");
    158.         }
    159.  
    160.         // Animation Event
    161.         void Hit()
    162.         {
    163.             if(target == null) { return; }
    164.  
    165.             float damage = GetComponent().GetStat(Stat.Damage);
    166.             BaseStats targetBaseStats = target.GetComponent();
    167.             if (targetBaseStats != null)
    168.             {
    169.                 float defence = targetBaseStats.GetStat(Stat.Defence);
    170.                 damage /= 1 + defence / damage;
    171.             }
    172.  
    173.             if (currentWeapon.value != null)
    174.             {
    175.                 currentWeapon.value.OnHit();
    176.             }
    177.  
    178.             if (currentWeaponConfig.HasProjectile())
    179.             {
    180.                 currentWeaponConfig.LaunchProjectile(rightHandTransform, leftHandTransform, target, gameObject, damage);
    181.             }
    182.             else
    183.             {
    184.                 target.TakeDamage(gameObject, damage);
    185.             }
    186.         }
    187.  
    188.         void Shoot()
    189.         {
    190.             Hit();
    191.         }
    192.  
    193.         private bool GetIsInRange(Transform targetTransform)
    194.         {
    195.             return Vector3.Distance(transform.position, targetTransform.position) < currentWeaponConfig.GetRange();
    196.         }
    197.  
    198.         public bool CanAttack(GameObject combatTarget)
    199.         {
    200.             if (combatTarget == null) { return false; }
    201.             if (!GetComponent().CanMoveTo(combatTarget.transform.position) &&
    202.                 !GetIsInRange(combatTarget.transform)) 
    203.             {
    204.                 return false; 
    205.             }
    206.             Health targetToTest = combatTarget.GetComponent();
    207.             return targetToTest != null && !targetToTest.IsDead();
    208.         }
    209.  
    210.         public void Attack(GameObject combatTarget)
    211.         {
    212.             GetComponent().StartAction(this);
    213.             target = combatTarget.GetComponent();
    214.         }
    215.  
    216.         public void Cancel()
    217.         {
    218.             StopAttack();
    219.             target = null;
    220.             GetComponent().Cancel();
    221.         }
    222.  
    223.         private void StopAttack()
    224.         {
    225.             GetComponent().ResetTrigger("attack");
    226.             GetComponent().SetTrigger("stopAttack");
    227.         }
    228.     }
    229. }

    ⭐️PlayerController.cs (主要是我们角色控制逻辑的一些处理，包括角色的自动寻路、和UI的交互、技能、和组件的交互、移动的交互、射线投射...)

    1. using RPG.Combat;
    2. using RPG.Movement;
    3. using UnityEngine;
    4. using RPG.Attributes;
    5. using System;
    6. using UnityEngine.EventSystems;
    7. using UnityEngine.AI;
    8. using GameDevTV.Inventories;
    9.  
    10. namespace RPG.Control
    11. {
    12.     public class PlayerController : MonoBehaviour
    13.     {
    14.         Health health;
    15.         ActionStore actionStore;
    16.  
    17.         [System.Serializable]
    18.         struct CursorMapping
    19.         {
    20.             public CursorType type;
    21.             public Texture2D texture;
    22.             public Vector2 hotspot;
    23.         }
    24.  
    25.         [SerializeField] CursorMapping[] cursorMappings = null;
    26.         [SerializeField] float maxNavMeshProjectionDistance = 1f;
    27.         [SerializeField] float raycastRadius = 1f;
    28.         [SerializeField] int numberOfAbilities = 6;
    29.  
    30.         bool isDraggingUI = false;
    31.  
    32.         private void Awake() {
    33.             health = GetComponent();
    34.             actionStore = GetComponent();
    35.         }
    36.  
    37.         private void Update()
    38.         {
    39.             if (InteractWithUI()) return;
    40.             if (health.IsDead()) 
    41.             {
    42.                 SetCursor(CursorType.None);
    43.                 return;
    44.             }
    45.  
    46.             UseAbilities();
    47.  
    48.             if (InteractWithComponent()) return;
    49.             if (InteractWithMovement()) return;
    50.  
    51.             SetCursor(CursorType.None);
    52.         }
    53.  
    54.         private bool InteractWithUI()
    55.         {
    56.             if (Input.GetMouseButtonUp(0))
    57.             {
    58.                 isDraggingUI = false;
    59.             }
    60.             if (EventSystem.current.IsPointerOverGameObject())
    61.             {
    62.                 if (Input.GetMouseButtonDown(0))
    63.                 {
    64.                     isDraggingUI = true;
    65.                 }
    66.                 SetCursor(CursorType.UI);
    67.                 return true;
    68.             }
    69.             if (isDraggingUI)
    70.             {
    71.                 return true;
    72.             }
    73.             return false;
    74.         }
    75.  
    76.         private void UseAbilities()
    77.         {
    78.             for (int i = 0; i < numberOfAbilities; i++)
    79.             {
    80.                 if (Input.GetKeyDown(KeyCode.Alpha1 + i))
    81.                 {
    82.                     actionStore.Use(i, gameObject);
    83.                 }
    84.             }
    85.         }
    86.  
    87.         private bool InteractWithComponent()
    88.         {
    89.             RaycastHit[] hits = RaycastAllSorted();
    90.             foreach (RaycastHit hit in hits)
    91.             {
    92.                 IRaycastable[] raycastables = hit.transform.GetComponents();
    93.                 foreach (IRaycastable raycastable in raycastables)
    94.                 {
    95.                     if (raycastable.HandleRaycast(this))
    96.                     {
    97.                         SetCursor(raycastable.GetCursorType());
    98.                         return true;
    99.                     }
    100.                 }
    101.             }
    102.             return false;
    103.         }
    104.  
    105.         RaycastHit[] RaycastAllSorted()
    106.         {
    107.             RaycastHit[] hits = Physics.SphereCastAll(GetMouseRay(), raycastRadius);
    108.             float[] distances = new float[hits.Length];
    109.             for (int i = 0; i < hits.Length; i++)
    110.             {
    111.                 distances[i] = hits[i].distance;
    112.             }
    113.             Array.Sort(distances, hits);
    114.             return hits;
    115.         }
    116.  
    117.         private bool InteractWithMovement()
    118.         {
    119.             Vector3 target;
    120.             bool hasHit = RaycastNavMesh(out target);
    121.             if (hasHit)
    122.             {
    123.                 if (!GetComponent().CanMoveTo(target)) return false;
    124.  
    125.                 if (Input.GetMouseButton(0))
    126.                 {
    127.                     GetComponent().StartMoveAction(target, 1f);
    128.                 }
    129.                 SetCursor(CursorType.Movement);
    130.                 return true;
    131.             }
    132.             return false;
    133.         }
    134.  
    135.         private bool RaycastNavMesh(out Vector3 target)
    136.         {
    137.             target = new Vector3();
    138.  
    139.             RaycastHit hit;
    140.             bool hasHit = Physics.Raycast(GetMouseRay(), out hit);
    141.             if (!hasHit) return false;
    142.  
    143.             NavMeshHit navMeshHit;
    144.             bool hasCastToNavMesh = NavMesh.SamplePosition(
    145.                 hit.point, out navMeshHit, maxNavMeshProjectionDistance, NavMesh.AllAreas);
    146.             if (!hasCastToNavMesh) return false;
    147.  
    148.             target = navMeshHit.position;
    149.  
    150.             return true;
    151.         }
    152.  
    153.         private void SetCursor(CursorType type)
    154.         {
    155.             CursorMapping mapping = GetCursorMapping(type);
    156.             Cursor.SetCursor(mapping.texture, mapping.hotspot, CursorMode.Auto);
    157.         }
    158.  
    159.         private CursorMapping GetCursorMapping(CursorType type)
    160.         {
    161.             foreach (CursorMapping mapping in cursorMappings)
    162.             {
    163.                 if (mapping.type == type)
    164.                 {
    165.                     return mapping;
    166.                 }
    167.             }
    168.             return cursorMappings[0];
    169.         }
    170.  
    171.         public static Ray GetMouseRay()
    172.         {
    173.             return Camera.main.ScreenPointToRay(Input.mousePosition);
    174.         }
    175.     }
    176. }

  • 相关阅读:
    [Rust笔记] 代码写明 Rust 中的泛型型变
    实验七 团队作业4：团队项目需求建模与系统设计
    三十多年前 钱学森给虚拟现实技术取了一个名
    Maven的生命周期
    [LeetCode304周赛] 两道关于基环树的题 6134. 找到离给定两个节点最近的节点，6135. 图中的最长环
    哈工大操作系统实验环境安装
    chatgpt赋能python：Python操作表格的全面指南
    剑指 Offer 10- II. 青蛙跳台阶问题【力扣】
    opencv 形态学转换
    Spark实现二次排序
  • 原文地址：https://blog.csdn.net/Luoxiaobaia/article/details/125865286