0

I have been making a brick breaker game recently however I have ran into a few issues. The issue I am having is trying to remove a brick from the arraylist. I first did this by using bricks.remove(i) (i stands for the brick I want to remove) however of course this causes issues as it makes the array shift to the left meaning the rest of the bricks are mucked up. The second idea I tried was setting it to null however this just caused the game to crash when a brick was meant to be destroyed.

Does anyone have a solution which will help me remove the bricks without the array shifting?

This is the method which creates the bricks into the array:

public void createGameObjects()
{
    synchronized( Model.class )
    {
        ball   = new GameObj(W/2, H/2, BALL_SIZE, BALL_SIZE, Colour.RED );
        bat    = new GameObj(210, H - BRICK_HEIGHT*1.5f, BAT_WIDTH, 
            BRICK_HEIGHT/4, Colour.GRAY);
        bricks = new ArrayList<>();


        int pos = 50;
        int pos2 = 50;
        //first row
        for ( int i = 0; i < 10; i++){
            bricks.add(new GameObj(pos,300, BRICK_HEIGHT, BRICK_WIDTH, Colour.ORANGE));
            pos = pos + 50;
        }
        //Second row
        pos = 50;
        for ( int i = 0; i < 10; i++){
            bricks.add(new GameObj(pos,270, BRICK_HEIGHT, BRICK_WIDTH, Colour.RED));
            pos = pos + 50;
        }
        //Third row
        pos = 50;
        for ( int i = 0; i < 10; i++){
            bricks.add(new GameObj(pos,240, BRICK_HEIGHT, BRICK_WIDTH, Colour.GRAY));
            pos = pos + 50;
        }
        // Blue bricks for bricks to be hit twice
        pos = 50;
        for ( int i = 0; i < 10; i++){
            bricks.add(new GameObj(pos,300, BRICK_HEIGHT, BRICK_WIDTH, Colour.BLUE));
            pos = pos + 50;
        }

        // Greenbreaks out of view to increase the size of array
        for ( int i = 0; i < 60; i++){ 
            bricks.add(new GameObj(0,0, BRICK_HEIGHT, BRICK_WIDTH, Colour.GREEN));

        }

    }
}

This method is which declares the Gameobj from the array list of the bricks and also detects the ball hitting the bricks. (This is the method where I am struggling to remove the bricks from):

