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

Unity控制逻辑（移动，翻滚，瞬移）_rigidbody2d.velocity

作者：weixin_40725706 | 2024-02-16 01:56:17

赞

踩

rigidbody2d.velocity

目录

1.案例的前期准备

2.移动的实现

3.翻滚的实现

4.瞬移的实现

1.案例的前期准备

1.创建2D项目

 2.搭建场景

分别创建player（玩家），background（背景图），barrier（障碍物）。

 3.创建C#脚本

在对象player上创建CharacterController2D脚本

2.移动的实现

  1. public class CharacterController2D : MonoBehaviour
  2. {
  3.     private const float MOVE_SPEED = 5f;
  4.     
  5.     private void Awake()
  6.     {
  7.         rigidbody2D = GetComponent<Rigidbody2D>();
  8.     }
  9.     
  10.     private void Update()
  11.     {
  12.         float moveX = 0f;
  13.         float moveY = 0f;
  14.  
  15.         if (Input.GetKey(KeyCode.W))
  16.         {
  17.             // transform.position += new Vector3(0,+1);
  18.             moveY = +1f;
  19.         }
  20.         if (Input.GetKey(KeyCode.S))
  21.         {
  22.             // transform.position += new Vector3(0,-1);
  23.             moveY = -1f;
  24.         }
  25.         if (Input.GetKey(KeyCode.A))
  26.         {
  27.             // transform.position += new Vector3(-1,0);
  28.             moveX = -1f;
  29.         }
  30.         if (Input.GetKey(KeyCode.D))
  31.         {
  32.             // transform.position += new Vector3(+1,0);
  33.             moveX = +1f;
  34.         }
  35.         moveDir = new Vector3(moveX, moveY).normalized;
  36.     }
  37.  
  38.     private void FixedUpdate()
  39.     {
  40.         rigidbody2D.velocity = moveDir * MOVE_SPEED;
  41.     }
  42. }
  43.

实现方法：方向向量*移动速度

1，使用const储存物体速度（float）

2，在Update()中使用Input.GetKey(keyCode.按键)方法读取玩家相应按键 

3，使用moveX,moveY分别保存在X，Y轴的移动增量，以此创建Vector

4，使用normalized获取Vector对象的方向向量（单位向量）赋给moveDir              

Rigidbody2D.velocity

描述

刚体的线性速度，采用单位/秒形式。

在移动或旋转一个物体时，往往会直接使用Transform来执行这些操作。这种方法对于不具物理特性的GameObject来说，是可行的。但是一旦GameObject上附带有Rigidbody2D，这种方式就会带来性能的损失

