C# 如何使船舶在旋转后朝着它们所面对的方向移动？

在剧本中我有20艘太空船。我存储了每艘飞船的起始位置，然后检查每艘飞船是否在我旋转飞船时移动和移动了50距离。这部分工作正常

现在我想做的是，如果我把每艘飞船旋转180度，一旦飞船旋转到这个方向。问题是，即使在旋转之后，船舶仍会保持向原始方向移动

在脚本的顶部：

private float distanceTravelled;
public bool updateOn = true;
private Vector3 lastPosition;

List<bool> hasRotated = new List<bool>();
List<float> distanceTraveled = new List<float>();
List<Vector3> lastPositions = new List<Vector3>();

然后在移动飞船中，我试图改变每艘飞船旋转后的移动方向：

这是原始的MoveShips功能代码：

private void MoveShips()
    {
        for (int index = 0;index < spheres[0].transform.childCount;index++)
        {
            Transform oneChild = spheres[0].transform.GetChild(index);
            lastPositions[index] = oneChild.transform.position;
            oneChild.transform.position += Vector3.forward * Time.deltaTime * moveSpeed;
        }

        if (updateOn == true) {
            for(int index =0;index < spheres[0].transform.childCount;index++)
            {
                Transform child = spheres[0].transform.GetChild(index);

                distanceTraveled[index] += Vector3.Distance (child.transform.position, lastPositions [index]);
                if (distanceTraveled[index] >= 50 && !hasRotated[index])
                {
                    child.transform.Rotate (new Vector3 (0f, 180f, 0f));
                    hasRotated[index] = true;
                }
            }
        }
    }

或

但在所有情况下，船舶都会保持原来的方向，然后再也不会根据旋转后它们面对的方向改变运动

如果我将它们旋转1度、20度或180度，我希望它们在旋转后移动到它们现在面对的方向。即使我更改了X轴、Y轴或Z轴上的旋转，也会根据我旋转的轴向上下左右向前移动。但我现在首先要做的是将它们旋转180度，这样它们在旋转后会改变方向，并向这个方向移动。现在要反向移动，但移动到面方向

所以我试着用child变换来代替Vector3.forward，但到目前为止还没有成功

private void MoveShips()
    {
        for (int index = 0;index < spheres[0].transform.childCount;index++)
        {
            Transform oneChild = spheres[0].transform.GetChild(index);
            lastPositions[index] = oneChild.transform.position;
            //oneChild.transform.position += Vector3.forward * Time.deltaTime * moveSpeed;
            if (distanceTraveled [index] >= 50 && !hasRotated [index]) {
                oneChild.transform.position -= oneChild.transform.forward * Time.deltaTime * moveSpeed;
            } else 
            {
                oneChild.transform.position += Vector3.forward * Time.deltaTime * moveSpeed;
            }

        }

        if (updateOn == true) {
            for(int index =0;index < spheres[0].transform.childCount;index++)
            {
                Transform child = spheres[0].transform.GetChild(index);

                distanceTraveled[index] += Vector3.Distance (child.transform.position, lastPositions [index]);
                if (distanceTraveled[index] >= 50 && !hasRotated[index])
                {
                    child.transform.Rotate (new Vector3 (0f, 180f, 0f));
                    hasRotated[index] = true;
                    //child.transform.position += child.transform.forward * Time.deltaTime * moveSpeed;
                }
            }
        }
    }

这就是我的船现在的样子：

private void MoveShips()
    {
        for (int index = 0;index < spheres[0].transform.childCount;index++)
        {
            Transform oneChild = spheres[0].transform.GetChild(index);
            lastPositions[index] = oneChild.transform.position;
            oneChild.transform.position += Vector3.forward * Time.deltaTime * moveSpeed;
        }

        if (updateOn == true) {
            for(int index =0;index < spheres[0].transform.childCount;index++)
            {
                Transform child = spheres[0].transform.GetChild(index);

                distanceTraveled[index] += Vector3.Distance (child.transform.position, lastPositions [index]);
                if (distanceTraveled[index] >= 50 && !hasRotated[index])
                {
                    targetAngles = child.transform.eulerAngles + 180f * Vector3.up;
                    StartCoroutine (TurnShip (child.transform, child.transform.eulerAngles, targetAngles, smooth));
                    hasRotated[index] = true;
                }
            }
        }
    }

private void MoveShips（）
{
对于（int index=0；index=50&&！已旋转[索引]）
{
targetAngles=child.transform.eulerAngles+180f*Vector3.up；
Start例程（TurnShip（child.transform，child.transform.eulerAngles，targetAngles，smooth））；
hasRotated[索引]=真；
}
}
}
}

