devbox
2023面试高手
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

[Untiy2D好项目分享]一个好手感的2D控制器_github unity 2d源码

作者：2023面试高手 | 2024-02-20 05:58:00

赞

踩

github unity 2d源码

学习目标：

今天同样在b站上看到一个转载视频这个Unity角色控制器是使用自定义的物理组件制作的，并包含一些隐藏的平台游戏技巧，让玩家体验到优秀的操作手感。

视频地址：

【Unity】好手感从何而来？一款免费的2D角色控制器，附源码_哔哩哔哩_bilibili来自Youtuber Tarodev中文字幕请开启CC字幕视频内源码: https://github.com/Matthew-J-Spencer/Ultimate-2D-Controller额外付费部分: https://www.patreon.com/tarodev了解如何制作一个优秀的玩家控制器。这个Unity角色控制器是使用自定义的物理组件制作的，并包含一些隐藏的平台游戏技巧，让玩家体验到优https://www.bilibili.com/video/BV14S4y1o79L?spm_id_from=333.851.header_right.history_list.click

源码：GitHub - Matthew-J-Spencer/Ultimate-2D-Controller: A great starting point for your 2D controller. Making use of all the hidden tricks like coyote, buffered actions, speedy apex, anti grav apex, etcA great starting point for your 2D controller. Making use of all the hidden tricks like coyote, buffered actions, speedy apex, anti grav apex, etc - GitHub - Matthew-J-Spencer/Ultimate-2D-Controller: A great starting point for your 2D controller. Making use of all the hidden tricks like coyote, buffered actions, speedy apex, anti grav apex, etchttps://github.com/Matthew-J-Spencer/Ultimate-2D-ControllerTarodev is creating Game dev and programming tutorials | PatreonBecome a patron of Tarodev today: Get access to exclusive content and experiences on the world’s largest membership platform for artists and creators.https://www.patreon.com/tarodev

学习内容：

学习好一个2D控制器源码是至关重要的，本素材中作者直接无需添加任何rigibody2D和Collider2D的组件，而是直接用代码来实现玩家的碰撞检测。

创建好一个Ground(用Tile)然后再将它的Layer设置为Ground

创建一个空对象名字叫Player再创建一个空对象叫Viusal给它Audio Source以及新组件Trail Renderer,当你在移动角色的时候该组件会产生一个细的运动轨迹，再创建一个Sprite并给它Sprite Renderer以及Animator

最后给它一个Particals作为总的管理Partical System的再创建移动跳跃落地所需要的Partical System（具体参数源码有）

搞完这些后即可进入编写代码部分：

首先我们要编写的是一个接口负责监控玩家的键盘输入命令，另外一个结构体FrameInput是负责玩家键盘的xy轴的输入，以及射线检测的结构体RayRange.

可以看到我们并没有继承MonoBehaviour，该脚本不需要作为组件挂载，而是给其它类调用

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. namespace TarController
  6. {
  7.     public struct FrameInput
  8.     {
  9.         public float X;
  10.         public bool JumpDown;
  11.         public bool JumpUp;
  12.     }
  13.     public interface IPlayerInterface
  14.     {
  15.         public FrameInput frameInput { get; }
  16.         public Vector3 Velocity { get; }
  17.         public bool FrameJumped { get; }
  18.         public bool FrameLanded { get; }
  19.         public bool Grounded { get; }
  20.         public Vector3 RawMovement { get; }
  21.  
  22.     }
  23.     public struct RayRange
  24.     {
  25.         public RayRange(float x1,float y1,float x2,float y2,Vector2 dir)
  26.         {
  27.             Start = new Vector2(x1, y1);
  28.             End = new Vector2(x2, y2);
  29.             Dir = dir;
  30.         }
  31.         public readonly Vector2 Start, End, Dir;
  32.     }
  33. }

其次编写的是我们上面提到的能够不使用其它多余组件实现多种移动的CharacterController.cs

