C# 来回移动物体

我试图移动多个物体，同时从A点移动到B点，然后再移动回来，形成一个循环，作为阻挡玩家的障碍

我试过了

StartCoroutine(Oscillate(OscillationFunction.Sine, 1f));
  public IEnumerator Oscillate(OscillationFunction method, float scalar)
  right = GameObject.FindGameObjectsWithTag("MovingObs2");
                foreach (GameObject r in right)
                {
                    startPos = r.transform.position;    
                    v = startPos;
                    v.x = (r.transform.position.x + (Mathf.Cos(Time.time) * scalar));
                    r.transform.position = v;
                    yield return new WaitForSeconds(2);
                    r.transform.position = startPos;
                }

还有一些，但是它们都很难控制在一个理想的距离和速度范围内。太快了，太远了

我尝试了一个看似简单的句子，对我来说更容易理解

 v.x = l.transform.position.x + speed * Time.deltaTime;
            l.transform.position = v;

但由于我在foreach循环中使用数组，我不知道如何保留每个游戏对象的transform.position，以便在每次到达点a或点B时都可以将其用作反转对象移动方向的条件

   if (l.transform.position.x <= startPos.x || l.transform.position.x >= startPos.x + endPos.x)
        {
            speed *= -1;
        }

if（l.transform.position.x=startPos.x+endPos.x）
{
速度*=-1；
}

---

编辑：如果我问了一个重复的问题，我很抱歉，我认为这是不同的，因为数组中涉及的对象数量不同。

我试图假设要解决您的所有问题，请参阅下面的代码

不需要Time.deltaTime，因为您的代码（和我的）每次都使用Time.Time来计算对象的位置

我还建议（如果可能的话）不要把所有的东西都放在脚本中，而是给每个对象一个swing脚本，并且尽量不要使用协同程序。但为了回答你的问题，我会告诉你怎么做

我已经创建了一个内部类，将目标游戏对象和它们在列表中的起始位置存储在“Init”中。稍后，您可以简单地在这个列表中循环，并始终保持起始位置

你需要在“Osciallate”程序中进行无休止的循环，并且需要等待每一轮。在您的示例中，您将等待放置在错误的位置，因此它在移动每个对象后等待，并在第一次运行所有这些对象后停止

代码如下：

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class OscilateObs : MonoBehaviour {

    // internal class where all gameobjects and their startposition will be saved
    internal class OscGameObjects
    {
        public GameObject gameObject;
        public Vector3 startPosition;
    }

    // Here the information of all gameObjects stored in a list
    private List<OscGameObjects> objectList;

    public float updateSpeed = 0.05f;
    public float oscScalar = 2f;

    public enum OscillationFunction {
        Sine = 1
    }

    void Start () {
        // First, the gameobjects have to saved to our internal List
        InitializeOscGameObjects();

        // Start the Corotine
        StartCoroutine(Oscillate(OscillationFunction.Sine, oscScalar));
    }

    private void InitializeOscGameObjects()
    {
        var objects = GameObject.FindGameObjectsWithTag("MovingObs2");

        objectList = new List<OscGameObjects>();
        foreach (var o in objects)
        {
            var oscObject = new OscGameObjects();
            oscObject.gameObject = o;
            oscObject.startPosition = o.transform.position;

            objectList.Add(oscObject);
        }
    }

    public IEnumerator Oscillate(OscillationFunction method, float scalar)
    {
        // Loop forever
        while(true)
        {
            foreach (var element in objectList)
            {
                var currentPosition = element.gameObject.transform.position;
                currentPosition.x = element.startPosition.x + Mathf.Cos(Time.time) * scalar;
                element.gameObject.transform.position = currentPosition;

            }
            yield return new WaitForSeconds(updateSpeed);
        }

    }

}