public void runAsSeparateThread()
    {
        final float S = 3; // Units to move (Speed)
        try
        {
            synchronized ( Model.class ) // Make thread safe
            {
                GameObj       ball   = getBall();     // Ball in game
                GameObj       bat    = getBat();      // Bat
                List<GameObj> bricks = getBricks();   // Bricks


            }
            while (runGame)
            {
                synchronized ( Model.class ) // Make thread safe
                {
                    float x = ball.getX();  // Current x,y position
                    float y = ball.getY();

                    // Deal with possible edge of board hit
                    if (x >= W - B - BALL_SIZE)  ball.changeDirectionX();
                    if (x <= 0 + B            )  ball.changeDirectionX();
                    if (y >= H - B - BALL_SIZE)  // Bottom
                    { 
                        ball.changeDirectionY(); addToScore( HIT_BOTTOM ); 
                    }
                    if (y <= 0 + M            )  ball.changeDirectionY();

                    // As only a hit on the bat/ball is detected it is 
                    //  assumed to be on the top or bottom of the object.
                    // A hit on the left or right of the object
                    //  has an interesting affect

                    String counter1 = "" + counter;
                    // Yellow Bricks
                    GameObj brick1 = bricks.get(0);
                    GameObj brick2 = bricks.get(1);
                    GameObj brick3 = bricks.get(2);
                    GameObj brick4 = bricks.get(3);
                    GameObj brick5 = bricks.get(4);
                    GameObj brick6 = bricks.get(5);
                    GameObj brick7 = bricks.get(6);
                    GameObj brick8 = bricks.get(7);
                    GameObj brick9 = bricks.get(8);
                    GameObj brick10 = bricks.get(9);
                    GameObj brick11 = bricks.get(10);
                    GameObj brick12 = bricks.get(11);
                    GameObj brick13 = bricks.get(12);
                    GameObj brick14 = bricks.get(13);
                    GameObj brick15 = bricks.get(14);
                    GameObj brick16 = bricks.get(15);
                    GameObj brick17 = bricks.get(16);
                    GameObj brick18 = bricks.get(17);
                    GameObj brick19 = bricks.get(18);
                    GameObj brick20 = bricks.get(19);
                    GameObj brick21 = bricks.get(20);
                    GameObj brick22 = bricks.get(21);
                    GameObj brick23 = bricks.get(22);
                    GameObj brick24 = bricks.get(23);
                    GameObj brick25 = bricks.get(24);
                    GameObj brick26 = bricks.get(25);
                    GameObj brick27 = bricks.get(26);
                    GameObj brick28 = bricks.get(27);
                    GameObj brick29 = bricks.get(28);
                    GameObj brick30 = bricks.get(29);
                    // Blue Bricks
                    GameObj brick31 = bricks.get(30);
                    GameObj brick32 = bricks.get(31);
                    GameObj brick33 = bricks.get(32);
                    GameObj brick34 = bricks.get(33);
                    GameObj brick35 = bricks.get(34);
                    GameObj brick36 = bricks.get(35);
                    GameObj brick37 = bricks.get(36);
                    GameObj brick38 = bricks.get(37);
                    GameObj brick39 = bricks.get(38);
                    GameObj brick40 = bricks.get(39);

                    if ( ball.hitBy(brick1)){
                        ball.changeDirectionY();
                        if (alreadyHit1 == true){
                            bricks.remove(0);
                            addToScore( HIT_BRICK  );
                            counter = counter - 1;
                            Debug.trace(counter1);

                        }
                    }
                    if ( ball.hitBy(brick2)){
                        ball.changeDirectionY();
                        if (alreadyHit2 == true){
                            bricks.remove(1);
                            addToScore( HIT_BRICK  ); 
                            counter = counter - 1;
                            Debug.trace(counter1);
                        }
                    }
                    if ( ball.hitBy(brick3)){
                        ball.changeDirectionY();
                        if (alreadyHit3 == true){
                            bricks.remove(2);
                            addToScore( HIT_BRICK  ); 
                            counter = counter - 1;
                            Debug.trace(counter1);
                        }
                    }
                    if ( ball.hitBy(brick4)){
                        ball.changeDirectionY();
                        if (alreadyHit4 == true){
                            bricks.remove(3);
                            addToScore( HIT_BRICK  );
                            counter = counter - 1;
                            Debug.trace(counter1);
                        }
                    }
                    if ( ball.hitBy(brick5)){
                        ball.changeDirectionY();
                        if (alreadyHit5 == true){
                            bricks.remove(4);
                            addToScore( HIT_BRICK  );
                            counter = counter - 1;
                            Debug.trace(counter1);
                        }
                    }  
                    if ( ball.hitBy(brick6)){
                        ball.changeDirectionY();
                        if (alreadyHit6 == true){
                            bricks.remove(5);
                            addToScore( HIT_BRICK  ); 
                            counter = counter - 1;
                            Debug.trace(counter1);
                        }
                    }
                    if ( ball.hitBy(brick7)){
                        ball.changeDirectionY();
                        if (alreadyHit7 == true){
                            bricks.remove(6);
                            addToScore( HIT_BRICK  ); 
                            counter = counter - 1;
                            Debug.trace(counter1);
                        }
                    }
                    if ( ball.hitBy(brick8)){
                        ball.changeDirectionY();
                        if (alreadyHit8 == true){
                            bricks.remove(7);
                            addToScore( HIT_BRICK  ); 
                            counter = counter - 1;
                            Debug.trace(counter1);
                        }
                    }
                    if ( ball.hitBy(brick9)){
                        ball.changeDirectionY();
                        if (alreadyHit9 == true){
                            bricks.remove(8);
                            addToScore( HIT_BRICK  ); 
                            counter = counter - 1;
                            Debug.trace(counter1);
                        }
                    }
                    if ( ball.hitBy(brick10)){
                        ball.changeDirectionY();
                        if (alreadyHit10 == true){
                            bricks.remove(9);
                            addToScore( HIT_BRICK  ); 
                            counter = counter - 1;
                            Debug.trace(counter1);
                        }
                    }
                    if ( ball.hitBy(brick11)){
                        ball.changeDirectionY();
                        bricks.remove(10);
                        addToScore( HIT_BRICK  ); 
                        counter = counter - 1;
                        Debug.trace(counter1);
                    }
                    if ( ball.hitBy(brick12)){
                        ball.changeDirectionY();
                        bricks.remove(11);
                        addToScore( HIT_BRICK  ); 
                        counter = counter - 1;
                        Debug.trace(counter1);
                    }
                    if ( ball.hitBy(brick13)){
                        ball.changeDirectionY();

                        bricks.remove(12);
                        addToScore( HIT_BRICK  );
                        counter = counter - 1;
                        Debug.trace(counter1);

                    }
                    if ( ball.hitBy(brick14)){
                        ball.changeDirectionY();
                        bricks.remove(13);
                        addToScore( HIT_BRICK  ); 
                        counter = counter - 1;
                        Debug.trace(counter1);

                    }
                    if ( ball.hitBy(brick15)){
                        ball.changeDirectionY();
                        bricks.remove(14);
                        addToScore( HIT_BRICK  ); 
                        counter = counter - 1;
                        Debug.trace(counter1);
                    }
                    if ( ball.hitBy(brick16)){
                        ball.changeDirectionY();

                        bricks.remove(15);
                        addToScore( HIT_BRICK  ); 
                        counter = counter - 1;
                        Debug.trace(counter1);

                    }
                    if ( ball.hitBy(brick17)){
                        ball.changeDirectionY();
                        bricks.remove(16);
                        addToScore( HIT_BRICK  );
                        counter = counter - 1;
                        Debug.trace(counter1);
                    }
                    if ( ball.hitBy(brick18)){
                        ball.changeDirectionY();
                        bricks.remove(17);
                        addToScore( HIT_BRICK  );
                        counter = counter - 1;
                        Debug.trace(counter1);
                    }
                    if ( ball.hitBy(brick19)){
                        ball.changeDirectionY();

                        bricks.remove(18);
                        addToScore( HIT_BRICK  ); 
                        counter = counter - 1;
                        Debug.trace(counter1);

                    }
                    if ( ball.hitBy(brick20)){
                        ball.changeDirectionY();
                        bricks.remove(19);
                        addToScore( HIT_BRICK  );
                        counter = counter - 1;
                        Debug.trace(counter1);
                    }
                    if ( ball.hitBy(brick21)){
                        ball.changeDirectionY();
                        bricks.remove(20);
                        addToScore( HIT_BRICK  ); 
                        counter = counter - 1;
                        Debug.trace(counter1);
                    }
                    if ( ball.hitBy(brick22)){
                        ball.changeDirectionY();

                        bricks.remove(21);
                        addToScore( HIT_BRICK  ); 
                        counter = counter - 1;
                        Debug.trace(counter1);

                    }
                    if ( ball.hitBy(brick23)){
                        ball.changeDirectionY();
                        bricks.remove(22);
                        addToScore( HIT_BRICK  ); 
                        counter = counter - 1;
                        Debug.trace(counter1);
                    }
                    if ( ball.hitBy(brick24)){
                        ball.changeDirectionY();
                        bricks.remove(23);
                        addToScore( HIT_BRICK  ); 
                        counter = counter - 1;
                        Debug.trace(counter1);
                    }
                    if ( ball.hitBy(brick25)){
                        ball.changeDirectionY();

                        bricks.remove(24);
                        addToScore( HIT_BRICK  ); 
                        counter = counter - 1;
                        Debug.trace(counter1);

                    }
                    if ( ball.hitBy(brick26)){
                        ball.changeDirectionY();
                        bricks.remove(25);
                        addToScore( HIT_BRICK  );
                        counter = counter - 1;
                        Debug.trace(counter1);
                    }
                    if ( ball.hitBy(brick27)){
                        ball.changeDirectionY();
                        bricks.remove(26);
                        addToScore( HIT_BRICK  );
                        counter = counter - 1;
                        Debug.trace(counter1);
                    }
                    if ( ball.hitBy(brick28)){
                        ball.changeDirectionY();

                        bricks.remove(27);
                        addToScore( HIT_BRICK  ); 
                        counter = counter - 1;
                        Debug.trace(counter1);

                    }
                    if ( ball.hitBy(brick29)){
                        ball.changeDirectionY();
                        bricks.remove(28);
                        addToScore( HIT_BRICK  );
                        counter = counter - 1;
                        Debug.trace(counter1);
                    }
                    if ( ball.hitBy(brick30)){
                        ball.changeDirectionY();
                        bricks.remove(29);
                        addToScore( HIT_BRICK  );
                        counter = counter - 1;
                        Debug.trace(counter1);
                    }
                    //Blue bricks
                    if ( ball.hitBy(brick31)){
                        ball.changeDirectionY();
                        brick31 = new GameObj(50,350, BRICK_HEIGHT, BRICK_WIDTH, Colour.GREEN);
                        alreadyHit1 = true;
                        addToScore( HIT_BRICK  );
                        counter = counter - 1;
                        Debug.trace(counter1);
                    }
                    if ( ball.hitBy(brick32)){
                        ball.changeDirectionY();
                        bricks.remove(31);
                        alreadyHit2 = true;
                        addToScore( HIT_BRICK  );
                        counter = counter - 1;
                        Debug.trace(counter1);
                    }
                    if ( ball.hitBy(brick33)){
                        ball.changeDirectionY();
                        bricks.remove(32);
                        alreadyHit3 = true;
                        addToScore( HIT_BRICK  );
                        counter = counter - 1;
                        Debug.trace(counter1);
                    }
                    if ( ball.hitBy(brick34)){
                        ball.changeDirectionY();
                        bricks.remove(33);
                        alreadyHit4 = true;
                        addToScore( HIT_BRICK  );
                        counter = counter - 1;
                        Debug.trace(counter1);
                    }
                    if ( ball.hitBy(brick35)){
                        ball.changeDirectionY();
                        bricks.remove(34);
                        alreadyHit5 = true;
                        addToScore( HIT_BRICK  );
                        counter = counter - 1;
                        Debug.trace(counter1);
                    }
                    if ( ball.hitBy(brick36)){
                        ball.changeDirectionY();
                        bricks.remove(35);
                        alreadyHit6 = true;
                        addToScore( HIT_BRICK  );
                        counter = counter - 1;
                        Debug.trace(counter1);
                    }
                    if ( ball.hitBy(brick37)){
                        ball.changeDirectionY();
                        bricks.remove(36);
                        alreadyHit7 = true;
                        addToScore( HIT_BRICK  );
                        counter = counter - 1;
                        Debug.trace(counter1);
                    }
                    if ( ball.hitBy(brick38)){
                        ball.changeDirectionY();
                        bricks.remove(37);
                        alreadyHit8 = true;
                        addToScore( HIT_BRICK  );
                        counter = counter - 1;
                        Debug.trace(counter1);
                    }
                    if ( ball.hitBy(brick39)){
                        ball.changeDirectionY();
                        bricks.remove(38);
                        alreadyHit9 = true;
                        addToScore( HIT_BRICK  );
                        counter = counter - 1;
                        Debug.trace(counter1);
                    }
                    if ( ball.hitBy(brick40)){
                        ball.changeDirectionY();
                        bricks.remove(39);
                        alreadyHit10 = true;
                        addToScore( HIT_BRICK  );
                        counter = counter - 1;
                        Debug.trace(counter1);
                    }

                    if ( counter < 1){
                        addToScore( HIT_BRICK  );
                        Debug.trace("Well done! you have completed BreakOut!");
                        break;
                    }

                    if ( ball.hitBy(bat) )
                        ball.changeDirectionY();

                }
                modelChanged();      // Model changed refresh screen
                Thread.sleep( fast ? 2 : 20 );
                ball.moveX(S);  ball.moveY(S);
            }
        } catch (Exception e) 
        { 
            Debug.error("Model.runAsSeparateThread - Error\n%s", 
                e.getMessage() );
        }
    }

