将角色从 A 点平稳地移动到 B 点

Question

所以，大家好，我是统一的新手。我有一个小小的疑问。我有一个玩家，他是一个放置在彼此身上的 3 stackcube 中的 topcube 的孩子。 一旦用户点击这些立方体，它们就有一个移动的目标位置。 就像想象我的世界有 3 个点。 POINT A 的位置坐标为 (0,0,1)，POINT B 的位置坐标为 (0,0,2)，POINT C 的位置坐标为 (0,0,3)，3 个堆叠立方体放置在 (0,0,0) 上玩家小时候连接到那个 3stackcube 中的 topcube。 所有这些点（A，B，C）都有一个名为 targetpoint 的脚本，其中有一个变量 bool isFilled（默认为 false），当其中一个立方体到达其目标位置时，它变为 true。 进一步检查立方体何时到达它们的目标位置使 isFilled 为真，并检查是否有一个孩子，如果是的话，获取孩子的动画师并触发跳跃动画。跳跃动画是原地动画。 所以我想以编程方式将我的角色 +1 朝着他所面对的方向移动（如果他面向 z 移动 + 1 在 z 中，如果 x 在 x 中移动 +1 像这样）当他附着的立方体达到其目标位置同时也播放跳跃动画。 我做了一个代码。它似乎没有工作。并对大段感到抱歉。我对编码和提出疑问完全陌生。任何帮助都会有所帮助，谢谢。

 [SerializeField] public List<targetpoint> waypoints;
    [SerializeField] float moveSpeed = 2f;
    [SerializeField] AudioClip[] surferSounds;
    [SerializeField] GameObject particleToPlay;
    int waypointIndex = 0;
    float t;

    //Cached Reference
    AudioSource audioSource;

    //State
    public bool move = false;

    void Start()
    {
        transform.position = this.transform.position;
        t = 0f;

    }

    void FixedUpdate()
    {
        if (move == true)
        {
            MoveTarget();
        }
    }

    void MoveTarget()
    {

        //Time.timeScale = 0.1f;
        if (waypointIndex <= waypoints.Count - 1)
        {
            var targetPosition = waypoints[waypointIndex].transform.position;
            transform.position = Vector3.MoveTowards(transform.position, targetPosition, moveSpeed * Time.deltaTime);

            if (transform.position == targetPosition)
            {

                //Debug.Log(t);
                if (waypoints[waypointIndex].isFilled == false)
                {
                    waypoints[waypointIndex].isFilled = true;
                    AudioClip clip = surferSounds[UnityEngine.Random.Range(0, surferSounds.Length)];
                    var storeToDestroy = Instantiate(particleToPlay, targetPosition, Quaternion.identity);
                    Destroy(storeToDestroy , 5f);
                    audioSource.PlayOneShot(clip);
                    move = false;
                }
                else if(waypoints[waypointIndex].isFilled == true)
                {
                    waypointIndex++;
                    targetPosition = waypoints[waypointIndex].transform.position;
                    transform.position = Vector3.MoveTowards(transform.position, targetPosition, moveSpeed * Time.deltaTime);
                }
                if (this.gameObject.transform.childCount > 0)
                {
                    var storeChild = gameObject.transform.GetChild(1).gameObject;
                    StartCoroutine(GravityAndJump(storeChild,storeChild.transform.position+1*transform.forward,1f));
                }
                else
                {
                    return;
                }
            }
        }
    }
    IEnumerator GravityAndJump(GameObject child, Vector3 newPosition , float time)
    {

        var elapsedTime = 0f;
        var startingPosition = child.transform.position;
        while(elapsedTime < time)
        {
            child.GetComponent<Animator>().SetTrigger("shouldJump?");
            child.transform.position = Vector3.Lerp(startingPosition, newPosition, (elapsedTime / time));
            elapsedTime += Time.deltaTime;
            yield return null;
        }


        //storeChild.GetComponent<Animator>().SetFloat("JumpSpeed", 1f);
        //yield return new WaitForSeconds(1f);
        //gameObject.GetComponentInChildren<Rigidbody>().useGravity = true;
    }
}

Answer 1

所以我想以编程方式将我的角色 +1 朝他所面对的方向移动（如果他面向 z 移动 +1 在 z 中，如果 x 像这样在 x 移动 +1）

您可以使用transform.forward 获取游戏对象的前进方向，您可以使用它来计算游戏对象前面的目标位置。

将目标位置设置在变换前面一段距离

targetPosition = transform.position + (transform.forward * distance);

以一定速度向目标位置移动。

transform.position = Vector3.Lerp(transform.position, targetPosition, Time.deltaTime * followSpeed);

确定到达 targetPosition

在确定变换是否已到达目标目的地时，您应该测量距离，而不是比较向量是否相同。

所以替换这个：

if (transform.position == targetPosition){}

这样的：

if(Vector3.Distance(transform.position, targetPosition) < .001f){
  transform.position = targetPosition;
}

除非您将两个向量严格设置为相同的值，否则由于浮点数的工作方式，它们可能永远不会被视为相等。