使用系统；
使用系统集合；
使用System.Collections.Generic；
使用UnityEngine；
公共类OscilateObs：单一行为{
//将保存所有游戏对象及其起始位置的内部类
内部类对象
{
公共游戏对象游戏对象；
公共矢量3起始位置；
}
//这里列出了存储在列表中的所有游戏对象的信息
私有列表对象列表；
公共浮点更新速度=0.05f；
公共浮点数=2f；
公共枚举振荡函数{
正弦=1
}
无效开始（）{
//首先，游戏对象必须保存到我们的内部列表中
初始化EOSCGAMEOBJECTS（）；
//启动Corotine
Start例程（振荡（振荡函数.Sine，oscScalar））；
}
private void InitializeOscGameObjects（）
{
var objects=GameObject.FindGameObjectsWithTag（“MovingObs2”）；
objectList=新列表（）；
foreach（对象中的var o）
{
var oscObject=新的OscGameObjects（）；
osobject.gameObject=o；
osobject.startPosition=o.transform.position；
objectList.Add（对象）；
}
}
公共IEnumerator振荡（振荡函数法，浮点标量）
{
//永远循环
while（true）
{
foreach（objectList中的var元素）
{
var currentPosition=element.gameObject.transform.position；
currentPosition.x=element.startPosition.x+Mathf.Cos（Time.Time）*标量；
element.gameObject.transform.position=当前位置；
}
产生返回新的WaitForSeconds（updateSpeed）；
}
}
}

编辑：

我忘了说：

1） 我建议在运动中使用“动画”组件，而不要使用C#，这样你就可以在需要的时候改变行为，从而更加灵活

2） 我还建议，如果可能的话，制作一个父对象“GameObject”，只移动这个，并将“MovingB2”简单地作为子对象

编辑2：

为每个对象添加延迟增量，使其不运行syncron：

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class OscilateObs : MonoBehaviour {

    // internal class where all gameobjects and their startposition will be saved
    internal class OscGameObjects
    {
        public GameObject gameObject;
        public Vector3 startPosition;
        public float waitCount;
    }

    // Here the information of all gameObjects stored in a list
    private List<OscGameObjects> objectList;

    public float updateSpeed = 0.05f;
    public float oscScalar = 2f;
    public float waitIncrementTime = 0.01f;

    public enum OscillationFunction {
        Sine = 1
    }

    void Start () {
        // First, the gameobjects have to saved to our internal List
        InitializeOscGameObjects();

        // Start the Corotine
        StartCoroutine(Oscillate(OscillationFunction.Sine, oscScalar));
    }

    private void InitializeOscGameObjects()
    {
        var objects = GameObject.FindGameObjectsWithTag("MovingObs2");

        objectList = new List<OscGameObjects>();

        float i = 0;
        foreach (var o in objects)
        {
            i += waitIncrementTime;
            var oscObject = new OscGameObjects();
            oscObject.gameObject = o;
            oscObject.startPosition = o.transform.position;
            oscObject.waitCount = i;
            objectList.Add(oscObject);
        }
    }

    public IEnumerator Oscillate(OscillationFunction method, float scalar)
    {
        // Loop forever
        while(true)
        {
            foreach (var element in objectList)
            {
                var currentPosition = element.gameObject.transform.position;
                currentPosition.x = element.startPosition.x + Mathf.Cos(Time.time + element.waitCount) * scalar;
                element.gameObject.transform.position = currentPosition;

            }
            yield return new WaitForSeconds(updateSpeed);
        }

    }

}

使用系统；
使用系统集合；
使用System.Collections.Generic；
使用UnityEngine；
公共类OscilateObs：单一行为{
//将保存所有游戏对象及其起始位置的内部类
内部类对象
{
公共游戏对象游戏对象；
公共矢量3起始位置；
公共浮动等待计数；
}
//这里列出了存储在列表中的所有游戏对象的信息
私有列表对象列表；
公共浮点更新速度=0.05f；
公共浮点数=2f；
公共浮点数waitIncrementTime=0.01f；
公共枚举振荡函数{
正弦=1
}
无效开始（）{
//首先，游戏对象必须保存到我们的内部列表中
初始化EOSCGAMEOBJECTS（）；
//启动Corotine
Start例程（振荡（振荡函数.Sine，oscScalar））；
}
private void InitializeOscGameObjects（）
{
var objects=GameObject.FindGameObjectsWithTag（“MovingObs2”）；
objectList=新列表（）；
浮点数i=0；
foreach（对象中的var o）
{
i+=等待增量时间；
var oscObject=新的OscGameObjects（）；
osobject.gameObject=o；
osobject.startPosition=o.transform.position；
osobject.waitCount=i；
objectList.Add（对象）；
}
}
公共IEnumerator振荡（振荡函数法，浮点标量）
{
//永远循环
while（true）
{
foreach（objectList中的var元素）
{
var currentPosition=element.gameObject.transform.position；
currentPosition.x=element.startPosition.x+Mathf.Cos（Time.Time+element.waitCount）*标量；
element.gameObject.transform.position=当前位置；
}
产生返回新的WaitForSeconds（updateSpeed）；
}
}
}

它们都很难控制在理想的范围内