The bit in the method above where I am trying to remove bricks is shown in the example below:

if ( ball.hitBy(brick1)){
                        ball.changeDirectionY();
                        if (alreadyHit1 == true){
                            bricks.remove(0);
                            addToScore( HIT_BRICK  );
                            counter = counter - 1;
                            Debug.trace(counter1);

                        }
                    }

The alreadyHit1 is a boolean which turns to true when a blue brick above this brick is destroyed allowing this brick to be destroyed.

Thank you and hope you can help James Holliday

rene
  • 37,946
  • 78
  • 99
  • 132
  • I would say that setting to `null` is fine, then you just need to check whether en element is `null` before doing anything with it (or a `NullPointerException` is likely, probably what you experienced?) – Ole V.V. Apr 20 '17 at 12:01
  • That is the error I receive when I set it to null, how would I adjust this? – Cheeseslinger123 Apr 20 '17 at 12:11
  • [What is a NullPointerException, and how do I fix it?](http://stackoverflow.com/questions/218384/what-is-a-nullpointerexception-and-how-do-i-fix-it) – Ole V.V. Apr 20 '17 at 12:13
  • 2
    Please don't vandalize your posts. – rene Feb 04 '18 at 13:28

1 Answers1

1

The list will be resized when you add/remove elements in it. You can use an array instead. The array is of fixed length. So you can "remove" bricks by setting the element to null.

If you don't know the number of bricks initially you can create the array by populating an ArrayList, and then invoking toArray

EDIT: Also, now I see that you've hardcoded the cases of each brick being hit separately. You need to take a step back and learn about loops/iteartions.

For instance, this is a method to iterate through all the bricks (provided you have a list of bricks named bricksList):

GameObj[] bricks = bricksList.toArray(new GameObj[bricksList.size()]);

for (int i = 0; i < bricks.length; i++) {
    if (ball.hitBy(bricks[i]) {
        ball.chageDirectionY();
        // more code here
    }
}
birgersp
  • 2,907
  • 4
  • 25
  • 53
  • Could you possibly provide an example of how I would go around doing this? Thank you – Cheeseslinger123 Apr 20 '17 at 11:40
  • See my edit, take a look here: https://www.tutorialspoint.com/java/java_loop_control.htm – birgersp Apr 20 '17 at 11:54
  • The example in your edit does not work. To make the toArray line work I have had to change it to `GameObj[] bricks2 = bricks.toArray(new GameObj[bricks.size()]);` however when it comes to the `ball.hitBy(bricks[i])` it throws a "array required" – Cheeseslinger123 Apr 20 '17 at 12:30
  • Right, `Brick` isn't actually a class. And, since you've renamed the array `bricks` to `bricks2`, you need to pass the new variable name instead. I wasn't trying to fix your code, I was trying to show you how to use iterations. Have a look at the tutorials. As for your question, the use of arrays instead of lists should be a viable solution. I'm not going to fix your code beyond that, at least not without a salary ;) – birgersp Apr 20 '17 at 12:37