Spawning random different objects at random locations

Question

I am making a game where there are different objects fall from the upper part of the screen to the lower part of the screen. I am having problems with how can I choose what TextureRegion randomly to be spawned and not to change the already spawned TextureRegions. When I run the game lets say that the electronRegion is spawned first then when the next is spawned and let's say it's an antiprotonRegion the first electronRegion changes to antiprotonRegion that I don't want.

Here is my game class:

public class GameScreenTest implements Screen {
...

@Override
public void render(float delta) {
    camera.update();

    game.batch.setProjectionMatrix(camera.combined);
    game.batch.begin();
    game.batch.disableBlending();
    game.batch.draw(background, 0, 0);
    game.batch.enableBlending();
    for(Particles particle: particles) {
        particlesControl.draw(particle.x, particle.y);
    }
    game.batch.end();

    if(TimeUtils.millis() - lastDropTime > 500) {
        particlesControl.spawn();
        particlesControl.update();
    }

    Iterator<Particles> iter = particles.iterator();
    while(iter.hasNext()) {
        Particles particle = iter.next();
        particle.y -= 200 * Gdx.graphics.getDeltaTime();
        if(particle.y + particle.height < 0) {
            iter.remove();
        }
    }
}

...

private class Particles {

    private int width;
    private int height;
    private int x;
    private int y;

    private Particles() {
    }

    private void spawn() {
        Particles particle = new Particles();
        particle.x = MathUtils.random(0, 480 - width);
        particle.y = 800;
        particle.width = width;
        particle.height = height;
        particles.add(particle);
        lastDropTime = TimeUtils.millis();
    }

    private void update() {
        choice = MathUtils.random(1, 4);
        switch(choice) {
            case 1:
                chosen = new TextureRegion(protonRegion);
                width = 75;
                height = 75;
                break;
            case 2:
                chosen = new TextureRegion(electronRegion);
                width = 75 / 2;
                height = 75 / 2;
                break;
            case 3:
                chosen = new TextureRegion(antiprotonRegion);
                width = 75;
                height = 75;
                break;
            case 4:
                chosen = new TextureRegion(antielectronRegion);
                width = 75 / 2;
                height = 75 / 2;
                break;
        }
    }
    private void draw(int x, int y) {
        game.batch.draw(chosen, x, y, width, height);
    }
}

I want to know why does all the spawned objects change every time a random choice is taken, and of course, how to solve this problem. Thank You.

Answer 1

Tray this:

public class GameScreenTest implements Screen {

    final AntimatterBlast game;

    private Texture gameObjects;

    private TextureRegion electronRegion;
    private TextureRegion antielectronRegion;
    private TextureRegion protonRegion;
    private TextureRegion antiprotonRegion;

//===========================================//
//remove private TextureRegion chosen;
//===========================================//

    private TextureRegion background;

    private Music gameMusic;

    private OrthographicCamera camera;

    private Array<Particles> particles;

    private Particles particlesControl;

    private long lastDropTime;

    private int choice;

    public GameScreenTest(final AntimatterBlast game) {
    this.game = game;

    gameObjects = new Texture(Gdx.files.internal("GameObjects.png"));

    electronRegion = new TextureRegion(gameObjects, 105, 103, 50, 50);

    antielectronRegion = new TextureRegion(gameObjects, 105, 155, 46, 46);

    protonRegion = new TextureRegion(gameObjects, 6, 6, 100, 100);

    antiprotonRegion = new TextureRegion(gameObjects, 6, 108, 90, 90);

    background = new TextureRegion(gameObjects, 0, 204, 480, 800);

    gameMusic = Gdx.audio.newMusic(Gdx.files.internal("DST-ElektroHauz.mp3"));

    gameMusic.setLooping(true);

    camera = new OrthographicCamera();

    camera.setToOrtho(false, 480, 800);

    particles = new Array<Particles>();

    particlesControl = new Particles();

//===========================================//
//choice = MathUtils.random(1, 4);           //remove
//chosen = new TextureRegion(protonRegion);  //remove
//===========================================//

}

@Override
public void render(float delta) {
    camera.update();

    game.batch.setProjectionMatrix(camera.combined);
    game.batch.begin();
    game.batch.disableBlending();
    game.batch.draw(background, 0, 0);
    game.batch.enableBlending();

    for(Particles particle: particles) {
    //===========================================//
    particlesControl.draw(particle.chosen, particle.x, particle.y);
    //change
    //particlesControl.draw(particle.x, particle.y);
    //===========================================//
    }

    game.batch.end();

    if(TimeUtils.millis() - lastDropTime > 500) {

    //===========================================//
    particlesControl.spawn();
    //===========================================//

    //===========================================//
    //remove particlesControl.update();
    //===========================================//
    }

        Iterator<Particles> iter = particles.iterator();
        while(iter.hasNext()) {
            Particles particle = iter.next();
            particle.y -= 200 * Gdx.graphics.getDeltaTime();
            if(particle.y + particle.height < 0) {
                iter.remove();
            }
        }


    }

