Recursion error in GUI

2019-02-28 06:39发布

站内文章 / Java
69 0 0

问题:

I am creating a simple 9x9 grid for Minesweeper. One of the primary functions of this game is to have a recursion to check all the sides when the tile clicked has no bombs surrounding it. In the code attached below, I have been able to create a function that checks the upper and left side of the tile. If I add more directions, such as lower and right side, the program will crash and will not properly display the tiles. (Check the method countBorders under the line //MY MAIN PROBLEM)

//displays the main GUI package Minesweeper4;

public class mainFrame {

public static void main(String[] args) {
    new Grid().setVisible(true);
}

}

// the main code

package Minesweeper4;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.Random;
import javax.swing.*;

public class Grid extends JFrame implements ActionListener {

    private JPanel mainGrid;
    private JButton button1, button2;
    private JButton[][] buttons = new JButton[9][9];
    private String[][] mines = new String[9][9];
    private ArrayList<ParentSquare> parentSquare = new ArrayList<ParentSquare>();

    Random rand = new Random();

    NumberSquare numberSquare = new NumberSquare();
    MineSquare mineSquare = new MineSquare();

    public void addMines() {
        for (int j = 0; j < 9; j++) {
            for (int k = 0; k < 9; k++) {
                mines[j][k] = ".";
            }
        }
        for (int i = 0; i < 3; i++) {
            int temp_x = rand.nextInt(9);
            int temp_y = rand.nextInt(9);
            mines[temp_x][temp_y] = "x";
        }
    }

    public void showMines() {
        for (int x = 0; x < 9; x++) {
            for (int y = 0; y < 9; y++) {
                String temp = mines[x][y];
                if (temp.equals("x")) {
                    System.out.println("X: " + (x + 1) + " Y: " + (y + 1) + " Value: " + temp);
                }
            }
        }
    }

    public Grid() {
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setSize(500, 500);
        this.setTitle("Minesweeper 1.0");

        mainGrid = new JPanel();
        mainGrid.setLayout(new GridLayout(9, 9));
        this.add(mainGrid);

        button1 = new JButton("Boop");
        button2 = new JButton("Poop");

        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                buttons[i][j] = new JButton("");
                buttons[i][j].addActionListener(this);
                buttons[i][j].setBackground(Color.GRAY);
            }
        }

        for (int k = 0; k < 9; k++) {
            for (int l = 0; l < 9; l++) {
                mainGrid.add(buttons[k][l]);
            }
        }

        addMines();
        showMines();

    }

    public void countBorders(int x, int y) {
        int UL = 0, UU = 0, UR = 0, LL = 0, RR = 0, DL = 0, DD = 0, DR = 0, SUM = 0;

        if (x > 0) {
            UU = checkTile(x - 1, y);
        }
        if (y > 0) {
            LL = checkTile(x, y - 1);
        }
        if (y < 8) {
            RR = checkTile(x, y + 1);
        }
        if (x < 8) {
            DD = checkTile(x + 1, y);
        }
        if ((x > 0) && (y > 0)) {
            UL = checkTile(x - 1, y - 1);
        }

        if ((x > 0) && (y < 8)) {
            UR = checkTile(x - 1, y + 1);
        }

        if ((x < 8) && (y > 0)) {
            DL = checkTile(x + 1, y - 1);
        }

        if ((x < 8) && (y < 8)) {
            DR = checkTile(x + 1, y + 1);
        }

        SUM = UL + UU + UR + LL + RR + DL + DD + DR;

        printTile(x, y, SUM);

        if (SUM == 0) { //MY MAIN PROBLEM

//            if ((x > 0) && (y > 0)) {countBorders(x-1, y-1);}               //Upper left
            if (x > 0) {
                countBorders(x - 1, y);
            }                 //Upper 
//            if ((x > 0) && (y < 8)) {countBorders(x-1, y+1);}               //Upper right
            if (y > 0) {
                countBorders(x, y - 1);
            }                 //Left
//            if (y < 8)              {countBorders(x, y+1);}                 //Right
//            if ((x < 8) && (y > 0)) {countBorders(x+1, y-1);}               //Down Left
//            if (x < 8)              {countBorders(x+1, y);}                 //Down
//            if ((x < 8) && (y < 8)) {countBorders(x+1, y+1);}               //Down Right
        }

    }

    public void printTile(int x, int y, int SUM) {
        String text = Integer.toString(SUM);
        buttons[x][y].setText(text);
        buttons[x][y].setBackground(Color.CYAN);
    }

    public int checkTile(int x, int y) {
        String c = mines[x][y];
        if (c.equals("x")) {
            return 1;
        } else {
            return 0;
        }
    }

    public void click(int x, int y) {
        String mine = mines[x][y];
        if (mine.equals("x")) {
            System.out.println("Bomb!!!");
            buttons[x][y].setText("!");
            buttons[x][y].setBackground(Color.RED);
        } else {
            countBorders(x, y);
            System.out.println("Safe!!!");
//            buttons[x][y].setText("√");
//            buttons[x][y].setBackground(Color.WHITE);
        }

    }

    @Override
    public void actionPerformed(ActionEvent e) {
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                if (e.getSource() == buttons[i][j]) {
                    System.out.println("Clicked Tile X: " + (i + 1) + " Y: " + (j + 1));
                    //buttons[i][j].setText("!");
                    click(i, j);
                }
            }
        }
    }

}

