Question

I am developing a game in java just for fun. It is a ball brick breaking game of some sort.

Here is a level, when the ball hits one of the Orange bricks I would like to create a chain reaction to explode all other bricks that are NOT gray(unbreakable) and are within reach of the brick being exploded.

So it would clear out everything in this level without the gray bricks.

I am thinking I should ask the brick that is being exploded for other bricks to the LEFT, RIGHT, UP, and DOWN of that brick then start the same process with those cells.

---

//NOTE TO SELF: read up on Enums and List

When a explosive cell is hit with the ball it calls the explodeMyAdjecentCells();

//This is in the Cell class

public void explodeMyAdjecentCells() {

    exploded = true;

    ballGame.breakCell(x, y, imageURL[thickness - 1][0]);

    cellBlocks.explodeCell(getX() - getWidth(),getY());
    cellBlocks.explodeCell(getX() + getWidth(),getY());
    cellBlocks.explodeCell(getX(),getY() - getHeight());
    cellBlocks.explodeCell(getX(),getY() + getHeight());

    remove();

    ballGame.playSound("src\\ballgame\\Sound\\cellBrakes.wav", 100.0f, 0.0f, false, 0.0d);

}

//This is the CellHandler->(CellBlocks)

public void explodeCell(int _X, int _Y) {


    for(int c = 0; c < cells.length; c++){

        if(cells[c] != null && !cells[c].hasExploded()) {

            if(cells[c].getX() == _X && cells[c].getY() == _Y) {

                int type = cells[c].getThickness();

                if(type != 7 && type != 6 && type != 2) {

                    cells[c].explodeMyAdjecentCells();
                }


            }
        }
    }

}

It successfully removes my all adjacent cells,

But in the explodeMyAdjecentCells() method, I have this line of code

ballGame.breakCell(x, y, imageURL[thickness - 1][0]);

//

This line tells the ParticleHandler to create 25 small images(particles) of the exploded cell.

Tough all my cells are removed the particleHandler do not create particles for all the removed cells.

---

The problem was solved youst now, its really stupid.
I had set particleHandler to create max 1500 particles. My god how did i not see that!

private int particleCellsMax = 1500;
private int particleCellsMax = 2500;

thx for all the help people, I will upload the source for creating the particles youst for fun if anyone needs it.

The source code for splitting image into parts was taken from:
Kalani’s Tech Blog

//Particle Handler

public void breakCell(int _X, int _Y, String URL) {

    File file = new File(URL);

    try {

        FileInputStream fis = new FileInputStream(file);
        BufferedImage image = ImageIO.read(fis);

    int rows = 5;
    int colums = 5;

    int parts = rows * colums;

    int partWidth = image.getWidth() / colums;
    int partHeight = image.getHeight() / rows;

    int count = 0;

    BufferedImage imgs[] = new BufferedImage[parts];

    for(int x = 0; x < colums; x++) {

        for(int y = 0; y < rows; y++) {

            imgs[count] = new BufferedImage(partWidth, partHeight, image.getType());

            Graphics2D g = imgs[count++].createGraphics();

            g.drawImage(image, 0, 0, partWidth, partHeight, partWidth * y, partHeight * x, partWidth * y + partWidth, partHeight * x + partHeight, null);
            g.dispose();
        }
    }

    int numParts = imgs.length;
    int c = 0;

    for(int iy = 0; iy < rows; iy ++) {

        for(int ix = 0; ix < colums; ix++) {

            if(c < numParts) {

                Image imagePart = Toolkit.getDefaultToolkit().createImage(imgs[c].getSource());
                createCellPart(_X + ((image.getWidth() / colums) * ix), _Y + ((image.getHeight() / rows) * iy), c, imagePart);

                c++;

            } else {

                break;
            }
        }
    }


    } catch(IOException io) {}
}

Answer 1

I would imagine a method that would recursively get all touching cells of a similar color.
Then you can operate on that list (of all touching blocks) pretty easily and break all the ones are haven’t been broken.

Also note that your getAdjentCell() method has side effects (it does the breaking) which isn’t very intuitive based on the name.

// I agree with Matt that color (or type) should probably be an enum, 
// or at least a class.  int isn't very descriptive
public enum CellType { GRAY, RED, ORANGE }

public class Cell{
....
    public final CellType type;

    /**
     * Recursively find all adjacent cells that have the same type as this one.
     */
    public List<Cell> getTouchingSimilarCells() {
        List<Cell> result = new ArrayList<Cell>();
        result.add(this);
        for (Cell c : getAdjecentCells()) {
            if (c != null && c.type == this.type) {
                result.addAll(c.getTouchingSimilarCells());
            }
        }
        return result;
    }

    /**
     * Get the 4 adjacent cells (above, below, left and right).<br/>
     * NOTE: a cell may be null in the list if it does not exist.
     */
    public List<Cell> getAdjecentCells() {
        List<Cell> result = new ArrayList<Cell>();
        result.add(cellBlock(this.getX() + 1, this.getY()));
        result.add(cellBlock(this.getX() - 1, this.getY()));
        result.add(cellBlock(this.getX(), this.getY() + 1));
        result.add(cellBlock(this.getX(), this.getY() - 1));
        return result;
    }
}