    @Override
    public void resize(int width, int height) {
    }

    @Override
    public void show() {
        gameMusic.play();
        particlesControl.spawn();
    }

    @Override
    public void hide() {
    }

    @Override
    public void pause() {
    }

    @Override
    public void resume() {
    }

    @Override
    public void dispose() {
        gameObjects.dispose();
        gameMusic.dispose();
    }


    private class Particles {

        //===========================================//
        private TextureRegion chosen; //add variable
        //===========================================//

        private int width;
        private int height;
        private int x;
        private int y;

        private Particles() {

        }

        private void spawn() {

            Particles particle = new Particles();
            particle.x = MathUtils.random(0, 480 - width);
            particle.y = 800;
            particle.width = width;
            particle.height = height;

            //===========================================//
            particle.selectTexture();
            //===========================================//

            lastDropTime = TimeUtils.millis();

            //===========================================//
            selectTexture(); //add call
            //===========================================//

            particles.add(particle);
        }

        //===========================================//
        private void selectTexture() { //change name, but is not nesesari
        //===========================================//
            choice = MathUtils.random(1, 4);
            switch(choice) {
                case 1:
                   //===========================================//
                   //change
                   //chosen = new TextureRegion(antielectronRegion);
                   //if you are not going to change or modific TextureRegion 
                   //independet other the textureRegion, 
                   //I think you could use it well.It is just an idea
                   chosen = protonRegion;
                   //===========================================//

                    width = 75;
                    height = 75;
                    break;
                case 2:
                   //===========================================//
                   //change
                   //chosen = new TextureRegion(antielectronRegion);
                   //if you are not going to change or modific TextureRegion 
                   //independet other the textureRegion, 
                   //I think you could use it well.It is just an idea
                   chosen = electronRegion;
                   //===========================================//

                    width = 75 / 2;
                    height = 75 / 2;
                    break;
                case 3:
                   //===========================================//
                   //change
                   //chosen = new TextureRegion(antielectronRegion);
                   //if you are not going to change or modific TextureRegion 
                   //independet other the textureRegion, 
                   //I think you could use it well.It is just an idea
                   chosen = antiprotonRegion;
                   //===========================================//

                    width = 75;
                    height = 75;
                    break;
                case 4:
                   //===========================================//
                   //change
                   //chosen = new TextureRegion(antielectronRegion);
                   //if you are not going to change or modific TextureRegion 
                   //independet other the textureRegion, 
                   //I think you could use it well.It is just an idea
                   chosen = antielectronRegion;
                   //===========================================//

                    width = 75 / 2;
                    height = 75 / 2;
                    break;
            }
        }
        //===========================================//
        private void draw(TextureRegion chosen, int x, int y) {
            game.batch.draw(chosen, x, y, width, height);
        //===========================================//
        }
    }
}

Answer 2

Like I said in the previous comment the texture (chosen) is in the GameScreenTest and you are using it in the inner class so every single instance of the Particles class will share the same texture.

---

Not error causing but it might help you to organize the code and make it more readable and by all means you are not obligated to make them just take them as suggestions:

Naming conventions
Naming the class Particles make it seem like the class represents more than 1 Particle, but in fact it represents a single Particle maybe name it only Particle.

Separating the game logic
Make the Particle class deal only with its own problems and don't use it to generate other particles and to add it to an outer class.

Using the constructor since it is already there
Give the Particle the texture that it should use and maybe the coordinates.

Drawing "dead" particle
You are drawing first and asking questions later depending on your game it might feel weird since you will always draw a frame while it no longer exists.

Not really sure on this one
But you might be able to reuse the textures regions instead of a creating a new one of the same texture for every single particle