Is there a way on how to fix this recursion problem? Thank you in advance and I'm really trying to learn Java. Have a nice day!

回答1:

Your error-causing recursion has no stopping logic that I can find, and what you need to do is to somehow check to make sure that a cell hasn't already been counted or pressed before re-counting it. Otherwise the code risks throwing a stackoverflow error. This will require giving the cells being counted some state that would tell you this information, that would tell you if the cell has already been counted.

For an example of a successful program that does this logic, feel free to look at my Swing GUI example, one I created 5 years ago. In this code, I've got a class, MineCellModel, that provides the logic (not the GUI) for a single mine sweeper cell, and the class contains a boolean field, pressed, that is false until the cell is "pressed", either by the user pressing the equivalent button, or recursively in the model's logic. If the cell is pressed, if the boolean is true, the recursion stops with this cell.

You can find the code here: Minesweeper Action Events. It's an old program, and so I apologize for any concepts or code that may be off.

Running the code results in this:

Here's the code present in a single file:

import java.awt.CardLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JSeparator;
import javax.swing.SwingConstants;
import javax.swing.event.SwingPropertyChangeSupport;

@SuppressWarnings("serial")
public class MineSweeper {
    private JPanel mainPanel = new JPanel();
    private MineCellGrid mineCellGrid;
    private JButton resetButton = new JButton("Reset");

    public MineSweeper(int rows, int cols, int mineTotal) {
        mainPanel.setLayout(new BoxLayout(mainPanel, BoxLayout.PAGE_AXIS));
        mineCellGrid = new MineCellGrid(rows, cols, mineTotal);

        resetButton.setMnemonic(KeyEvent.VK_R);
        resetButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                mineCellGrid.reset();
            }
        });

        mainPanel.add(mineCellGrid);
        mainPanel.add(new JSeparator());
        mainPanel.add(new JPanel() {
            {
                add(resetButton);
            }
        });
    }

    private JPanel getMainPanel() {
        return mainPanel;
    }

    private static void createAndShowUI() {
        JFrame frame = new JFrame("MineSweeper");
        // frame.getContentPane().add(new MineSweeper(20, 20,
        // 44).getMainPanel());
        frame.getContentPane().add(new MineSweeper(12, 12, 13).getMainPanel());
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.pack();
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
    }

    public static void main(String[] args) {
        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                createAndShowUI();
            }
        });
    }
}

@SuppressWarnings("serial")
class MineCellGrid extends JPanel {
    private MineCellGridModel model;
    private List<MineCell> mineCells = new ArrayList<MineCell>();