3.翻滚的实现

  1. public class CharacterController2D : MonoBehaviour
  2. {
  3.     //构建枚举类区分行走状态和翻滚状态
  4.     private enum State
  5.     {
  6.         Normal, //正常行走
  7.         Rolling, //翻滚
  8.     }
  9.  
  10.     [SerializeField] private LayerMask dashLayerMask;
  11.  
  12.     private Rigidbody2D rigidbody2D;
  13.     private Vector3 moveDir;
  14.     private Vector3 rollDir; //翻滚的方向
  15.     private Vector3 lastMoveDir; //保存最后一次非静止状态的Vector
  16.     private float rollSpeed; //翻滚的初始速度
  17.     private State state; 
  18.  
  19.     private void Awake()
  20.     {
  21.         rigidbody2D = GetComponent<Rigidbody2D>();
  22.         state = State.Normal;
  23.     }
  24.  
  25.     private void Update()
  26.     {
  27.         switch (state)
  28.         {
  29.             case State.Normal:
  30.                 float moveX = 0f;
  31.                 float moveY = 0f;
  32.                 if (Input.GetKey(KeyCode.W))
  33.                 {
  34.                     // transform.position += new Vector3(0,+1);
  35.                     moveY = +1f;
  36.                 }
  37.                 if (Input.GetKey(KeyCode.S))
  38.                 {
  39.                     // transform.position += new Vector3(0,-1);
  40.                     moveY = -1f;
  41.                 }
  42.                 if (Input.GetKey(KeyCode.A))
  43.                 {
  44.                     // transform.position += new Vector3(-1,0);
  45.                     moveX = -1f;
  46.                 }
  47.                 if (Input.GetKey(KeyCode.D))
  48.                 {
  49.                     // transform.position += new Vector3(+1,0);
  50.                     moveX = +1f;
  51.                 }
  52.  
  53.                 moveDir = new Vector3(moveX, moveY).normalized;
  54.  
  55.                 //保存最后一次非静止状态的Vector，防止原地翻滚
  56.                 if(moveX != 0f || moveY != 0)
  57.                 {
  58.                     lastMoveDir = moveDir;
  59.                 }
  60.                 
  61.                 //按下空格键进入翻滚状态   
  62.                 if (Input.GetKey(KeyCode.Space))
  63.                 {
  64.                     //最后一次非静止状态的Vector，即翻滚的方向
  65.                     rollDir = lastMoveDir;
  66.                     //翻滚的初始速度
  67.                     rollSpeed = 25f;
  68.                     state = State.Rolling;
  69.                 }
  70.                 break;
  71.             case State.Rolling:
  72.                 //翻滚是一个减速过程
  73.                 //减速系数
  74.                 float rollSpeedDropMultiplier = 5f;
  75.                 //按帧减速
  76.                 rollSpeed -= rollSpeed * rollSpeedDropMultiplier * Time.deltaTime;
  77.  
  78.                 //设置下限
  79.                 float rollSpeedMinimum = 5f;
  80.                 //小于下限切换至行走状态
  81.                 if(rollSpeed < rollSpeedMinimum)
  82.                 {
  83.                     state=State.Normal;
  84.                 }
  85.             break;
  86.         }
  87.  
  88.  
  89.     }
  90.  
  91.     private void FixedUpdate()
  92.     {
  93.         switch (state)
  94.         {
  95.             case State.Normal:
  96.                 rigidbody2D.velocity = moveDir * MOVE_SPEED;
  97.                 break;
  98.             case State.Rolling:
  99.                 rigidbody2D.velocity = rollDir * rollSpeed;
  100.                 break;
  101.         }
  102.  
  103.     }
  104. }