完整版如下：

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4. using System.Linq;
  5.  
  6. namespace TarController
  7. {
  8.     public class CharacterController : MonoBehaviour, IPlayerInterface
  9.     {
  10.         //实现IPlayerInterface的接口
  11.         public FrameInput frameInput { get; private set; }
  12.         public Vector3 Velocity { get; private set; }
  13.         public bool FrameJumped { get; private set; }
  14.         public bool FrameLanded { get; private set; }
  15.         public bool Grounded => collDown;
  16.         public Vector3 RawMovement { get; private set; }
  17.  
  18.         private Vector3 lastPosition;
  19.         private float currentHorizontalSpeed, currentVerticalSpeed;
  20.         //为了防止游戏开始时碰撞体还没生成需要等0.5s ,nameof函数的string类型
  21.         bool _actived;
  22.         private void Awake()=>Invoke(nameof(Activated),0.5f );
  23.         void Activated() => _actived = true;
  24.         void Update()
  25.         {
  26.             if (!_actived)
  27.                 return;
  28.             //计算速度
  29.             Velocity = (transform.position - lastPosition) / Time.deltaTime;
  30.             lastPosition = transform.position;
  31.  
  32.             CatchInput();
  33.             RunCollisionCheck();
  34.  
  35.             CalculateWalk();
  36.             CalculateJumpApex();
  37.             CalculateGravity();
  38.             CalculateJump();
  39.  
  40.             MoveCharacter();
  41.         }
  42.  
  43.         #region Input System
  44.         private void CatchInput()
  45.         {
  46.             frameInput = new FrameInput
  47.             {
  48.                 X = Input.GetAxisRaw("Horizontal"),
  49.                 JumpDown = Input.GetButtonDown("Jump"),//按下跳跃
  50.                 JumpUp = Input.GetButtonUp("Jump") //按起跳跃
  51.             };
  52.             if (frameInput.JumpDown)
  53.             {
  54.                 lastJumpPressed = Time.time;
  55.             }
  56.         }
  57.         #endregion
  58.  
  59.         #region Collison
  60.         [Header("Collision")]
  61.         [SerializeField] private Bounds characterBounds; //边界长方体
  62.         [SerializeField] private LayerMask groundLayer;
  63.         [SerializeField] private int detectorCount = 3;
  64.         [SerializeField] private float detectorLength = 0.1f;
  65.         [SerializeField, Range(0.1f, 0.3f)] private float rayBuffer = 0.1f;
  66.  
  67.         private RayRange raysUp, raysDown, raysLeft, raysRight;
  68.         bool collUp, collDown, collLeft, collRight;
  69.  
  70.         private float timeLeftGrounded;
  71.  
  72.         private void RunCollisionCheck()
  73.         {
  74.             //生成射线
  75.             CaculateRayRanged();
  76.  
  77.             //这个状态是在地面上
  78.             FrameLanded = false;
  79.             var groundedCheck = RunDetection(raysDown);
  80.             if(collDown&& !groundedCheck)
  81.             {
  82.                 timeLeftGrounded = Time.time;
  83.             }
  84.             //目的是让玩家离开地面一小段距离时还能进行跳跃
  85.             else if(!collDown && groundedCheck)
  86.             {
  87.                 coyoteUsable = true;
  88.                 FrameLanded = true;
  89.             }
  90.             collDown = groundedCheck;
  91.  
  92.             collUp = RunDetection(raysUp);
  93.             collLeft = RunDetection(raysLeft);
  94.             collRight = RunDetection(raysRight);
  95.  
  96.             bool RunDetection(RayRange range)
  97.             {
  98.                 return EvaluateRayPositions(range).Any(point => Physics2D.Raycast(point, range.Dir, detectorLength, groundLayer));
  99.             }
  100.         }
  101.         //用射线来判断是否在地面上
  102.         private void CaculateRayRanged()
  103.         {
  104.             var b = new Bounds(transform.position, characterBounds.size);
  105.  
  106.             raysDown = new RayRange (b.min.x + rayBuffer, b.min.y, b.max.x-rayBuffer, b.min.y,Vector2.down);
  107.             raysUp = new RayRange   (b.min.x + rayBuffer, b.max.y, b.max.x-rayBuffer, b.max.y, Vector2.up);
  108.             raysLeft = new RayRange (b.min.x, b.min.y + rayBuffer, b.min.x, b.max.y - rayBuffer, Vector2.left);
  109.             raysRight = new RayRange(b.max.x, b.min.y + rayBuffer, b.max.x, b.max.y - rayBuffer, Vector2.right);
  110.         }
  111.  
  112.         //这里不知道什么意思
  113.         private IEnumerable<Vector2> EvaluateRayPositions(RayRange range)
  114.         {
  115.             for (int i = 0; i < detectorCount; i++)
  116.             {
  117.                 var t = (float)i / (detectorCount - 1);
  118.                 yield return Vector2.Lerp(range.Start, range.End, t);
  119.             }
  120.         }
  121.         private void OnDrawGizmos()
  122.         {
  123.             //Bounds
  124.             Gizmos.color = Color.yellow;
  125.             Gizmos.DrawWireCube(transform.position + characterBounds.center, characterBounds.size);
  126.  
  127.             //画射线
  128.             if (!Application.isPlaying)
  129.             {
  130.                 CaculateRayRanged();
  131.                 Gizmos.color = Color.blue;
  132.                 foreach (var range in new List<RayRange> { raysUp,raysRight,raysDown,raysLeft})
  133.                 {
  134.                     foreach (var point in EvaluateRayPositions(range))
  135.                     {
  136.                         Gizmos.DrawRay(point, range.Dir * detectorLength);
  137.                     }
  138.                 }
  139.             }
  140.  
  141.             if (!Application.isPlaying)
  142.                 return;
  143.  
  144.             //未来的位置
  145.             Gizmos.color = Color.red;
  146.             var move = new Vector3(currentHorizontalSpeed, currentVerticalSpeed) * Time.deltaTime;
  147.             Gizmos.DrawWireCube(transform.position + move, characterBounds.size);
  148.         }
  149.         #endregion
  150.  
  151.         #region Walk
  152.         /*
  153.          要说明一定，当到最高点apex的时候，允许有一定的调整速度，即apexBonus
  154.          */
  155.         [Header("Walking")]
  156.         [SerializeField] float moveClamp = 13f; //最大速度
  157.         [SerializeField] float accleration = 90f; //加速度
  158.         [SerializeField] float deAccleration = 60f; //减速度
  159.         [SerializeField] float apexBonus = 2f;
  160.         private void CalculateWalk()
  161.         {
  162.             if(frameInput.X != 0)
  163.             {
  164.                 currentHorizontalSpeed +=frameInput.X * accleration * Time.deltaTime;
  165.                 currentHorizontalSpeed = Mathf.Clamp(currentHorizontalSpeed, -moveClamp, moveClamp);
  166.                 //奖励速度,当跳跃到最高点时
  167.                 //Mathf.Sign() 如果是0或正数就返回1，负数则返回-1       //最高点apex
  168.                 var _apexBouns = Mathf.Sign(frameInput.X) * apexBonus * apexPoints;
  169.                 currentHorizontalSpeed += _apexBouns * Time.deltaTime;
  170.             }
  171.             //当你键盘没有输入X的速度就减速
  172.             else
  173.             {
  174.                 currentHorizontalSpeed = Mathf.MoveTowards(currentHorizontalSpeed, 0, deAccleration * Time.deltaTime);
  175.             }
  176.             //当碰到墙上时
  177.             if(currentHorizontalSpeed >0 && collRight || currentHorizontalSpeed <0 && collLeft)
  178.             {
  179.                 currentHorizontalSpeed = 0;
  180.             }
  181.         }
  182.         #endregion
  183.  
  184.         #region Jump
  185.         /*
  186.          跳跃分为小跳和大跳
  187.         当按下跳跃的时候y轴的速度等于跳跃高度，同时开始计时离开地面的时间，关闭coyote，正在跳跃为true，早点结束跳跃为false
  188.         当按起跳跃键的时候，判断脚没碰到地面，有y轴方向的速度，早点结束跳跃为true
  189.         当头顶碰到物体的时候直接将y轴速度设置为0
  190.  
  191.         同时还有一个判断在跳跃最高点，用插值函数作为fallspeed
  192.          */
  193.         [Header("Jumping")]
  194.         [SerializeField] float jumpHeight = 30f;
  195.         [SerializeField] float jumpEarlyGravityModifier = 3;
  196.         [SerializeField] float jumpApexThreshold = 10f; //当跳跃到最高点时有一段反重力和小助推效果
  197.         [SerializeField] float coyoteTImeThreshold = 0.1f;
  198.         [SerializeField] float jumpBuffered = 0.1f; 
  199.  
  200.         private float apexPoints; //当跳到最高点时值为1
  201.         private float lastJumpPressed; //记录按下跳跃的时间
  202.  
  203.         private bool coyoteUsable;
  204.         private bool endedjumpEarly = true;
  205.  
  206.         private bool CanUseCoyote => coyoteUsable && !collDown && coyoteTImeThreshold + timeLeftGrounded > Time.time; //允许玩家在离开平台的几毫秒时间内仍然能跳跃
  207.         private bool HasBufferJump => collDown && jumpBuffered + lastJumpPressed > Time.time; //跳跃缓冲
  208.         private void CalculateJumpApex()
  209.         {
  210.             if (!collDown)
  211.             {
  212.                 apexPoints = Mathf.InverseLerp(jumpApexThreshold, 0,Mathf.Abs( Velocity.y));
  213.                 fallSpeed = Mathf.Lerp(minFallSpeed, maxFallSpeed, apexPoints);
  214.             }
  215.             else
  216.             {
  217.                 apexPoints = 0;
  218.             }
  219.         }
  220.         private void CalculateJump()
  221.         {
  222.             //大跳
  223.             if (frameInput.JumpDown && CanUseCoyote || HasBufferJump)
  224.             {
  225.                 currentVerticalSpeed = jumpHeight;
  226.                 endedjumpEarly = false;
  227.                 coyoteUsable = false;
  228.                 timeLeftGrounded = float.MinValue;
  229.                 FrameJumped = true;
  230.             }
  231.             else
  232.             {
  233.                 FrameJumped = false;
  234.             }
  235.             //小跳（在跳跃的时候很快就松开跳跃键）
  236.             if (frameInput.JumpUp && !collDown && !endedjumpEarly && Velocity.y >0)
  237.             {
  238.                 endedjumpEarly = true;
  239.             }
  240.             //如果头顶撞到了
  241.             if (collUp)
  242.             {
  243.                 if(currentVerticalSpeed > 0)
  244.                 {
  245.                     currentVerticalSpeed = 0;
  246.                 }
  247.             }
  248.         }
  249.         #endregion
  250.  
  251.         #region Gravity
  252.         [Header("Gravity")]
  253.         [SerializeField] float fallClamp = -40f;
  254.         [SerializeField] float minFallSpeed = 80f;
  255.         [SerializeField] float maxFallSpeed = 120f;
  256.         private float fallSpeed;
  257.  
  258.         /*
  259.           先判断是否在地面上，如果在地面上y轴的速度为0，如果在下降过程中，则再判断是否是小跳，小跳则加快降落速度，否则是正常减速度
  260.           最后再限制一下最大下落速度
  261.          */
  262.         private void CalculateGravity()
  263.         {
  264.             if (collDown)
  265.             {
  266.                 if (currentVerticalSpeed < 0)
  267.                     currentVerticalSpeed = 0;
  268.             }
  269.             else
  270.             {
  271.                 //判断是否大小跳然后再根据选择下降速度
  272.                 var fallingSpeed = endedjumpEarly && currentVerticalSpeed > 0 ? fallSpeed * jumpEarlyGravityModifier : fallSpeed;
  273.                 currentVerticalSpeed -= fallingSpeed * Time.deltaTime;
  274.                 if (currentVerticalSpeed < fallClamp) currentVerticalSpeed = fallClamp;
  275.             }
  276.         }
  277.         #endregion
  278.  
  279.         #region Move
  280.         [Header("Move")]
  281.         [SerializeField, Tooltip("Raising this value increases collision accuracy at the cost of performance.")]
  282.         private int freeColliderIterations = 10;
  283.  
  284.         //我们投射我们的边界来避免被接下来的碰撞体
  285.         private void MoveCharacter()
  286.         {
  287.             var pos = transform.position;
  288.             RawMovement = new Vector3(currentHorizontalSpeed, currentVerticalSpeed);
  289.             var move = RawMovement * Time.deltaTime;
  290.             var furtherPos = move + pos;
  291.  
  292.             //检测下一个位置的碰撞，如果没有发生碰撞就停止检测
  293.             var hit = Physics2D.OverlapBox(furtherPos, characterBounds.size, 0, groundLayer);
  294.             if(!hit)
  295.             {
  296.                 transform.position += move;
  297.                 return;
  298.             }
  299.  
  300.             //否则找个可以移动的点
  301.             var positionToMoveTo = transform.position;
  302.  
  303.             for (int i = 1; i < freeColliderIterations; i++)
  304.             {
  305.                 var t = (float)i / freeColliderIterations;
  306.                 var posToTry = Vector2.Lerp(pos, furtherPos, t);
  307.  
  308.                 if (Physics2D.OverlapBox(posToTry, characterBounds.size, 0, groundLayer))
  309.                 {
  310.                     transform.position = positionToMoveTo;
  311.  
  312.                     if(i == 1)
  313.                     {
  314.                         if (currentVerticalSpeed < 0)
  315.                             currentVerticalSpeed = 0;
  316.                         var dir = transform.position - hit.transform.position;
  317.                         transform.position += dir.normalized * move.magnitude;
  318.                     }
  319.                     return;
  320.                 }
  321.                 positionToMoveTo = posToTry;
  322.             }
  323.         }
  324.         #endregion
  325.     }
  326. }