    public MineCellGrid(final int maxRows, final int maxCols, int mineNumber) {
        model = new MineCellGridModel(maxRows, maxCols, mineNumber);
        setLayout(new GridLayout(maxRows, maxCols));

        for (int row = 0; row < maxRows; row++) {
            for (int col = 0; col < maxCols; col++) {
                MineCell mineCell = new MineCell(row, col);
                add(mineCell);
                mineCells.add(mineCell);
                model.add(mineCell.getModel(), row, col);
            }
        }

        reset();
    }

    public void reset() {
        model.reset();
        for (MineCell mineCell : mineCells) {
            mineCell.reset();
        }
    }
}

class MineCellGridModel {
    private MineCellModel[][] cellModelGrid;
    private List<Boolean> mineList = new ArrayList<Boolean>();
    private CellModelPropertyChangeListener cellModelPropChangeListener = new CellModelPropertyChangeListener();
    private int maxRows;
    private int maxCols;
    private int mineNumber;
    private int buttonsRemaining;

    public MineCellGridModel(final int maxRows, final int maxCols, int mineNumber) {
        this.maxRows = maxRows;
        this.maxCols = maxCols;
        this.mineNumber = mineNumber;
        for (int i = 0; i < maxRows * maxCols; i++) {
            mineList.add((i < mineNumber) ? true : false);
        }
        cellModelGrid = new MineCellModel[maxRows][maxCols];
        buttonsRemaining = (maxRows * maxCols) - mineNumber;
    }

    public void add(MineCellModel model, int row, int col) {
        cellModelGrid[row][col] = model;
        model.addPropertyChangeListener(cellModelPropChangeListener);
    }

    public void reset() {
        buttonsRemaining = (maxRows * maxCols) - mineNumber;

        // randomize the mine location
        Collections.shuffle(mineList);
        // reset the model grid and set mines
        for (int r = 0; r < cellModelGrid.length; r++) {
            for (int c = 0; c < cellModelGrid[r].length; c++) {
                cellModelGrid[r][c].reset();
                cellModelGrid[r][c].setMined(mineList.get(r * cellModelGrid[r].length + c));
            }
        }
        // advance value property of all neighbors of a mined cell
        for (int r = 0; r < cellModelGrid.length; r++) {
            for (int c = 0; c < cellModelGrid[r].length; c++) {
                if (cellModelGrid[r][c].isMined()) {
                    int rMin = Math.max(r - 1, 0);
                    int cMin = Math.max(c - 1, 0);
                    int rMax = Math.min(r + 1, cellModelGrid.length - 1);
                    int cMax = Math.min(c + 1, cellModelGrid[r].length - 1);
                    for (int row2 = rMin; row2 <= rMax; row2++) {
                        for (int col2 = cMin; col2 <= cMax; col2++) {
                            cellModelGrid[row2][col2].incrementValue();
                        }
                    }
                }
            }
        }
    }

    private class CellModelPropertyChangeListener implements PropertyChangeListener {

        public void propertyChange(PropertyChangeEvent evt) {
            MineCellModel model = (MineCellModel) evt.getSource();
            int row = model.getRow();
            int col = model.getCol();

            if (evt.getPropertyName().equals(MineCellModel.BUTTON_PRESSED)) {
                if (cellModelGrid[row][col].isMineBlown()) {
                    mineBlown();
                } else {
                    buttonsRemaining--;
                    if (buttonsRemaining <= 0) {
                        JOptionPane.showMessageDialog(null, "You've Won!!!", "Congratulations",
                                JOptionPane.PLAIN_MESSAGE);
                    }
                    if (cellModelGrid[row][col].getValue() == 0) {
                        zeroValuePress(row, col);
                    }
                }
            }
        }

        private void mineBlown() {
            for (int r = 0; r < cellModelGrid.length; r++) {
                for (int c = 0; c < cellModelGrid[r].length; c++) {
                    MineCellModel model = cellModelGrid[r][c];
                    if (model.isMined()) {
                        model.setMineBlown(true);
                    }
                }
            }

        }

