Java 在render（）中随机更改图像，而不更改所有其他图像的图像

我随后在

LibGDX

中构建了一个简单的游戏。游戏的基本思想是：有水滴落下，玩家应该把一个桶拖到水滴落下的地方，让它们坐在沙发上

在原始版本中，所有水滴都是从一个水滴图像创建的，我尝试做的是制作一个不同水滴的雨（不同的水滴图像），因此我创建了一个不同纹理的

列表
-
一些水滴
，在
渲染（）中，我替换了：

     batch.draw(dropImage, raindrop.x, raindrop.y); 

与：

我得到的是不同的雨滴，但它们不会以不同的图像落下，但它们会落下，并同时改变图像

我如何设置，使每一个水滴都能随机地从
someDrops
的图像中落下，并以随机的x、y位置落下。
此外，我还想向每个放置点添加不同的点，我应该将其保存在哪里，以及选择什么类型的集合

public class Drop implements ApplicationListener {
   private Texture dropImage;
   private Texture bucketImage;
   private Sound dropSound;
   private Music rainMusic;
   private SpriteBatch batch;
   private OrthographicCamera camera;
   private Rectangle bucket;
   private Array<Rectangle> raindrops;
   private long lastDropTime;
   private List<Texture> someDrops;

   private Texture drop0;   
   private Texture drop1;
   private Texture drop2;
   private Texture drop3;