以及转船功能：

IEnumerator TurnShip(Transform ship, Vector3 startAngle, Vector3 endAngle, float smooth)
    {
        float lerpSpeed = 0;

        while(lerpSpeed < 1)
        {
            ship.eulerAngles = Vector3.Lerp(startAngle, endAngle, lerpSpeed);
            lerpSpeed += Time.deltaTime * smooth;
            yield return null;
        }
    }

IEnumerator旋转船（变换船、矢量3星缠结、矢量3端角、浮动平滑）
{
浮点数=0；
while（lerpSpeed<1）
{
ship.eulerAngles=Vector3.Lerp（startAngle、endAngle、lerpSpeed）；
lerpSpeed+=Time.deltaTime*平滑；
收益返回空；
}
}

你试过翻译吗

// Example Forwards
child.transform.Translate(Vector3.forward * Time.deltaTime * moveSpeed);
// Example Backwards
child.transform.Translate(Vector3.back * Time.deltaTime * moveSpeed);
// you could use: left, right, up, down, forward, back

---

文档：

如果我有问题在这里作为评论或在链接中的其他问题询问@Absince，可能会重复@Absince？我想问你链接中的解决方案。@苦艾酒在另一个问题中，你的解决方案现在起作用了，我看到了顺利的转折。但是这些船继续朝着原来的方向移动，而不是朝着转弯后的方向移动。我在这里使用了你的轮换解决方案。@Absince我想做的不是越过看不见的墙，而是让船行驶一段距离，在这段距离之后，它们会转向另一边，然后移动到另一边。@Absince我用你在另一个问题上的解决方案更新了我的问题。抱歉搞砸了。这有助于你找到解决方案吗？

private void MoveShips()
    {
        for (int index = 0;index < spheres[0].transform.childCount;index++)
        {
            Transform oneChild = spheres[0].transform.GetChild(index);
            lastPositions[index] = oneChild.transform.position;
            //oneChild.transform.position += Vector3.forward * Time.deltaTime * moveSpeed;
            if (distanceTraveled [index] >= 50 && !hasRotated [index]) {
                oneChild.transform.position -= oneChild.transform.forward * Time.deltaTime * moveSpeed;
            } else 
            {
                oneChild.transform.position += Vector3.forward * Time.deltaTime * moveSpeed;
            }

        }

        if (updateOn == true) {
            for(int index =0;index < spheres[0].transform.childCount;index++)
            {
                Transform child = spheres[0].transform.GetChild(index);

                distanceTraveled[index] += Vector3.Distance (child.transform.position, lastPositions [index]);
                if (distanceTraveled[index] >= 50 && !hasRotated[index])
                {
                    child.transform.Rotate (new Vector3 (0f, 180f, 0f));
                    hasRotated[index] = true;
                    //child.transform.position += child.transform.forward * Time.deltaTime * moveSpeed;
                }
            }
        }
    }

public float smooth = 1f;
private Vector3 targetAngles;

private void MoveShips()
    {
        for (int index = 0;index < spheres[0].transform.childCount;index++)
        {
            Transform oneChild = spheres[0].transform.GetChild(index);
            lastPositions[index] = oneChild.transform.position;
            oneChild.transform.position += Vector3.forward * Time.deltaTime * moveSpeed;
        }

        if (updateOn == true) {
            for(int index =0;index < spheres[0].transform.childCount;index++)
            {
                Transform child = spheres[0].transform.GetChild(index);

                distanceTraveled[index] += Vector3.Distance (child.transform.position, lastPositions [index]);
                if (distanceTraveled[index] >= 50 && !hasRotated[index])
                {
                    targetAngles = child.transform.eulerAngles + 180f * Vector3.up;
                    StartCoroutine (TurnShip (child.transform, child.transform.eulerAngles, targetAngles, smooth));
                    hasRotated[index] = true;
                }
            }
        }
    }

IEnumerator TurnShip(Transform ship, Vector3 startAngle, Vector3 endAngle, float smooth)
    {
        float lerpSpeed = 0;

        while(lerpSpeed < 1)
        {
            ship.eulerAngles = Vector3.Lerp(startAngle, endAngle, lerpSpeed);
            lerpSpeed += Time.deltaTime * smooth;
            yield return null;
        }
    }

// Example Forwards
child.transform.Translate(Vector3.forward * Time.deltaTime * moveSpeed);
// Example Backwards
child.transform.Translate(Vector3.back * Time.deltaTime * moveSpeed);
// you could use: left, right, up, down, forward, back