Java 我怎样才能阻止数组中的元素互相加载？

我正在用AndEngine为Android开发一款游戏，我有一系列汽车物体，它们在屏幕上以不同的车道从左到右移动。当汽车超过摄像头宽度（屏幕大小）时，我将其位置设置为0（屏幕左侧）-spriteWidth（）（屏幕视口左侧）。我的问题是，由于返回的坐标是随机的，所以这些车一直顶着彼此装载。我尝试过很多事情，但总是发生

这是用于在游戏开始时设置汽车坐标的方法，也可以在屏幕右侧设置汽车坐标

public Vector2 randomRoadCoord()
{
    int Y;
    int X;

    int arrayLength = rManager.getInstance().roadPosition.length;
    int arrayFirstValue = 1;

    Random xR = new Random();
    int Low = (int) (5 *(0 - rManager.getInstance().car_region.getWidth()));
    int High = (int) (0 - rManager.getInstance().car_region.getWidth());
    X = xR.nextInt(High-Low) + Low;

    Random yR = new Random();

    int LowY = arrayFirstValue;
    int HighY = arrayLength;
    Y = yR.nextInt(HighY-LowY) + LowY;;

    if (firstLoad)
    {
        for(int i = 0; i < rManager.getInstance().carArray.length; i++)
        {
            for(int j = 0; j < rManager.getInstance().carArray.length; j++)
            {
                while(rManager.getInstance().carArray[i].getCarSprite().collidesWith(rManager.getInstance().carArray[j].getCarSprite()))
                    X-= 150;
            }
        }
    }

    lastX = X;
    lastY = Y;
    return new Vector2(X, Y);
}