解析版如下：

首先我们要实现前面提到的接口里面的所有成员（这里是属性）

  1. //实现IPlayerInterface的接口
  2.         public FrameInput frameInput { get; private set; }
  3.         public Vector3 Velocity { get; private set; }
  4.         public bool FrameJumped { get; private set; }
  5.         public bool FrameLanded { get; private set; }
  6.         public bool Grounded => collDown;
  7.         public Vector3 RawMovement { get; private set; }

然后我们currentHorizontalSpeed, currentVerticalSpeed记录我们的xy轴方向上的速度。

这段是作者说明为了防止游戏运行时碰撞体还没有完成生成而延迟0.5s使用Awake（）函数

  1.  //为了防止游戏开始时碰撞体还没生成需要等0.5s ,nameof函数的string类型
  2.         bool _actived;
  3.         private void Awake()=>Invoke(nameof(Activated),0.5f );
  4.         void Activated() => _actived = true;
  1. if (!_actived)
  2.                 return;
  3.             //计算速度
  4.             Velocity = (transform.position - lastPosition) / Time.deltaTime;
  5.             lastPosition = transform.position;

然后我们分模块解析各个函数的意义，每个模块都用#region 和 #endregion来分块管理

首先是Input System

用Unity中Input类自带的来键盘输入，赋值给我们前面创建的结构体FrameInput，frameInput.JumpDown记录我们最后按下跳跃的时间

  1. #region Input System
  2.         private void CatchInput()
  3.         {
  4.             frameInput = new FrameInput
  5.             {
  6.                 X = Input.GetAxisRaw("Horizontal"),
  7.                 JumpDown = Input.GetButtonDown("Jump"),//按下跳跃
  8.                 JumpUp = Input.GetButtonUp("Jump") //按起跳跃
  9.             };
  10.             if (frameInput.JumpDown)
  11.             {
  12.                 lastJumpPressed = Time.time;
  13.             }
  14.         }
  15.         #endregion