4.瞬移的实现

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class CharacterController2D : MonoBehaviour
  6. {
  7.     private const float MOVE_SPEED = 5f;
  8.  
  9.     private enum State
  10.     {
  11.         Normal,
  12.         Rolling,
  13.     }
  14.  
  15.     [SerializeField] private LayerMask dashLayerMask;//设置射线与哪些层级发生碰撞，此项为可序列化的
  16.  
  17.     private Rigidbody2D rigidbody2D;
  18.     private Vector3 moveDir;
  19.     private Vector3 rollDir;
  20.     private Vector3 lastMoveDir;
  21.     private float rollSpeed;
  22.     private bool isDashButtonDown;//瞬移状态切换
  23.     private State state;
  24.  
  25.     private void Awake()
  26.     {
  27.         rigidbody2D = GetComponent<Rigidbody2D>();
  28.         state = State.Normal;
  29.     }
  30.  
  31.     private void Update()
  32.     {
  33.         switch (state)
  34.         {
  35.             case State.Normal:
  36.                 float moveX = 0f;
  37.                 float moveY = 0f;
  38.                 if (Input.GetKey(KeyCode.W))
  39.                 {
  40.                     // transform.position += new Vector3(0,+1);
  41.                     moveY = +1f;
  42.                 }
  43.                 if (Input.GetKey(KeyCode.S))
  44.                 {
  45.                     // transform.position += new Vector3(0,-1);
  46.                     moveY = -1f;
  47.                 }
  48.                 if (Input.GetKey(KeyCode.A))
  49.                 {
  50.                     // transform.position += new Vector3(-1,0);
  51.                     moveX = -1f;
  52.                 }
  53.                 if (Input.GetKey(KeyCode.D))
  54.                 {
  55.                     // transform.position += new Vector3(+1,0);
  56.                     moveX = +1f;
  57.                 }
  58.  
  59.                 moveDir = new Vector3(moveX, moveY).normalized;
  60.                 if(moveX != 0f || moveY != 0)
  61.                 {
  62.                     lastMoveDir = moveDir;
  63.                 }
  64.                 
  65.                 //按F进入瞬移状态
  66.                 if (Input.GetKey(KeyCode.F))
  67.                 {
  68.                     isDashButtonDown = true;
  69.                 }
  70.  
  71.                 if (Input.GetKey(KeyCode.Space))
  72.                 {
  73.                     rollDir = lastMoveDir;
  74.                     rollSpeed = 25f;
  75.                     state = State.Rolling;
  76.                 }
  77.                 break;
  78.             case State.Rolling:
  79.                 float rollSpeedDropMultiplier = 5f;
  80.                 rollSpeed -= rollSpeed * rollSpeedDropMultiplier * Time.deltaTime;
  81.  
  82.                 float rollSpeedMinimum = 5f;
  83.                 if(rollSpeed < rollSpeedMinimum)
  84.                 {
  85.                     state=State.Normal;
  86.                 }
  87.             break;
  88.         }
  89.  
  90.  
  91.     }
  92.  
  93.     private void FixedUpdate()
  94.     {
  95.         switch (state)
  96.         {
  97.             case State.Normal:
  98.                 rigidbody2D.velocity = moveDir * MOVE_SPEED;
  99.  
  100.                 if (isDashButtonDown)
  101.                 {
  102.                     //瞬移距离
  103.                     float dashAmount = 0.5f;
  104.                     //无障碍物情况下的瞬移量
  105.                     Vector3 dashPosition = transform.position + lastMoveDir * dashAmount;
  106.  
  107.                     //使用射线判断瞬移路径上是否有障碍物，有则被阻碍
  108.                     RaycastHit2D raycastHit2D = Physics2D.Raycast(transform.position, lastMoveDir, dashAmount, dashLayerMask);
  109.                     //射线碰撞的物体不为空
  110.                     if (raycastHit2D.collider != null)
  111.                     {
  112.                         //射线与物体碰撞的点即为瞬移的最终位置
  113.                         dashPosition = raycastHit2D.point;
  114.                     }
  115.                     rigidbody2D.MovePosition(dashPosition);
  116.                     //切换至行走状态
  117.                     isDashButtonDown = false;
  118.                 }
  119.                 break;
  120.             case State.Rolling:
  121.                 rigidbody2D.velocity = rollDir * rollSpeed;
  122.                 break;
  123.         }
  124.  
  125.     }
  126. }

​​​RigidBody2D.MovePosition

描述

将刚体移动到 /position/。

通过计算在下一次物理更新期间将刚体移动到指定 position 所需的适当线速度来将刚体移动到该位置。在移动过程中，重力或线性阻力都不会影响刚体。这使得对象能够快速从现有位置穿过世界移动到指定的 /position/。

由于该功能允许刚体穿过世界快速移动到指定的 /position/，因此附加到刚体的任何碰撞体都将按预期作出反应，也就是说，它们将产生碰撞和/或触发。这也意味着如果碰撞体产生碰撞，则将影响到刚体的运动，并可能阻止刚体在下一次物理更新期间到达指定的 /position/。如果是运动刚体，则任何碰撞都不影响刚体本身，只会影响任何其他动态碰撞体。

2D 刚体对其移动速度有固定限制，因此在短时间内尝试移动较远的距离会导致刚体无法在下一次物理更新期间到达指定 /position/。建议仅将该函数用于相对较短距离的移动。

请务必注意， 实际的位置更改只在下一次物理更新期间进行， 因此重复调用该方法而不等待下一次物理更新将导致使用最后一次调用。 因此，建议在 FixedUpdate 回调期间调用该函数。

Rigidbody2D.velocity:将钢体线性移动至某一位置

RigidBody2D.MovePosition:将钢体线性瞬移至某一位置

如何理解本案例中的射线RaycastHit2D

若没有使用射线进行判定，这钢体可能可以穿越碰撞体

RaycastHit2D raycastHit2D = Physics2D.Raycast(transform.position, lastMoveDir, dashAmount, dashLayerMask);

本案例的射线分别有如下参数

1.射线的起始位置

2.射线的方向

3.射线的距离

4.射线应于哪些层级发生碰撞

ps：若不设置此项，则与所有层级发生碰撞。可能导致本案例中的瞬移无法实现

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

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

  

闽ICP备14008679号