        private void zeroValuePress(int row, int col) {
            int rMin = Math.max(row - 1, 0);
            int cMin = Math.max(col - 1, 0);
            int rMax = Math.min(row + 1, cellModelGrid.length - 1);
            int cMax = Math.min(col + 1, cellModelGrid[row].length - 1);
            for (int row2 = rMin; row2 <= rMax; row2++) {
                for (int col2 = cMin; col2 <= cMax; col2++) {
                    cellModelGrid[row2][col2].pressedAction();
                }
            }
        }
    }
}

@SuppressWarnings("serial")
class MineCell extends JPanel {
    private static final String LABEL = "label";
    private static final String BUTTON = "button";
    private static final int PS_WIDTH = 24;
    private static final int PS_HEIGHT = PS_WIDTH;
    private static final float LABEL_FONT_SIZE = (float) (24 * PS_WIDTH) / 30f;
    private static final float BUTTON_FONT_SIZE = (float) (14 * PS_WIDTH) / 30f;
    private JButton button = new JButton();
    private JLabel label = new JLabel(" ", SwingConstants.CENTER);
    private CardLayout cardLayout = new CardLayout();
    private MineCellModel model;

    public MineCell(final boolean mined, int row, int col) {
        model = new MineCellModel(mined, row, col);
        model.addPropertyChangeListener(new MyPCListener());
        label.setFont(label.getFont().deriveFont(Font.BOLD, LABEL_FONT_SIZE));
        button.setFont(button.getFont().deriveFont(Font.PLAIN, BUTTON_FONT_SIZE));
        button.setMargin(new Insets(1, 1, 1, 1));
        setLayout(cardLayout);

        add(button, BUTTON);
        add(label, LABEL);

        button.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                pressedAction();
            }
        });
        button.addMouseListener(new MouseAdapter() {
            @Override
            public void mousePressed(MouseEvent e) {
                if (e.getButton() == MouseEvent.BUTTON3) {
                    model.upDateButtonFlag();
                }
            }
        });
    }

    public MineCell(int row, int col) {
        this(false, row, col);
    }

    @Override
    public Dimension getPreferredSize() {
        return new Dimension(PS_WIDTH, PS_HEIGHT);
    }

    public void pressedAction() {
        if (model.isFlagged()) {
            return;
        }
        model.pressedAction();
    }

    public void showCard(String cardConstant) {
        cardLayout.show(this, cardConstant);
    }

    // TODO: have this change the button's icon
    public void setFlag(boolean flag) {
        if (flag) {
            button.setBackground(Color.yellow);
            button.setForeground(Color.red);
            button.setText("f");
        } else {
            button.setBackground(null);
            button.setForeground(null);
            button.setText("");
        }
    }

    private void setMineBlown(boolean mineBlown) {
        if (mineBlown) {
            label.setBackground(Color.red);
            label.setOpaque(true);
            showCard(LABEL);
        } else {
            label.setBackground(null);
        }
    }

    public MineCellModel getModel() {
        return model;
    }

    public void addPropertyChangeListener(PropertyChangeListener listener) {
        model.addPropertyChangeListener(listener);
    }

    public void removePropertyChangeListener(PropertyChangeListener listener) {
        model.removePropertyChangeListener(listener);
    }

    private class MyPCListener implements PropertyChangeListener {
        public void propertyChange(PropertyChangeEvent evt) {
            String propName = evt.getPropertyName();
            if (propName.equals(MineCellModel.MINE_BLOWN)) {
                setMineBlown(true);
            } else if (propName.equals(MineCellModel.FLAG_CHANGE)) {
                setFlag(model.isFlagged());
            } else if (propName.equals(MineCellModel.BUTTON_PRESSED)) {
                if (model.isMineBlown()) {
                    setMineBlown(true);
                } else {
                    String labelText = (model.getValue() == 0) ? "" : String.valueOf(model
                            .getValue());
                    label.setText(labelText);
                }
                showCard(LABEL);
            }
        }
    }

    public void reset() {
        setFlag(false);
        setMineBlown(false);
        showCard(BUTTON);
        label.setText("");
    }

}