然后是Walk模块

用+=来加速，用Mathf.Clamp(限制它的最大速度)，而apexBouns则是玩家跳跃到最高点的时候能进行小范围的移动来控制下落点；当你没有输入X方向的输入的时候，Mathf.MoveTowards（）来减速，最后当你撞墙的时候你的currentHorizontalSpeed = 0;

  1. #region Walk
  2.         /*
  3.          要说明一定，当到最高点apex的时候，允许有一定的调整速度，即apexBonus
  4.          */
  5.         [Header("Walking")]
  6.         [SerializeField] float moveClamp = 13f; //最大速度
  7.         [SerializeField] float accleration = 90f; //加速度
  8.         [SerializeField] float deAccleration = 60f; //减速度
  9.         [SerializeField] float apexBonus = 2f;
  10.         private void CalculateWalk()
  11.         {
  12.             if(frameInput.X != 0)
  13.             {
  14.                 currentHorizontalSpeed +=frameInput.X * accleration * Time.deltaTime;
  15.                 currentHorizontalSpeed = Mathf.Clamp(currentHorizontalSpeed, -moveClamp, moveClamp);
  16.                 //奖励速度,当跳跃到最高点时
  17.                 //Mathf.Sign() 如果是0或正数就返回1，负数则返回-1       //最高点apex
  18.                 var _apexBouns = Mathf.Sign(frameInput.X) * apexBonus * apexPoints;
  19.                 currentHorizontalSpeed += _apexBouns * Time.deltaTime;
  20.             }
  21.             //当你键盘没有输入X的速度就减速
  22.             else
  23.             {
  24.                 currentHorizontalSpeed = Mathf.MoveTowards(currentHorizontalSpeed, 0, deAccleration * Time.deltaTime);
  25.             }
  26.             //当碰到墙上时
  27.             if(currentHorizontalSpeed >0 && collRight || currentHorizontalSpeed <0 && collLeft)
  28.             {
  29.                 currentHorizontalSpeed = 0;
  30.             }
  31.         }
  32.         #endregion