   @Override
   public void create() {
      // load the images for the droplet and the bucket, 64x64 pixels each
      dropImage = new Texture(Gdx.files.internal("droplet.png"));

      drop0 = new Texture(Gdx.files.internal("droplet0.png"));
      drop1 = new Texture(Gdx.files.internal("droplet1.png"));
      drop2 = new Texture(Gdx.files.internal("droplet2.png"));
      drop3 = new Texture(Gdx.files.internal("droplet3.png"));
      bucketImage = new Texture(Gdx.files.internal("bucket.png"));

      someDrops = new ArrayList<Texture>();

            someDrops.add(new Texture(drop0));
            someDrops.add(new Texture(drop1));
            someDrops.add(new Texture(drop2));
            someDrops.add(new Texture(drop3));

      camera = new OrthographicCamera();
      camera.setToOrtho(false, 800, 480);
      batch = new SpriteBatch();

      // create a Rectangle to logically represent the bucket
      bucket = new Rectangle();
      bucket.x = 800 / 2 - 64 / 2; // center the bucket horizontally
      bucket.y = 20; // bottom left corner of the bucket is 20 pixels above the bottom screen edge
      bucket.width = 64;
      bucket.height = 64;

      //raindrops array and spawn the first raindrop
      raindrops = new Array<Rectangle>();
      spawnRaindrop();

   private void spawnRaindrop() {
      Rectangle raindrop = new Rectangle();
      raindrop.x = MathUtils.random(0, 800-64);
      raindrop.y = 480;
      raindrop.width = 64;
      raindrop.height = 64;
      raindrops.add(raindrop);
      lastDropTime = TimeUtils.nanoTime();
   }

   @Override
   public void render() {
      Gdx.gl.glClearColor(0, 0, 0.2f, 1);
      Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
      camera.update();
      batch.setProjectionMatrix(camera.combined);

      // begin a new batch and draw the bucket and
      // all drops
      batch.begin();
      batch.draw(bucketImage, bucket.x, bucket.y);
      for(Rectangle raindrop: raindrops) {
         //batch.draw(dropImage, raindrop.x, raindrop.y); 
           int random = MathUtils.random(0, 4);
           batch.draw(someDrops.get(random), raindrop.x, raindrop.y); 

      }
      batch.end();

      // check if we need to create a new raindrop
      if(TimeUtils.nanoTime() - lastDropTime > 1000000000) spawnRaindrop();

      Iterator<Rectangle> iter = raindrops.iterator();
      while(iter.hasNext()) {
         Rectangle raindrop = iter.next();
         raindrop.y -= 200 * Gdx.graphics.getDeltaTime();
         if(raindrop.y + 64 < 0) iter.remove();
         if(raindrop.overlaps(bucket)) {
            dropSound.play();
            iter.remove();
         }
      }
   }

public类Drop实现ApplicationListener{
私有纹理图像；
私有纹理图像；
私人声音；
私人音乐；
专用SpriteBatch批次；
私人正交摄影机；
私有矩形桶；
私人阵列雨滴；
私人长时间；
私人名单；
私有纹理0；
私有纹理1；
私有纹理2；
私有纹理3；
@凌驾
公共void create（）{
//加载液滴和铲斗的图像，每个图像为64x64像素
dropImage=新纹理（Gdx.files.internal（“droplet.png”）；
drop0=新纹理（Gdx.files.internal（“droplet0.png”）；
drop1=新纹理（Gdx.files.internal（“droplet1.png”）；
drop2=新纹理（Gdx.files.internal（“droplet2.png”）；
drop3=新纹理（Gdx.files.internal（“droplet3.png”）；
bucketImage=新纹理（Gdx.files.internal（“bucket.png”）；
someDrops=newarraylist（）；
添加（新纹理（drop0））；
添加（新纹理（drop1））；
添加（新纹理（drop2））；
添加（新纹理（drop3））；
摄影机=新的正交摄影机（）；
摄像头。设置为ToOrtho（假，800480）；
批次=新的SpriteBatch（）；
//创建一个矩形以逻辑方式表示存储桶
bucket=新矩形（）；
bucket.x=800/2-64/2；//将铲斗水平居中
bucket.y=20；//bucket的左下角比屏幕底部边缘高20像素
桶宽=64；
铲斗高度=64；
//雨滴阵列并产生第一个雨滴
雨滴=新阵列（）；
雨滴（）；
私人空间和雨滴（）{
矩形雨滴=新矩形（）；
雨滴.x=数学随机数（0800-64）；
雨滴y=480；
雨滴宽度=64；
雨滴高度=64；
雨滴。添加（雨滴）；
lastDropTime=TimeUtils.nanoTime（）；
}
@凌驾
公共无效呈现（）{
glClearColor（0,0,0.2f,1）；
Gdx.gl.glClear（GL20.gl\u颜色\u缓冲\u位）；
camera.update（）；
batch.setProjectionMatrix（camera.combined）；
//开始一个新的批次，并绘制铲斗和
//所有滴
batch.begin（）；
批量绘制（bucketImage，bucket.x，bucket.y）；
用于（矩形雨滴：雨滴）{
//批处理绘制（dropImage，raindrop.x，raindrop.y）；
int random=MathUtils.random（0,4）；
批量绘制（someDrops.get（random），raindrop.x，raindrop.y）；
}
batch.end（）；
//检查是否需要创建新的雨滴
如果（TimeUtils.nanoTime（）-lastDropTime>100000000）生成雨滴（）；
迭代器iter=raindrops.Iterator（）；
while（iter.hasNext（））{
矩形雨滴=iter.next（）；
raindrop.y-=200*Gdx.graphics.getDeltaTime（）；
如果（雨滴y+64<0）iter.remove（）；
if（雨滴重叠（桶））{
dropSound.play（）；
iter.remove（）；
}
}
}
在
render（）
函数中，我相信您会调用每一帧，您会绘制所有现有的放置点，必要时创建一个新放置点，并减小放置点的y位置。
问题的出现是因为每次要绘制现有的水滴时，都要使用

int random = MathUtils.random(0, 4);

这可能会给你一个不同于上一次绘制的图像，即当它处于较高的y位置时。因此，当它下降（y递减）时，图像会在每次渲染时不断变化，直到它最终落入桶中时被移除

若要解决此问题，请仅在第一次渲染新水滴时获取随机图像，然后保存此图像并在水滴的整个生命周期内使用相同的图像绘制。保存相应图像的新数组的大小将与雨滴数组保持相同，除非添加了新的雨滴，在这种情况下，您将获得新的随机图像法师

我将添加一些代码来说明这一点，但我从未用Java编程或使用过libgdx，因此您必须修复编译器错误：）

在开始时创建雨滴纹理

   private Array<Texture> raindropTextures; // need an ArrayList here?

最后——

   Iterator<Rectangle> iter = raindrops.iterator();
   Iterator<Texture> iter2 = raindropTextures.iterator();
   //later
   iter.remove()
   iter2.remove()

iter=raindrops.Iterator（）；
迭代器iter2=raindropTextures.Iterator（）；
//后来
iter.remove（）
iter2.remove（）
我知道render（）会在屏幕上绘制所有水滴，按照我的代码操作。在整个水滴生命周期中，我如何每次为每一水滴绘制一个新图像，你能用代码显示它吗？我不完全熟悉libgdx中的可用选项，但伪代码是-在Create（）中创建一个纹理数组，检查render（）中雨滴数组和纹理数组的大小是否相同，如果不使用somedrops.get（random）向纹理数组添加一个额外的纹理，然后对纹理数组和雨滴数组进行循环。这样解释更好吗？同时确保减小
   raindropTextures = new Array<Texture>();

   // if the sizes aren't equal, a new raindrop must have been added!!
   if(raindrops.size() != raindropTextures.size())  {
     int random = MathUtils.random(0, 4);
     raindropTextures.add(someDrops.get(random));
   }        
   for(Rectangle raindrop: raindrops, Texture texture: raindropTextures) {
        // make sure the textures and raindrops correspond here; theoritically they should
        batch.draw(texture, raindrop.x, raindrop.y); 
   }

   Iterator<Rectangle> iter = raindrops.iterator();
   Iterator<Texture> iter2 = raindropTextures.iterator();
   //later
   iter.remove()
   iter2.remove()