公共矢量2随机道路坐标（） { int-Y； int X； int-arrayLength=rManager.getInstance（）.roadPosition.length； int arrayFirstValue=1； Random xR=新的Random（）； int Low=（int）（5*（0-rmager.getInstance（）.car_region.getWidth（））； int-High=（int）（0-rManager.getInstance（）.car_region.getWidth（））； X=xR.nextInt（高-低）+低； 随机yR=新随机（）； int LowY=数组第一个值； int HighY=阵列长度； Y=yR.nextInt（高-低）+LowY；； 如果（首次加载） { 对于（int i=0；i 如您所见，在某些区域之间返回随机的x和y值；具体来说，相机的顶部和底部（静态相机，因此基本上是视口），以及屏幕外-50和-450之间（类似于此）。我的问题是，我需要它们停止相互加载，因为如果发生碰撞，用户将输掉游戏。我试着检查每个汽车精灵，看看它是否在装载时已经与另一辆汽车相撞（尽管这确实会导致减速，如果是，将X坐标进一步向左移动，但它似乎没有任何作用）

/*if (firstLoad)
        {
        for(int i = 0; i < rManager.getInstance().carArray.length; i++)
        {
            while(rManager.getInstance().carArray[i].getCarX() + 100 > X && X > rManager.getInstance().carArray[i].getCarX() - 100)
                X-= 150;
        }       
        firstLoad = true;
    }   */

/*如果（首次加载）
{
对于（int i=0；iX&&X>rManager.getInstance（）.carArray[i].getCarX（）-100）
X-=150；
}       
firstLoad=true；
}   */

我也试过检查这辆车是否在其他车的x+150和x-150之间，但这也没什么作用。不是所有的车都装在一起，但肯定超过1辆，这太多了

谢谢。请随时提问

---------------------------------更新：

我试着使用整形外科医生的建议，但同样的问题仍然存在。虽然一辆车被压在另一辆车上的可能性要小得多，但它仍然偶尔发生。我这次对代码进行了注释，因此应该更容易理解

for (int i = 0; i < rManager.getInstance().carArray.length; i++)
            {
                if(rManager.getInstance().carArray[i].getCarSprite().getX() < (rManager.camera.getWidth() + rManager.getInstance().carArray[i].getCarSprite().getWidth()))
                {
                    // moves car from left to right
                    rManager.getInstance().carArray[i].getCarSprite().setPosition(rManager.getInstance().carArray[i].getCarSprite().getX() + (rManager.getInstance().carArray[i].getSpeed() * 4), rManager.getInstance().carArray[i].getCarSprite().getY()); 
                } 

                else //if out of the screen
                {       
                    //set the position to the left of the screen
                    rManager.getInstance().carArray[i].getCarSprite().setPosition(randomRoadCoord().x, rManager.getInstance().roadPosition[(int) randomRoadCoord().y].y);

                    //if colliding with another car
                    while(collidesWithExisting(rManager.getInstance().carArray[i]))
                    {   //set a new random pos
                        rManager.getInstance().carArray[i].getCarSprite().setPosition(randomRoadCoord().x, rManager.getInstance().roadPosition[(int) randomRoadCoord().y].y);
                    }
                }
            }

for（int i=0；i

方法：

boolean collidesWithExisting(Car pCar)
{
    for(int j = 0; j < rManager.getInstance().carArray.length; j++)
    {
        if (rManager.getInstance().carArray[j] == pCar)
            return false;

        if(rManager.getInstance().carArray[j].getCarSprite().collidesWith(pCar.getCarSprite()))
            return true;
    }
    return false;
}

boolean冲突与现有冲突（汽车pCar）
{
对于（int j=0；j

---

再次感谢。

您的循环至少有一个问题： 当X值更改时，您检查的条件.CollizeSwith（）不会更改。因此可能会发生其他误报

第二个问题是，如果发生了CollizeSwith（）事件，则无法知道新x是否也会在循环中较早时在另一辆车上引发CollizeSwith（）事件。想象一下，将第三辆车放置在两辆车之间，这两辆车之间太近，无法容纳两辆车。在单循环或双循环中无法解决这一问题

因此，这里有一个不同的策略：仅使一个轴完全随机。一次通过X轴（车辆行驶方向）一个车辆长度。随机确定该位置是否应有车辆。如果是，则沿Y轴随机定位该车辆。 没有太多的麻烦，你可以让它适应放置一个或多个汽车每一步

如果你不希望网格像obvoius一样，你可以将你的X环向前推进1/2车长。然后你只需要检查与前一辆车或前一辆车的碰撞

   Car newCar = new Car();
   newCar.setPosition(randomXPostion, randomYPosition);
   while(testCarCollidesWithExisting(newCar)){
       newCar.setPosition(randomXPostion, randomYPosition);
   }

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;

import org.andengine.engine.camera.Camera;
import org.andengine.engine.options.EngineOptions;
import org.andengine.engine.options.ScreenOrientation;
import org.andengine.engine.options.resolutionpolicy.RatioResolutionPolicy;
import org.andengine.entity.scene.Scene;
import org.andengine.entity.scene.background.Background;
import org.andengine.entity.sprite.Sprite;
import org.andengine.entity.util.FPSLogger;
import org.andengine.opengl.texture.ITexture;
import org.andengine.opengl.texture.bitmap.BitmapTexture;
import org.andengine.opengl.texture.region.ITextureRegion;
import org.andengine.opengl.texture.region.TextureRegionFactory;
import org.andengine.ui.activity.SimpleBaseGameActivity;
import org.andengine.util.adt.io.in.IInputStreamOpener;
import org.andengine.util.debug.Debug;

import android.os.Bundle;
import android.view.Menu;

public class TestBed extends SimpleBaseGameActivity {

    // ===========================================================
    // Constants
    // ===========================================================

    private static final int CAMERA_WIDTH = 720;
    private static final int CAMERA_HEIGHT = 480;

    // ===========================================================
    // Fields
    // ===========================================================

    private ITexture mTexture;
    private ITextureRegion mFaceTextureRegion;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //setContentView(R.layout.activity_test_bed);
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.test_bed, menu);
        return true;
    }

    @Override
    public EngineOptions onCreateEngineOptions() {
        final Camera camera = new Camera(0, 0, CAMERA_WIDTH, CAMERA_HEIGHT);

        return new EngineOptions(true, ScreenOrientation.LANDSCAPE_SENSOR, new RatioResolutionPolicy(CAMERA_WIDTH, CAMERA_HEIGHT), camera);
    }

    @Override
    public void onCreateResources() {
        try {
            this.mTexture = new BitmapTexture(this.getTextureManager(), new IInputStreamOpener() {
                @Override
                public InputStream open() throws IOException {
                    return getAssets().open("tank.png");
                }
            });

            this.mTexture.load();
            this.mFaceTextureRegion = TextureRegionFactory.extractFromTexture(this.mTexture);
        } catch (IOException e) {
            Debug.e(e);
        }
    }
    ArrayList<Sprite> placedSprites = new ArrayList<Sprite>();
    @Override
    protected Scene onCreateScene() {
        this.mEngine.registerUpdateHandler(new FPSLogger());

        final Scene scene = new Scene();
        scene.setBackground(new Background(0.09804f, 0.6274f, 0.8784f));

        /* Calculate the coordinates for the face, so its centered on the camera. */
        final float centerX = (CAMERA_WIDTH - this.mFaceTextureRegion.getWidth()) / 2;
        final float centerY = (CAMERA_HEIGHT - this.mFaceTextureRegion.getHeight()) / 2;

        /* Create the face and add it to the scene. */
        for (int i = 0; i < 20; i++) {
            final Sprite face = new Sprite(centerX, centerY, this.mFaceTextureRegion, this.getVertexBufferObjectManager());
            scene.attachChild(face);
            face.setPosition((float)(Math.random()*CAMERA_WIDTH), (float)(Math.random()*CAMERA_HEIGHT));
            while(faceDoesNotOverlap(face)){
                face.setPosition((float)(Math.random()*CAMERA_WIDTH), (float)(Math.random()*CAMERA_HEIGHT));                
            }
            placedSprites.add(face);

        }

        return scene;
    }

    private boolean faceDoesNotOverlap(Sprite face) {
        for (int i = 0; i < placedSprites.size(); i++) {
            if(face.collidesWith(placedSprites.get(i))){
                return true;
            }
        }
        return false;
    }



}