跳跃部分分为大跳和小跳，根据你是否过早松开跳跃键来判断。需要注意的是coyote部分的代码使用于当你在台阶上离开地面的几毫秒时间你仍然能进行跳跃

  1. #region Jump
  2.         /*
  3.          跳跃分为小跳和大跳
  4.         当按下跳跃的时候y轴的速度等于跳跃高度，同时开始计时离开地面的时间，关闭coyote，正在跳跃为true，早点结束跳跃为false
  5.         当按起跳跃键的时候，判断脚没碰到地面，有y轴方向的速度，早点结束跳跃为true
  6.         当头顶碰到物体的时候直接将y轴速度设置为0
  7.  
  8.         同时还有一个判断在跳跃最高点，用插值函数作为fallspeed
  9.          */
  10.         [Header("Jumping")]
  11.         [SerializeField] float jumpHeight = 30f;
  12.         [SerializeField] float jumpEarlyGravityModifier = 3;
  13.         [SerializeField] float jumpApexThreshold = 10f; //当跳跃到最高点时有一段反重力和小助推效果
  14.         [SerializeField] float coyoteTImeThreshold = 0.1f;
  15.         [SerializeField] float jumpBuffered = 0.1f; 
  16.  
  17.         private float apexPoints; //当跳到最高点时值为1
  18.         private float lastJumpPressed; //记录按下跳跃的时间
  19.  
  20.         private bool coyoteUsable;
  21.         private bool endedjumpEarly = true;
  22.  
  23.         private bool CanUseCoyote => coyoteUsable && !collDown && coyoteTImeThreshold + timeLeftGrounded > Time.time; //允许玩家在离开平台的几毫秒时间内仍然能跳跃
  24.         private bool HasBufferJump => collDown && jumpBuffered + lastJumpPressed > Time.time; //跳跃缓冲
  25.         private void CalculateJumpApex()
  26.         {
  27.             if (!collDown)
  28.             {
  29.                 apexPoints = Mathf.InverseLerp(jumpApexThreshold, 0,Mathf.Abs( Velocity.y));
  30.                 fallSpeed = Mathf.Lerp(minFallSpeed, maxFallSpeed, apexPoints);
  31.             }
  32.             else
  33.             {
  34.                 apexPoints = 0;
  35.             }
  36.         }
  37.         private void CalculateJump()
  38.         {
  39.             //大跳
  40.             if (frameInput.JumpDown && CanUseCoyote || HasBufferJump)
  41.             {
  42.                 currentVerticalSpeed = jumpHeight;
  43.                 endedjumpEarly = false;
  44.                 coyoteUsable = false;
  45.                 timeLeftGrounded = float.MinValue;
  46.                 FrameJumped = true;
  47.             }
  48.             else
  49.             {
  50.                 FrameJumped = false;
  51.             }
  52.             //小跳（在跳跃的时候很快就松开跳跃键）
  53.             if (frameInput.JumpUp && !collDown && !endedjumpEarly && Velocity.y >0)
  54.             {
  55.                 endedjumpEarly = true;
  56.             }
  57.             //如果头顶撞到了
  58.             if (collUp)
  59.             {
  60.                 if(currentVerticalSpeed > 0)
  61.                 {
  62.                     currentVerticalSpeed = 0;
  63.                 }
  64.             }
  65.         }
  66.         #endregion