class MineCellModel {
    public static final String FLAG_CHANGE = "Flag Change";
    public static final String BUTTON_PRESSED = "Button Pressed";
    public static final String MINE_BLOWN = "Mine Blown";
    private int row;
    private int col;
    private int value = 0;
    private boolean mined = false;;
    private boolean flagged = false;
    private SwingPropertyChangeSupport pcSupport = new SwingPropertyChangeSupport(this);
    private boolean pressed = false;
    private boolean mineBlown = false;

    public MineCellModel(boolean mined, int row, int col) {
        this.mined = mined;
        this.row = row;
        this.col = col;
    }

    public void incrementValue() {
        int temp = value + 1;
        setValue(temp);
    }

    public void setValue(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }

    public void setMineBlown(boolean mineBlown) {
        this.mineBlown = mineBlown;
        PropertyChangeEvent evt = new PropertyChangeEvent(this, MINE_BLOWN, false, true);
        pcSupport.firePropertyChange(evt);
    }

    public boolean isMineBlown() {
        return mineBlown;
    }

    public void setMined(boolean mined) {
        this.mined = mined;
    }

    public void setFlagged(boolean flagged) {
        this.flagged = flagged;
    }

    public int getRow() {
        return row;
    }

    public int getCol() {
        return col;
    }

    public boolean isMined() {
        return mined;
    }

    public boolean isFlagged() {
        return flagged;
    }

    public void pressedAction() {
        if (pressed) {
            return;
        }
        pressed = true;
        if (mined) {
            setMineBlown(true);
        }

        PropertyChangeEvent evt = new PropertyChangeEvent(this, BUTTON_PRESSED, -1, value);
        pcSupport.firePropertyChange(evt);
    }

    public void upDateButtonFlag() {
        boolean oldValue = flagged;
        setFlagged(!flagged);
        PropertyChangeEvent evt = new PropertyChangeEvent(this, FLAG_CHANGE, oldValue, flagged);
        pcSupport.firePropertyChange(evt);
    }

    public void reset() {
        mined = false;
        flagged = false;
        pressed = false;
        mineBlown = false;
        value = 0;
    }

    public void addPropertyChangeListener(PropertyChangeListener listener) {
        pcSupport.addPropertyChangeListener(listener);
    }

    public void removePropertyChangeListener(PropertyChangeListener listener) {
        pcSupport.removePropertyChangeListener(listener);
    }
}

Edit Regarding Recursion

My code uses recursion, but with a level of indirection, since it is based on a Model-View-Controller type of design pattern, and the recursion is within the notification of listeners. Note that each GUI MineCell object holds its own MineCellModel object, the latter holds the MineCell's state. When a GUI JButton held within the MineCell object is pressed, its ActionListener calls the same class's pressed() method:

button.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        pressedAction();
    }
});

This method first checks the corresponding MineCellModel to see if it has been "flagged", if a boolean called flagged is true. If so, this means that the user has right-clicked on the button, and it is not active, and so the method returns. Otherwise the MineCellModel's pressedAction() method is called, 

public void pressedAction() {
    if (model.isFlagged()) {
        return;
    }
    model.pressedAction();
}

and here is where the recursion starts, and it does so through an Observer Design Pattern:

// within MineCellModel
public void pressedAction() {
    if (pressed) {
        // if the button's already been pressed -- return, do nothing
        return;
    }

    // otherwise make pressed true
    pressed = true;

    // if we've hit a mine -- blow it!
    if (mined) {
        setMineBlown(true);
    }

    // *** Here's the key *** notify all listeners that this button has been pressed
    PropertyChangeEvent evt = new PropertyChangeEvent(this, BUTTON_PRESSED, -1, value);
    pcSupport.firePropertyChange(evt);
}

The two lines of code on the bottom notify any listeners to this model that its BUTTON_PRESSED state has been changed, and it sends the MineCellModel's value to all listeners. The value int is key as its the number of neighbors that have mines. So what listens to the MineCellModel? Well, one key object is the MineCellGridModel, the model that represents the state of the entire grid. It has a CellModelPropertyChangeListener class that does the actual listening, and within this class is the following code:

private class CellModelPropertyChangeListener implements PropertyChangeListener {

    public void propertyChange(PropertyChangeEvent evt) {
        // first get the MineCellModel for the cell that triggered this notification
        MineCellModel model = (MineCellModel) evt.getSource();
        int row = model.getRow();
        int col = model.getCol();

        // if the event is a button pressed event
        if (evt.getPropertyName().equals(MineCellModel.BUTTON_PRESSED)) {
            // first check if a mine was hit, and if so, call mineBlown()
            if (cellModelGrid[row][col].isMineBlown()) {
                mineBlown(); // this method iterates through all cells and blows all mines
            } else {
                // here we check for a winner
                buttonsRemaining--;
                if (buttonsRemaining <= 0) {
                    JOptionPane.showMessageDialog(null, "You've Won!!!", "Congratulations",
                            JOptionPane.PLAIN_MESSAGE);
                }

                // here is the key spot -- if cell's value is 0, call the zeroValuePress method
                if (cellModelGrid[row][col].getValue() == 0) {
                    zeroValuePress(row, col);
                }
            }
        }
    }

    private void mineBlown() {
        // ... code to blow all the un-blown mines
    }

    // this code is called if a button pressed has 0 value -- no mine neighbors
    private void zeroValuePress(int row, int col) {

        // find the boundaries of the neighbors
        int rMin = Math.max(row - 1, 0);  // check for the top edge
        int cMin = Math.max(col - 1, 0);  // check for the left edge
        int rMax = Math.min(row + 1, cellModelGrid.length - 1);  // check for the bottom edge
        int cMax = Math.min(col + 1, cellModelGrid[row].length - 1);  // check for right edge

        // iterate through the neighbors
        for (int row2 = rMin; row2 <= rMax; row2++) {
            for (int col2 = cMin; col2 <= cMax; col2++) {
                // *** Here's the recursion ***
                // call pressedAction on all the neighbors
                cellModelGrid[row2][col2].pressedAction();
            }
        }
    }
}

So the key method in the listener above is the zeroValuePress(...) method. It first finds the boundaries of the neighbors around the current mine cell, using Math.min(...) and Math.max(...) to be careful not to go beyond the right, left, or top or bottom boundaries of the grid. It then iterates through the cell neighbors calling pressedAction() on each one of the neighbors MineCellModels held by this grid. As you know from above, the pressedAction() method will check if the cell has already been pressed, and if not, changes its state, which then notifies this same listener, resulting in recursion.



回答2:

One of the primary functions of this game is to have a recursion to check all the sides when the tile clicked has no bombs surrounding it.

Looks like you are stucked on the part where you need to update the cell with number according to the number of bombs surrounding it.

These are the things for you to take note:

  1. To update the numbers on the cells, there is no need to use recursion. The only part I used recursion is when user clicks on a cell with value == 0(stepped on an empty grid).

  2. Checking all 8 directions can be done easily without writing large number of if-conditions. All you need is a pair of nested for-loop. Just traverse the 3x3 grid like a 2D array (see diagram below for illustration).

  3. In the loop, set conditions to ensure you are within bounds (of the 3x3 matrix) before reading current grid's value (see code below).

To traverse the 3x3 matrix as shown in the diagram, we can use a pair of nested loops:

for(int x=(coordX-1); x<=(coordX+1); x++)
    for(int y=(coordY-1); y<=(coordY+1); y++)
        if(x!=-1 && y!= -1 && x! = ROWS && y! = COLS && map[x][y] != 'B')
            if(map[x][y] == '.')
                map[x][y] = '1';
            else
                map[x][y] += 1;

The if-condition prevents working on array element which is out of bounds.



标签： java swing recursion methods minesweeper
举报

收藏的人(0)

Ta的文章 更多文章
登录 后发表评论
0条评论
还没有人评论过~