Turn Based Game Java(Stratego)

Question

so i have JXButton[][] array (gridLayout) and each JXButton holds an icon, a piece,which player belongs to and has a mouseListener.

I am currently trying to make the Stratego Game(Two Players-I handle both). I set up the icons,pieces and how a piece should move alright.

Now i wish to make it play by turn.

For example when is Player1 Turn i need all Players2' pieces to change icon to Hidden(hidden.png) and vice versa. I have tried something like this.

tmp1, tmp2 are Icon arrays

pieceimgsB,R hold the Hidden Icon

allbuttons is my JXButton[][] array

    public void makeHidden(int iD){

            if(iD==1){
                for (int i=0;i<8;i++){
                    for(int y=0;y<10;y++){
                        if(allbuttons[i][y].getPlayerID()==iD){
                            tmp1[i][y]=allbuttons[i][y].getIcon();
                            allbuttons[i][y].setIcon(new ImageIcon(pieceimgsB[12]));
                        }
                    }

                }
            }
            else if(iD==2){
                for (int i=0;i<8;i++){
                    for(int y=0;y<10;y++){
                        if(allbuttons[i][y].getPlayerID()==iD){
                            tmp2[i][y]=allbuttons[i][y].getIcon();
                            allbuttons[i][y].setIcon(new ImageIcon(pieceimgsR[12]));
                        }
                    }

                }
            }
        }
 public void restoreHidden(int iD){
        if(iD==1){
            for (int i=0;i<8;i++){
                for(int y=0;y<10;y++){
                    if(allbuttons[i][y].getPlayerID()==iD){

                        allbuttons[i][y].setIcon(tmp1[i][y]);
                    }
                }

            }
        }
        else if(iD==2){
            for (int i=0;i<8;i++){
                for(int y=0;y<10;y++){
                    if(allbuttons[i][y].getPlayerID()==iD){

                        allbuttons[i][y].setIcon(tmp2[i][y]);
                    }
                }

            }
        }
    }

I my mind makeHidden Player2 pieces hidden when its Players1 turn.

And restoreHidden should change back the Icons when its Players2 turn.

If these two methods seem ok , where my problem lies is how to implement the turns.

I must say that (When i click on a JXButton and then click on another one, the piece moves on the board as it should). I tried having a flag in my mouseListener that when one actually moves the turn changes, but i cant make it work by turns. I have wrote this :

public void letsPlay(){
        switch (turn){
            case 1: 

                getsb().makeHidden(2);
                //getsb().restoreHidden(1);
                if(getsb().getPlayerMoved()==true){
                    setTurn(2);
                }
                break;
            case 2:

                getsb().makeHidden(1);
                //getsb().restoreHidden(2);
                if(getsb().getPlayerMoved()==true){

                    setTurn(1);
                    //;
                }
                break;
        }

    }

I need to know if these two methods seem ok according to what they should do and a little insight on how to get it to work by turns.

Should i have the getPlayerMoved() (which returns the flag in the mouseListener in a while outside the switch case)?

Maybe i am tired and i dont see it but any insight would be helpful. If someone needs it i can provide my mouseListener Code too although its a bit messy.

Answer 1

This seems to be an XY problem, the main point is not to specialize your listener to manage such behavior (and other inherent behaviors) but how to design something that is modular and easily maintainable.

I'd suggest you to try to workaround your problem by thinking how you could design your game and UI structure. Let's make a simple example:

First of all you have a game piece which has a type and a player, so why don't you use a specific object type for this? Eg:

class PieceType {
  String name;
  String iconName;
}

class Player {
  String name;
}

class Piece {
  PieceType type;
  Player owner;

class BoardCell {
  Piece piece;
}

Then you surely need a Board class able to manage the game board, eg:

class Board {
  private BoardCell [][] pieces = new Piece[10][10];

  public BoardCell cellAtPiece(int x, int y) { return pieces[x][y]; }
  /* other functions */
}

Finally you should have a Game class which manages the whole thing, eg:

class Game {
  Board board;
  Player[] players = new Player[2];
  Player currentPlayer;

  Player getCurrentPlayer() { return currentPlayer; }
  /* other methods, eg turn advance, check for correct position, eat piece etc */
}

Now you reached a point in which you have the structure of the game, and you can think about the UI, which should rely on the Game instance without the need of additional inputs (and Game shouldn't even know about the UI). You could extend a JXButton and provide custom behavior, eg:

class BoardButton extends JXButton {
  final private Game game;
  final private BoardCell cell;

  public BoardButton(Game game, int x, int y) { 
    this.game = game;
    this.cell = game.cellAtPiece(x,y);
  }

  public void refreshIcon() {
    if (cell.piece == null) { setIcon(null); }
    else if (cell.piece.owner != game.getCurrentPlayer()) { setIcon(hidden); }
    else setIcon(cell.piece.type.icon);
  }

  /* other utilities, like checking if a piece can be moved from here for current player and such */

Mind, I didn't answer directly to your question, but I explained some tools which would allow it to be solved easily together with all problems that you could find in implementation.