然后到了下落部分，同样根据你是大跳还是小跳决定你的下落速度

  1. #region Gravity
  2.         [Header("Gravity")]
  3.         [SerializeField] float fallClamp = -40f;
  4.         [SerializeField] float minFallSpeed = 80f;
  5.         [SerializeField] float maxFallSpeed = 120f;
  6.         private float fallSpeed;
  7.  
  8.         /*
  9.           先判断是否在地面上，如果在地面上y轴的速度为0，如果在下降过程中，则再判断是否是小跳，小跳则加快降落速度，否则是正常减速度
  10.           最后再限制一下最大下落速度
  11.          */
  12.         private void CalculateGravity()
  13.         {
  14.             if (collDown)
  15.             {
  16.                 if (currentVerticalSpeed < 0)
  17.                     currentVerticalSpeed = 0;
  18.             }
  19.             else
  20.             {
  21.                 //判断是否大小跳然后再根据选择下降速度
  22.                 var fallingSpeed = endedjumpEarly && currentVerticalSpeed > 0 ? fallSpeed * jumpEarlyGravityModifier : fallSpeed;
  23.                 currentVerticalSpeed -= fallingSpeed * Time.deltaTime;
  24.                 if (currentVerticalSpeed < fallClamp) currentVerticalSpeed = fallClamp;
  25.             }
  26.         }
  27.         #endregion

然后是Collision部分的检测

  1. region Collison
  2.         [Header("Collision")]
  3.         [SerializeField] private Bounds characterBounds; //边界长方体
  4.         [SerializeField] private LayerMask groundLayer;
  5.         [SerializeField] private int detectorCount = 3;
  6.         [SerializeField] private float detectorLength = 0.1f;
  7.         [SerializeField, Range(0.1f, 0.3f)] private float rayBuffer = 0.1f;
  8.  
  9.         private RayRange raysUp, raysDown, raysLeft, raysRight;
  10.         bool collUp, collDown, collLeft, collRight;
  11.  
  12.         private float timeLeftGrounded;
  13.  
  14.         private void RunCollisionCheck()
  15.         {
  16.             //生成射线
  17.             CaculateRayRanged();
  18.  
  19.             //这个状态是在地面上
  20.             FrameLanded = false;
  21.             var groundedCheck = RunDetection(raysDown);
  22.             if(collDown&& !groundedCheck)
  23.             {
  24.                 timeLeftGrounded = Time.time;
  25.             }
  26.             //目的是让玩家离开地面一小段距离时还能进行跳跃
  27.             else if(!collDown && groundedCheck)
  28.             {
  29.                 coyoteUsable = true;
  30.                 FrameLanded = true;
  31.             }
  32.             collDown = groundedCheck;
  33.  
  34.             collUp = RunDetection(raysUp);
  35.             collLeft = RunDetection(raysLeft);
  36.             collRight = RunDetection(raysRight);
  37.  
  38.             bool RunDetection(RayRange range)
  39.             {
  40.                 return EvaluateRayPositions(range).Any(point => Physics2D.Raycast(point, range.Dir, detectorLength, groundLayer));
  41.             }
  42.         }
  43.         //用射线来判断是否在地面上
  44.         private void CaculateRayRanged()
  45.         {
  46.             var b = new Bounds(transform.position, characterBounds.size);
  47.  
  48.             raysDown = new RayRange (b.min.x + rayBuffer, b.min.y, b.max.x-rayBuffer, b.min.y,Vector2.down);
  49.             raysUp = new RayRange   (b.min.x + rayBuffer, b.max.y, b.max.x-rayBuffer, b.max.y, Vector2.up);
  50.             raysLeft = new RayRange (b.min.x, b.min.y + rayBuffer, b.min.x, b.max.y - rayBuffer, Vector2.left);
  51.             raysRight = new RayRange(b.max.x, b.min.y + rayBuffer, b.max.x, b.max.y - rayBuffer, Vector2.right);
  52.         }
  53.  
  54.         //这里不知道什么意思
  55.         private IEnumerable<Vector2> EvaluateRayPositions(RayRange range)
  56.         {
  57.             for (int i = 0; i < detectorCount; i++)
  58.             {
  59.                 var t = (float)i / (detectorCount - 1);
  60.                 yield return Vector2.Lerp(range.Start, range.End, t);
  61.             }
  62.         }
  63.         private void OnDrawGizmos()
  64.         {
  65.             //Bounds
  66.             Gizmos.color = Color.yellow;
  67.             Gizmos.DrawWireCube(transform.position + characterBounds.center, characterBounds.size);
  68.  
  69.             //画射线
  70.             if (!Application.isPlaying)
  71.             {
  72.                 CaculateRayRanged();
  73.                 Gizmos.color = Color.blue;
  74.                 foreach (var range in new List<RayRange> { raysUp,raysRight,raysDown,raysLeft})
  75.                 {
  76.                     foreach (var point in EvaluateRayPositions(range))
  77.                     {
  78.                         Gizmos.DrawRay(point, range.Dir * detectorLength);
  79.                     }
  80.                 }
  81.             }
  82.  
  83.             if (!Application.isPlaying)
  84.                 return;
  85.  
  86.             //未来的位置
  87.             Gizmos.color = Color.red;
  88.             var move = new Vector3(currentHorizontalSpeed, currentVerticalSpeed) * Time.deltaTime;
  89.             Gizmos.DrawWireCube(transform.position + move, characterBounds.size);
  90.         }
  91.         #endregion

最后是真正用于移动的Move（）

  1.   #region Move
  2.         [Header("Move")]
  3.         [SerializeField, Tooltip("Raising this value increases collision accuracy at the cost of performance.")]
  4.         private int freeColliderIterations = 10;
  5.  
  6.         //我们投射我们的边界来避免被接下来的碰撞体
  7.         private void MoveCharacter()
  8.         {
  9.             var pos = transform.position;
  10.             RawMovement = new Vector3(currentHorizontalSpeed, currentVerticalSpeed);
  11.             var move = RawMovement * Time.deltaTime;
  12.             var furtherPos = move + pos;
  13.  
  14.             //检测下一个位置的碰撞，如果没有发生碰撞就停止检测
  15.             var hit = Physics2D.OverlapBox(furtherPos, characterBounds.size, 0, groundLayer);
  16.             if(!hit)
  17.             {
  18.                 transform.position += move;
  19.                 return;
  20.             }
  21.  
  22.             //否则找个可以移动的点
  23.             var positionToMoveTo = transform.position;
  24.  
  25.             for (int i = 1; i < freeColliderIterations; i++)
  26.             {
  27.                 var t = (float)i / freeColliderIterations;
  28.                 var posToTry = Vector2.Lerp(pos, furtherPos, t);
  29.  
  30.                 if (Physics2D.OverlapBox(posToTry, characterBounds.size, 0, groundLayer))
  31.                 {
  32.                     transform.position = positionToMoveTo;
  33.  
  34.                     if(i == 1)
  35.                     {
  36.                         if (currentVerticalSpeed < 0)
  37.                             currentVerticalSpeed = 0;
  38.                         var dir = transform.position - hit.transform.position;
  39.                         transform.position += dir.normalized * move.magnitude;
  40.                     }
  41.                     return;
  42.                 }
  43.                 positionToMoveTo = posToTry;
  44.             }
  45.         }
  46.         #endregion
  47.     }

最后我们再添加一个CharacterAnimator.cs用于做动画，控制身体转向，播放声音，播放粒子特效

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4. using Random = UnityEngine.Random;
  5.  
  6. namespace TarController
  7. {
  8.     public class CharacterAnimator : MonoBehaviour
  9.     {
  10.         [SerializeField] private Animator anim;
  11.         [SerializeField] private AudioSource source;
  12.         [SerializeField] private AudioClip[] clips;
  13.         [SerializeField] private LayerMask groundMasks;
  14.         [SerializeField] private ParticleSystem jumpParticle, lanuchParticle;
  15.         [SerializeField] private ParticleSystem moveParticle, landParticle;
  16.         [SerializeField] private float maxTilt = 0.1f;
  17.         [SerializeField] private float tileSpeed = 1f;
  18.         [SerializeField, Range(1f, 3f)] private float maxIdleSpeed = 2f;
  19.  
  20.         
  21.         [SerializeField] private float maxParticalFallSpeed = -40f;
  22.         private ParticleSystem.MinMaxGradient currentGradient;
  23.  
  24.         private IPlayerInterface player;
  25.         private bool playerOnGround;
  26.         private Vector2 movement;
  27.  
  28.         void Awake() => player = GetComponentInParent<IPlayerInterface>();
  29.         void Update()
  30.         {
  31.             if (player != null)
  32.                 return;
  33.             //Flip
  34.             if (player.frameInput.X != 0)
  35.             {
  36.                 transform.localScale = new Vector3(player.frameInput.X >0?1:-1, 1, 1);
  37.             }
  38.             //跑步的时候播放身体抖动的动画
  39.             var targetRotVector = new Vector3(0, 0, Mathf.Lerp(-maxTilt, maxTilt, Mathf.InverseLerp(-1, 1, player.frameInput.X)));
  40.             anim.transform.rotation = Quaternion.RotateTowards(anim.transform.rotation,Quaternion.Euler(targetRotVector), tileSpeed * Time.deltaTime);
  41.  
  42.             //跑步的动画
  43.             anim.SetFloat(IdleSpeedKey, Mathf.Lerp(1, maxIdleSpeed, Mathf.Abs(player.frameInput.X)));
  44.             //降落动画
  45.             if (player.FrameLanded)
  46.             {
  47.                 anim.SetTrigger(GroundedKey);
  48.                 source.PlayOneShot(clips[Random.Range(0, clips.Length)]);
  49.             }
  50.             //跳跃动画
  51.             if (player.FrameJumped)
  52.             {
  53.                 anim.SetTrigger(JumpKey);
  54.                 anim.ResetTrigger(GroundedKey);
  55.  
  56.                 //只有在地面上才会播放粒子（也避免在coyote状态下播放）
  57.                 if (player.Grounded)
  58.                 {
  59.                     SetColor(jumpParticle);
  60.                     SetColor(lanuchParticle);
  61.                     jumpParticle.Play();
  62.                 }
  63.             }
  64.             //降落的粒子特效
  65.             if(!playerOnGround && player.Grounded)
  66.             {
  67.                 playerOnGround = true;
  68.                 moveParticle.Play();
  69.                 landParticle.transform.localScale = Vector3.one * Mathf.InverseLerp(0, maxParticalFallSpeed, movement.y);
  70.                 SetColor(landParticle);
  71.                 landParticle.Play();
  72.             }
  73.             else if(playerOnGround && !player.Grounded)
  74.             {
  75.                 playerOnGround = false;
  76.                 moveParticle.Stop();
  77.             }
  78.  
  79.             //检测是否碰到地面
  80.             var groundHit = Physics2D.Raycast(transform.position, Vector3.down, 2, groundMasks);
  81.             if(groundHit&& groundHit.transform.TryGetComponent(out SpriteRenderer sr))
  82.             {
  83.                 currentGradient = new ParticleSystem.MinMaxGradient(sr.color * 0.9f, sr.color * 1.2f);
  84.                 SetColor(moveParticle);
  85.             }
  86.  
  87.             movement = player.RawMovement;
  88.         }
  89.         private void OnDisable()
  90.         {
  91.             moveParticle.Stop();
  92.         }
  93.         private void OnEnable()
  94.         {
  95.             moveParticle.Play();
  96.         }
  97.         private void SetColor(ParticleSystem ps)
  98.         {
  99.             var main = ps.main;
  100.             main.startColor = currentGradient;
  101.         }
  102.         #region Animation Keys
  103.         private static readonly int GroundedKey = Animator.StringToHash("Grounded");
  104.         private static readonly int IdleSpeedKey = Animator.StringToHash("IdleSpeed");
  105.         private static readonly int JumpKey = Animator.StringToHash("Jump");
  106.         #endregion
  107.     }
  108. }

在Visual游戏对象的Aniamtor中添加条件 

别忘了修改参数

学习产出：

 

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

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

  

闽ICP备14008679号