Java - Picross Game

Picross Game - Java

This is an application written in Java to implement the puzzle game of “Picross”. The user is able to play the game through an implemented graphical user interface.

Picross, is a visual game where the objective is to identify a picture on a cross board using a specific logic. The graphical user interface is implemented using Java Swing. The application utilizes a Model-View-Controller architecture. A server and client configuration was additionally implemented to allow user data and game configurations to be sent and stored at the server or received. Each row and column of the board has a sequence of numbers that indicate the number of blocks (squares) that should appear consecutively. The initial board is empty, and the player needs to use logic to determine the correct distribution of squares. For example, a sequence like (5,1) means there should be a group of 5 squares followed by some empty spaces and then another single square. The challenge lies in figuring out the correct arrangement of squares since no initial distribution information is provided.

A video demonstrating the application and the code is shown below:

Alternate Link

View the Source Code below, or view the full codebase on GitHub

Game

Client

Server

Splash

Model

View

Controller

Exported from Notepad++

 /*
  * File name: Game.java
  * Author: Mostapha A
  * Purpose: This contains the main method and uses the other classes
  * Class list: Game.java, GameView.java, GameModel.java, GameController.java
  */

 package piccross;

import java.awt.EventQueue;
11
/**
 * Piccross class that contains the main method for the program, displays the
 * splash screen then game
 * 
 * @author Mostapha Abdelaziz
 * @version 2.0
 * @see piccross package
 * @since Java 16
 */
public class Game {
    
    /**
     * The main method that combines the other classes, displays a splash screen then the game
     * @param args default arguments
     */
    public static void main(String[] args) {
        GameView gameView = new GameView();
        GameModel gameModel = new GameModel();
        GameController gameController = new GameController(gameView, gameModel);        
        
        // create the splash screen
        GameView.GameSplash splashScreen = new GameView.GameSplash();
34
        // call method to display
        splashScreen.showSplashWindow();
37
        // display the game after the splash screen
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                gameController.startGame("");
            }
        });
        
    }
}
48
49

Exported from Notepad++

 /*
  * File name: GameServer.java
  * Author: Mostapha A
  * Purpose: Creates and Manages a game client
  * Class list: gameView.java, gameModel.java, gameController.java, DrawGame, ButtonHandler
  */

 package piccross;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;
import java.net.UnknownHostException;

import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;

/**
 * GameClient class that sets up a piccross client
 * 
 * @author Mostapha Abdelaziz
 * @version 1.0
 * @see piccross package, Game.java, GameModel.java, GameView.java
 * @since Java 16
 */
public class GameClient {
    /** The console to write information to */
    private static JTextArea console;
    /** The button to initiate connection */
    private static JButton connect;
    /** The text box for port number input */
    private static JTextField portInput;
    /** The text box for user name input */
    private static JTextField userInput;
    /** The text box for server name input */
    private static JTextField serverNameInput;
    /** The port number */
    private static int portNum;
    /** The GameView object */
    private static GameView gameView;
    /** The GameModel object */
    private static GameModel gameModel;
    /** The game controller object */
    private static GameController gameController;
    /** The server name */
    private static String serverName;
    /** The socket for connections */
    private static Socket socket;
    /** buffered reader for information from server */
    private static BufferedReader serverInput;
    /** print stream to send information to server */
    private static PrintStream serverOutput;
    /** get the client id from server */
    private static String clientId;
    /** a counter for the play button for logic purposes */
    private static int game = 0;
    /** To keep track whether we are connected */
    private static boolean connected = false;

    /**
     * Main function that calls function to create GUI elements
     * @param args
     */
    public static void main(String[] args) {
        create();
    } // end main

    /**
     * Creates the GUI elements
     */
    private static void create() {
        // create action listener
        ButtonHandler buttonHandler = new ButtonHandler();

        // create the window
        JFrame window = new JFrame("Piccross client - Mostapha");
        window.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);

        // print a message if they try to close from the window button
        window.addWindowListener(new java.awt.event.WindowAdapter() {
            @Override
            public void windowClosing(java.awt.event.WindowEvent windowEvent) {
                write("Must close the client with the \"End\" button");
            }
       });
101
       // create the text area and scrollpane
       console = new JTextArea();
       JScrollPane consoleScroll = new JScrollPane(console);
       console.setEditable(false);
       console.setText("");
107
       // create the buttons and text options
       JLabel userLabel = new JLabel("User:");
       userInput = new JTextField("user", 10);
       JLabel serverLabel = new JLabel("Server:");
       serverNameInput = new JTextField("localhost", 10);
       JLabel portLabel = new JLabel("Port:");
       portInput = new JTextField("1234", 6);
       connect = new JButton("Connect");
       JButton end = new JButton("End");
117
       JButton newGame = new JButton("New Game");
       JButton drawGame = new JButton("Draw Game");
       JButton sendGame = new JButton("Send Game");
       JButton receiveGame = new JButton("Receive Game");
       JButton sendData = new JButton("Send Data");
       JButton play = new JButton("Play");
124
       // add listeners
       connect.addActionListener(buttonHandler);
       end.addActionListener(buttonHandler);
       newGame.addActionListener(buttonHandler);
       drawGame.addActionListener(buttonHandler);
       sendGame.addActionListener(buttonHandler);
       receiveGame.addActionListener(buttonHandler);
       sendData.addActionListener(buttonHandler);
       play.addActionListener(buttonHandler);
134
       // add option elements to 2 panels and a main panel
       JPanel info = new JPanel();
       JPanel buttons = new JPanel();
       info.add(userLabel);
       info.add(userInput);
       info.add(serverLabel);
       info.add(serverNameInput);
       info.add(portLabel);
       info.add(portInput);
       info.add(connect);
       info.add(end);
146
       buttons.add(newGame);
       buttons.add(drawGame);
       buttons.add(sendGame);
       buttons.add(receiveGame);
       buttons.add(sendData);
       buttons.add(play);
153
       JPanel options = new JPanel();
       options.setLayout(new BorderLayout());
       options.add(info, BorderLayout.NORTH);
       options.add(buttons, BorderLayout.CENTER);
158
       // set window layout and add elements
       window.setLayout(new BorderLayout());
       window.add(options, BorderLayout.NORTH);
       window.add(consoleScroll, BorderLayout.CENTER);
163
       // set size and show
       window.setSize(630, 350);
       window.setResizable(false);
       window.setVisible(true);
       window.setLocationRelativeTo(null);
       // window.pack();
170
       // create game elements
       gameView = new GameView();
       gameModel = new GameModel();
       gameController = new GameController(gameView, gameModel);
   }
176
   /**
    * Writes a message to system and GUI console
    * @param message The message to write
    */
   private static void write(String message) {
       // write the message to console
       console.append(message + "\n");
       System.out.println(message);
   }
186
   /**
    * Attempts to connect to the server
    * @return Return a boolean for connection status
    */
   private static boolean connect() {
       // create a socket with port number and server name
       serverName = serverNameInput.getText();
194
       try {
           // socket for connection
           socket = new Socket(serverName, portNum);
           // buffered reader for information from server
           serverInput = new BufferedReader(new InputStreamReader(socket.getInputStream()));
           // print stream to send information to server
           serverOutput = new PrintStream(socket.getOutputStream());
           // get the client id from server
           clientId = serverInput.readLine();
           // write we are connected
           write("We are client " + clientId + " connected in server");
           connected = true;
           return true;
       } catch (UnknownHostException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
           write("Host name is invalid");
       } catch (IOException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
           write("Port Number is invalid");
       } catch (Exception e) {
           e.printStackTrace();
           write("Unknown error");
       }
       connected = false;
       return false;
   }
223
   /**
    * Attempts to send data to the server
    * @param protocol Protocol number for communication purposes
    * @param data The data being sent
    * @throws IOException Disconnection exception
    */
   private static void sendData(int protocol, String data) throws IOException {
       // set output to data taken in
       String output = data;
       String input;
       try {
           write("Sending " + output);
           // add necessary format
           output = clientId + "#P" + protocol + "#" + output;
           // send to server
           serverOutput.println(output);
           serverOutput.flush();
           // receive information from server
           input = serverInput.readLine();
           String[] splitInput = input.split("#");
           // write("Server sent: " + input);
245
           // case structure depending on protocol
           switch (protocol) {
           // cases 0 - 4 not receiving anything
           case 0:
               // end game protocol
               write("Closing connection...");
               break;
           case 1:
           case 2:
           case 3:
               write(data + " sent");
               break;
           case 4:
               // receiving game configuration
               if (splitInput[1].equals("0")) {
                   write("Server has no saved game");
               } else {
                   gameModel.generateBoard(splitInput[1]);
                   write("Received game " + gameModel.getString());
               }
               break;
           case 5:
               break;
           }
270
           /*
            * write("Client[" + clientId + "]: ");
            * 
            * output = clientId + "#" + output; serverOutput.println(output);
            */
276
           serverOutput.flush();
           // socket.close();
279
       } catch (Exception e) {
           System.out.println(e);
           // set connected to false and tell user we are disconnected
           write("Connection to server lost");
           connected = false;
           connect.setEnabled(true);
       }
   }
288
   /**
    * Creates the window to draw a game configuration
    * @author moabd
    *
    */
   private static class DrawGame implements ActionListener {
       /** The dimension of the drawing grid */
       private static int dimension = 5;
       /** The array of buttons */
       private static JButton[][] playButtons;
       /** The panel for the buttons */
       private static JPanel buttonGrid;
       /** The combo box for grid options */
       private static JComboBox options;
       /** The array for configuration string */
       private static int[][] configuration;
       /** The frame for the draw window */
       private static JFrame drawGame;
307
       /**
        * creates the GUI elements of the draw window
        */
       private void drawGame() {
           // create a frame
           drawGame = new JFrame();
           // create a combo box for options
           JPanel sizeSelection = new JPanel();
           JLabel enterSize = new JLabel("Choose board size:");
           String[] sizes = { "2", "3", "4", "5", "6", "7", "8", "9", "10" };
           options = new JComboBox(sizes);
           options.setSelectedIndex(3);
           options.addActionListener(this);
           sizeSelection.add(enterSize);
           sizeSelection.add(options);
           // create array for game configuration
           configuration = new int[dimension][dimension];
           // create a button to save
           JButton save = new JButton("save");
           save.addActionListener(this);
328
           // create a panel to add the buttons to
           buttonGrid = new JPanel();
331
           // create the grid
           makeGrid();
334
           // add components
           drawGame.add(sizeSelection, BorderLayout.NORTH);
           drawGame.add(save, BorderLayout.SOUTH);
           drawGame.add(buttonGrid, BorderLayout.CENTER);
339
           drawGame.setResizable(false);
           drawGame.setVisible(true);
           drawGame.setLocationRelativeTo(null);
           drawGame.pack();
       }
345
       /**
        * Creates a button and sets it up for actions
        * 
        * @param name          The name of the button, or the position
        * @return Returns the created button
        */
       public JButton createButton(String name) {
           // create button
           JButton button = new JButton();
355
           // set attributes
           button.setPreferredSize(new Dimension((500 / dimension), (500 / dimension)));
           button.setFocusable(false);
           button.setBackground(Color.white);
           button.setBorder(BorderFactory.createMatteBorder(2, 2, 2, 2, new Color(70, 70, 70)));
           // button.setText(name);
362
           // set action
           button.addActionListener(this);
           button.setActionCommand(name);
           // return the created button
           return button;
       }
369
       /**
        * Creates the button grid depending on the selected dimension
        */
       private void makeGrid() {
           // create an array for all the buttons, size of grid
           playButtons = new JButton[dimension][dimension];
           buttonGrid.setLayout(new GridLayout(dimension, dimension));
377
           // set amount of names
           String[] buttonNames = new String[dimension * dimension];
           // loop for grid size and create buttons
           int i = 0;
           int row = 0;
           int column = 0;
           for (i = 0; i < (dimension * dimension); i++) {
               // reset column after reaches gridSize
               if (column >= dimension) {
                   column = 0;
                   row++;
               }
390
               // create button name/action
               buttonNames[i] = (column + 1) + "," + (row + 1);
393
               // create and add button to array list
               playButtons[column][row] = createButton(buttonNames[i]);
396
               // thicker border for outside edge
               if (column == 0 && row == 0) {
                   // top left corner
                   playButtons[column][row]
                           .setBorder(BorderFactory.createMatteBorder(4, 4, 2, 2, new Color(70, 70, 70)));
               } else if (column == dimension - 1 && row == 0) {
                   // top right corner
                   playButtons[column][row]
                           .setBorder(BorderFactory.createMatteBorder(4, 2, 2, 4, new Color(70, 70, 70)));
               } else if (column == 0 && row == dimension - 1) {
                   // bottom left corner
                   playButtons[column][row]
                           .setBorder(BorderFactory.createMatteBorder(2, 4, 4, 2, new Color(70, 70, 70)));
               } else if (column == dimension - 1 && row == dimension - 1) {
                   // bottom right corner
                   playButtons[column][row]
                           .setBorder(BorderFactory.createMatteBorder(2, 2, 4, 4, new Color(70, 70, 70)));
               } else if (column == 0) {
                   // left edge
                   playButtons[column][row]
                           .setBorder(BorderFactory.createMatteBorder(2, 4, 2, 2, new Color(70, 70, 70)));
               } else if (row == 0) {
                   // top edge
                   playButtons[column][row]
                           .setBorder(BorderFactory.createMatteBorder(4, 2, 2, 2, new Color(70, 70, 70)));
               } else if (column == dimension - 1) {
                   // right edge
                   playButtons[column][row]
                           .setBorder(BorderFactory.createMatteBorder(2, 2, 2, 4, new Color(70, 70, 70)));
               } else if (row == dimension - 1) {
                   // bottom edge
                   playButtons[column][row]
                           .setBorder(BorderFactory.createMatteBorder(2, 2, 4, 2, new Color(70, 70, 70)));
               }
431
               // add to panel
               buttonGrid.add(playButtons[column][row]);
434
               column++;
           }
437
       }
439
       /**
        * Creates the configuration string based on the selected buttons
        */
       private void createString() {
           String config = "";
           // loop through config array and create configuration string
           int x = 0;
           int y = 0;
           for (y = 0; y < dimension; y++) {
               for (x = 0; x < dimension; x++) {
                   // create the string depending on which buttons are selected
                   if (configuration[x][y] == 0) {
                       config += "0";
                   } else {
                       config += "1";
                   }
               }
               // add comma unless it is the last row
               if (y < dimension - 1) {
                   config += ",";
               }
           }
           // change the game config string
           gameModel.generateBoard(config);
       }
465
       /**
        * Listens to actions on the items and performs functions depending on item selected
        */
       @Override
       public void actionPerformed(ActionEvent e) {
           // if they choose a new dimension re-draw the grid
           if (e.getActionCommand().equals("comboBoxChanged")) {
               // set new dimension and redraw
               dimension = Integer.parseInt(options.getSelectedItem().toString());
               buttonGrid.removeAll();
               makeGrid();
               buttonGrid.revalidate();
               buttonGrid.repaint();
               drawGame.pack();
               configuration = new int[dimension][dimension];
           } else if (e.getActionCommand().equals("save")) {
               // if they click save set the game string, print and close
               createString();
               drawGame.setVisible(false);
               drawGame.dispose();
               write("New game " + gameModel.getString());
           } else {
               // otherwise change the game configuration string
               String[] coordinate = e.getActionCommand().split(",");
               int x = Integer.parseInt(coordinate[0]) - 1;
               int y = Integer.parseInt(coordinate[1]) - 1;
               // check if button is unselected
               if (configuration[x][y] == 0) {
                   // change color and set to selected
                   configuration[x][y] = 1;
                   playButtons[x][y].setBackground(new Color(97, 197, 255));
               } else {
                   // change color and set to unselected
                   configuration[x][y] = 0;
                   playButtons[x][y].setBackground(Color.WHITE);
               }
           }
       }
   }
505
   /**
    * Inner action listener class for managing the buttons
    * 
    * @author Mostapha Abdelaziz
    * @version 1.0
    * @since Java 16
    * @see GameServer
    */
   private static class ButtonHandler implements ActionListener {
       /**
        * This is called when one of the buttons is clicked, it will execute a function
        * depending on the button used
        * 
        * @param e The event object with the event information
        */
       @Override
       public void actionPerformed(ActionEvent e) {
           // store which button was pressed
           String button = e.getActionCommand();
           // case structure to do different things depending on the button
           switch (button) {
           // check connection first with each case
           case "Connect":
               // get the port value
               String input = portInput.getText();
               write("Connecting to server...");
               // validate input
               if (input.length() > 5 || input.isBlank() || !input.matches("[0-9]+")) {
                   write("Port must be an integer number from 0 to 66535, try again");
               } else if (Integer.parseInt(input) < 0 || Integer.parseInt(input) > 66535) {
                   write("Port must be an integer number from 0 to 66535, try again");
               } else if (userInput.getText().equals("")){
                   write("Enter a username, try again");
               }else {
                   // if it is valid establish server on port
                   portNum = Integer.parseInt(input);
                   try {
                       connected = connect();
                       // if we are connected act accordingly
                       if (connected == true) {
                           // send our name
                           sendData(2, userInput.getText());
                           // set connect button to not be enabled
                           connect.setEnabled(false);
                       } else {
                           write("We are not connected to a server");
                       }
                   } catch (IOException e1) {
                       // TODO Auto-generated catch block
                       e1.printStackTrace();
                   }
               }
               break;
           case "End":
               try {
                   // send end protocol
                   if (connected == true) {
                       sendData(0, "0");
                       System.exit(0);
                   } else {
                       System.exit(0);
                   }
               } catch (IOException e1) {
                   // TODO Auto-generated catch block
                   e1.printStackTrace();
                   System.exit(0);
               }
               break;
           case "New Game":
               gameModel.generateString();
               
               write("New game " + gameModel.getString());
               break;
           case "Draw Game":
               // create a new game based on their selections
               DrawGame draw = new DrawGame();
               draw.drawGame();
               break;
           case "Send Game":
               // send the config string if it is not empty
               if (gameModel.getString().equals("0")) {
                   write("No game stored, create a new game or receive one first");
               } else {
                   // send the configuration
                   try {
                       if (connected == true) {
                           sendData(1, gameModel.getString());
                       } else {
                           write("We are not connected to a server");
                       }
                   } catch (IOException e1) {
                       // TODO Auto-generated catch block
                       e1.printStackTrace();
                   }
               }
               break;
           case "Receive Game":
               // send a request for a configuration
               try {
                   if (connected == true) {
                       sendData(4, "0");
                       write("Current game is " + gameModel.getString());
                   } else {
                       write("We are not connected to a server");
                   }
               } catch (IOException e2) {
                   // TODO Auto-generated catch block
                   e2.printStackTrace();
               }
               break;
           case "Send Data":
               try {
                   if (connected == true) {
                       sendData(3, gameController.returnInfo());
                   } else {
                       write("We are not connected to a server");
                   }
               } catch (IOException e1) {
                   // TODO Auto-generated catch block
                   e1.printStackTrace();
               }
               break;
           case "Play":
               // start the game if we have a configuration
               if (gameModel.getString().equals("0")) {
                   write("No game stored, create a new game or receive one first");
               } else {
                   if (game > 0) {
                       int dimension = gameModel.getDimension();
                       String tempGameConfig = gameModel.getString();
                       
                       // reset view and model
                       gameView.reset();
                       gameModel.reset();
                       gameController.resetController();
                       
                       // set dimensions
                       gameView.setDimension(dimension);
                       gameModel.setDimension(dimension);
                       gameController.setDimension(dimension);
646
                       // reset play area
                       gameController.createNewGame();
                       
                       // create data for game logic
                       gameModel.generateBoard(tempGameConfig);
652
                       // setup hints
                       gameController.setupHints();
                       gameView.setVisible();
                       
                   } else {
                       gameController.startGame(gameModel.getString());
                   }
                   write("Starting game " + gameModel.getString());        
                   game++;
               }
               break;
           }
       }
666
   } // end button handler class
668
}
670

Exported from Notepad++

 /*
  * File name: GameServer.java
  * Author: Mostapha A
  * Purpose: Creates and Manages a game server
  * Class list: ButtonHandler, CheckBoxHandler, Connection
  */

 package piccross;

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;

import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;

/**
 * GameServer class that sets up a piccross server
 * 
 * @author Mostapha Abdelaziz
 * @version 1.0
 * @see piccross package
 * @since Java 16
 */
public class GameServer implements Runnable {
    /** The input box for port number */
    private static JTextField portInput;
    /** The button to execute */
    private static JButton execute;
    /** The text area for all the information to be printed */
    private static JTextArea console;
    /** The port number */
    private static int portNum;
    /** The socket for the connection */
    private static Socket sock;
    /** The current client and total clients */
    static int nclient = 0, nclients = 0;
    /** The server socket for the connections */
    static ServerSocket servsock;
    /** The finalize checkbox */
    private static JCheckBox finalize;
    /** The button to print results */
    private static JButton results;
    /** The current game configuration */
    static String gameConfig = "0";
    /** The array of all client information */
    private static ArrayList<String[]> allInfo = new ArrayList<String[]>();

    /**
     * Main function that calls function to create the GUI
     * @param args
     */
    public static void main(String[] args) {
        // call the function that creates the gui
        create();
    }

    /**
     * Creates GUI elements
     */
    private static void create() {
        // create action listener
        ButtonHandler buttonHandler = new ButtonHandler();

        // create the window
        JFrame window = new JFrame("Piccross server - Mostapha");
        window.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);

        // print a message if they try to close from the window button
        window.addWindowListener(new java.awt.event.WindowAdapter() {
            @Override
            public void windowClosing(java.awt.event.WindowEvent windowEvent) {
                write("Must close the server with the \"End\" button");
            }
        });

        // create the text area and scrollpane
        console = new JTextArea();
        JScrollPane consoleScroll = new JScrollPane(console);
        console.setEditable(false);
        console.setText("");

        // create the buttons and text options
       JLabel portLabel = new JLabel("Port:");
       portInput = new JTextField("1234", 6);
       execute = new JButton("Execute");
       results = new JButton("Results");
       results.setEnabled(false);
       JButton end = new JButton("End");
       finalize = new JCheckBox("Finalize");
107
       execute.addActionListener(buttonHandler);
       results.addActionListener(buttonHandler);
       end.addActionListener(buttonHandler);
       finalize.addItemListener(new CheckBoxHandler());
112
       // add option elements to a panel
       JPanel options = new JPanel();
       options.add(portLabel);
       options.add(portInput);
       options.add(execute);
       options.add(results);
       options.add(finalize);
       options.add(end);
121
       // set window layout and add elements
       window.setLayout(new BorderLayout());
       window.add(options, BorderLayout.NORTH);
       window.add(consoleScroll, BorderLayout.CENTER);
126
       // set size and show
       window.setSize(630, 350);
       window.setResizable(false);
       window.setVisible(true);
       window.setLocationRelativeTo(null);
       // window.pack();
   }
134
   /**
    * Writes a message to the system console and GUI console
    * @param message The message to write
    */
   private static void write(String message) {
       // write the message to console
       console.append(message + "\n");
       System.out.println(message);
   }
144
   /** Attempts to connect with a new thread */
   public static void connect() throws IOException {
       try {
           servsock = new ServerSocket(portNum);
           Thread newThread = new Thread(new GameServer());
           newThread.start();
           write("Server on " + InetAddress.getLocalHost() + " port " + portNum);
           // grey out execute button
           execute.setEnabled(false);
           results.setEnabled(true);
       } catch (Exception e) {
           System.out.println(e);
           write("Port Number in use try again");
       }
       
   }
161
   /**
    * Inner action listener class for managing the buttons
    * 
    * @author Mostapha Abdelaziz
    * @version 1.0
    * @since Java 16
    * @see GameServer
    */
   private static class ButtonHandler implements ActionListener {
       /**
        * This is called when one of the buttons is clicked, it will execute a function
        * depending on the button used
        * 
        * @param e The event object with the event information
        */
       @Override
       public void actionPerformed(ActionEvent e) {
           // store which button was pressed
           String button = e.getActionCommand();
           // case structure to do different things depending on the button
           switch (button) {
           case "Execute":
               // get the port value
               String input = portInput.getText();
186
               // validate input
               if (input.length() > 5 || input.isBlank() || !input.matches("[0-9]+")) {
                   write("Port must be an integer number from 0 to 66535, try again");
               } else if (Integer.parseInt(input) < 0 || Integer.parseInt(input) > 66535) {
                   write("Port must be an integer number from 0 to 66535, try again");
               } else {
                   // if it is valid establish server on port
                   portNum = Integer.parseInt(input);
                   try {
                       connect();
197
                   } catch (IOException e1) {
                       // TODO Auto-generated catch block
                       e1.printStackTrace();
                   }
               }
203
               break;
           case "Results":
               // print info
               printInfo();
               break;
           case "End":
               // close server
               try {
                   if (nclients > 0)
                   sock.close();
               } catch (IOException e1) {
                   // TODO Auto-generated catch block
                   e1.printStackTrace();
               }
               System.exit(0);
               break;
           }
       }
222
   } // end button handler class
224
   /**
    * Inner item listener class for managing the finalize check box
    * 
    * @author Mostapha Abdelaziz
    * @version 1.0
    * @since Java 16
    * @see GameServer
    */
   private static class CheckBoxHandler implements ItemListener {
       /**
        * This is called when the finalize check box is changed
        * 
        * @param e The event object with the event information
        */
       @Override
       public void itemStateChanged(ItemEvent e) {
           // print message depending on status
           if (finalize.isSelected() == true) {
               write("Server will close when there are no more connections");
               if (nclients == 0) {
                   System.exit(0);
               }
           } else {
               write("Server will remain open when there are no more connections");
           }
250
       }
   }// end check box handler class
253
   /**
    * Prints the information in the array of client information
    */
   public static void printInfo() {
       // loop through our clients and print information
       String scoreTime;
       // if we have no clients write so
       if (allInfo.size() == 0) {
           write("No clients connected");
       }
       for (String[] client : allInfo) {
           // if they have no score and time print info accordingly
           if (Integer.parseInt(client[1]) == 0) {
               scoreTime = "has not finished a game";
           } else {
               scoreTime = "last played game took " + client[1] + " seconds and scored " + client[2] + " points";
           }
           // write each clients information
           write("Client " + client[3] + " (" + client[0] + ") " + scoreTime);
       }
   }
275
   /**
    * The method that will run with a new thread, attempts to connect to a client
    */
   public void run() {
       // loop indefinitely
       for (;;) {
           // try to establish a connection
           try {
               // new client
               sock = servsock.accept();
               nclient += 1;
               nclients += 1;
               write("Connecting " + sock.getInetAddress() + " in port " + sock.getPort());
           } catch (IOException ioe) {
               System.out.println(ioe);
           }
           // new object that recieves info from client
           Connection clientConnection = new Connection(sock, nclient);
           clientConnection.start();
       }
   }
297
   /**
    * The class that will take in all input and handle communications
    * @author moabd
    *
    */
   class Connection extends Thread {
       /** Socket for connection */
       Socket sock;
       /** The unique client number */
       Integer clientid;
       /** The clients name */
       String clientName;
       /** A descriptor of the information received */
       String infoType;
       /** An array for the clients information */
       String[] clientInfo = new String[4];
314
       /**
        * The constructor of the class
        * @param socket Previously established socket
        * @param nclient The unique client number
        */
       public Connection(Socket socket, int nclient) {
           // receive the socket previously established a connection with
           sock = socket;
           clientid = nclient;
       }
325
       /**
        * Handles all communications
        */
       public void run() {
           String clientData;
           String returnInfo;
           PrintStream clientOutput = null;
           try {
               // set the stream we will be printing to
               clientOutput = new PrintStream(sock.getOutputStream());
               // set the reader we will be receiving from
               BufferedReader clientInput = new BufferedReader(new InputStreamReader(sock.getInputStream()));
               // send the client their client number
               clientOutput.println(clientid);
               // receive first info back
               clientData = clientInput.readLine();
342
               // initialize our client info array
               clientInfo[0] = "No name recorded";
               clientInfo[1] = "0";
               clientInfo[2] = "0";
               clientInfo[3] = clientid.toString();
               // store our client in all information array
               allInfo.add(clientInfo);
350
               // loop until end protocol
               while (!clientData.equals(clientid + "#P0#0")) {
                   // default return value
                   returnInfo = "0";
                   // case structure depending on input
                   String[] input = clientData.split("#");
                   switch (input[1]) {
                   case "P1":
                       // receiving game configuration
                       gameConfig = input[2];
                       infoType = "a game configuration (" + gameConfig + ")";
                       break;
                   case "P2":
                       // receiving user name
                       clientInfo[0] = input[2];
                       clientName = input[2];
                       infoType = "their name";
                       break;
                   case "P3":
                       // receiving time and score
                       clientInfo[1] = input[2];
                       clientInfo[2] = input[3];
                       infoType = "their time (" + clientInfo[1] + ") and score (" + clientInfo[2] + ")";
                       break;
                   case "P4":
                       // receiving a request for a game configuration
                       returnInfo = gameConfig;
                   default:
379
                       break;
                   }
                   // write to console what was received
                   write("Client " + clientid + " (" + clientName + ") sent " + infoType);
                   // send something back
                   clientOutput.println(clientid + "#" + returnInfo);
                   
                   // update info array
                   int i = 0;
                   for(i = 0; i < allInfo.size(); i++) {
                       if (allInfo.get(i)[3].equals(clientid.toString())) {
                           allInfo.set(i, clientInfo);
                           break;
                       }
                   }
395
                   // flush and receive next input
                   clientOutput.flush();
                   clientData = clientInput.readLine();
               }
               // if they sent end protocol
               write("Disconnecting client " + clientid + " (" + clientName + ") at " + sock.getInetAddress());
               clientOutput.println(clientid + "#Closing Connection");
               // close socket
               sock.close();
               
               // decrease client number
               nclients -= 1;
               write("There are " + nclients + " clients connected");
               
               // if finalize is checked and there are no clients automatically close the
               // server
               if (finalize.isSelected() && nclients == 0) {
                   write("Closing server...");
                   System.exit(0);
               }
           } catch (IOException ioe) {
               System.out.println(ioe);
           }
       }
   }
}
422

Exported from Notepad++

 /*
  * File name: GameSplash.java
  * Author: Mostapha A
  * Purpose: This sets up the splash screen
  * Class list: Piccross.java, GameSplash.java, GameController.java
  */

 package piccross;

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Toolkit;
import javax.swing.ImageIcon;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JWindow;
17
/**
 * GameSplash class that sets up the splash screen
 * 
 * @author Mostapha Abdelaziz
 * @version 1.0
 * @see piccross package, Piccross.java
 * @since Java 16
 */
public class GameSplash extends JWindow {
    /** Required long value */
    private static final long serialVersionUID = 1L;
29
    /**
     * Displays a splash screen for 5 seconds
     */
    public void showSplashWindow() {
        // create panel that will hold image
        JPanel splashPanel = new JPanel(new BorderLayout());
36
        // create a label to place splash screen image
        JLabel label;
        try {
            label = new JLabel(new ImageIcon("images/loadingscreen.gif"));
        } catch (Exception e) {
            // print error and no image will be displayed instead of selected image
            e.printStackTrace();
            label = new JLabel("No image");
        }
        
        // add the image to our panel
        splashPanel.add(label, BorderLayout.CENTER);
49
        // get the size of the screen
        Dimension screen = Toolkit.getDefaultToolkit().getScreenSize();
52
        // calculate the position to place window in center of screens
        int x = (screen.width - (600)) / 2;
        int y = (screen.height - (300)) / 2;
56
        // set the window size and put in the center of the screen
        setBounds(x, y, (600), (300));
59
        // replace the window content with our image in the panel
        setContentPane(splashPanel);
62
        // ensure splash window is visible
        setVisible(true);
        
        // keep the screen up for 5 seconds
        try {
            // splash screen displays for 5000 milliseconds
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            // print error if one is caught
            e.printStackTrace();
            System.out.println("Interrupted Exception " + e);
        }
        
        // release resources
        dispose();
    }
}

Exported from Notepad++

 /*
  * File name: GameModel.java
  * Author: Mostapha A
  * Purpose: This maintains data and values
  * Class list: Game.java, GameView.java, GameModel.java, GameController.java
  */

 package piccross;

import java.util.Random;
import java.util.Timer;
import java.util.TimerTask;

/**
 * GameModel class contains game data
 * 
 * @author Mostapha Abdelaziz
 * @version 1.0
 * @see piccross package, Game.java, GameController.java
 * @since Java 16
 */
public class GameModel {
    /** The board dimension */
    private int dimension = 5;
    /** The board array representation */
    private Integer[][] board;
    /** The board selection array representation */
    private Integer[][] selectedBoard;
    /** The string with the solution */
    private String configString = "0";

    /** The starting seconds for timer */
    private int seconds = 0;
    /** Timer initialization */
    private Timer timer = new Timer();
    /** The timer task initialization */
    private TimerTask timerTask;

    /**
     * Default game model constructor
     */
    GameModel() {

    }

    /**
     * Generates a solution string based on dimensions
     */
    public void generateString() {
        int column = 0;
        int row = 0;
        // create a random object to randomize game solution
        Random rd = new Random();
        // reset current string
        configString = "";
        // temporary array and booleans for validation
        int[][] stringArray = new int[dimension][dimension];
        boolean rowCheck = false;
        boolean colCheck = false;

        // loop through dimension, generating a string for solution
        for (row = 0; row < dimension; row++) {
            // reset boolean checks
            rowCheck = false;
            for (column = 0; column < dimension; column++) {
                colCheck = false;
                // check that each column has at least one 1, otherwise generate randoms
                if (row == dimension - 1) {
                    // loop through the row
                    for (int i = 0; i < dimension - 1; i++) {
                        // check if there is a 1 in the row
                        if (stringArray[column][i] == 1) {
                            colCheck = true;
                        }
                    }
                    // if row check is false make last column in row a 1, otherwise randomise
                    if (colCheck == false) {
                        // set string and checks
                        colCheck = true;
                        configString = configString + "1";
                        stringArray[column][row] = 1;
                    } else {
                        if (rd.nextBoolean() == true) {
                            // set string and checks
                            rowCheck = true;
                            configString = configString + "1";
                            stringArray[column][row] = 1;
                        } else if (column == dimension - 1 && rowCheck == false) {
                            // if there isn't at least one 1 in row, make last column in row a 1
                            rowCheck = true;
                            configString = configString + "1";
                            stringArray[column][row] = 1;
                        } else {
                            // set string and checks
                            configString = configString + "0";
                            stringArray[column][row] = 0;
                        }
                    }
                } else {
                   // generate a random boolean, true is 1
                   if (rd.nextBoolean() == true) {
                       // set string and checks
                       rowCheck = true;
                       configString = configString + "1";
                       stringArray[column][row] = 1;
                   } else if (column == dimension - 1 && rowCheck == false) {
                       // if there isn't at least one 1 in row, make last column in row a 1
                       rowCheck = true;
                       configString = configString + "1";
                       stringArray[column][row] = 1;
                   } else {
                       // set string and checks
                       configString = configString + "0";
                       stringArray[column][row] = 0;
                   }
               }
           }
           // add a comma to the string
           if (row != dimension - 1) {
               configString = configString + ",";
           }
       }
       System.out.println(configString);
   }
125
   /**
    * Generates a 2d array representing the board solution based on the configuration string
    * @param string The configuration string to generate board out of
    */
   public void generateBoard(String string) {
       configString = string;
       // split the config string based on commas
       String[] rows = string.split(",");
       dimension = rows[0].length();
       // reset / make a new board representation
       board = new Integer[dimension][dimension];
       selectedBoard = new Integer[dimension][dimension];
       
       int column = 0;
       int row = 0;
141
       // loop through strings and create board
       for(row = 0; row < dimension; row++) {
           for(column = 0; column < dimension; column++) {
               // loop through each column string and put corresponding value in the board
               board[column][row] = Integer.parseInt(Character.toString(rows[row].charAt(column)));
               // set selection to -1 for unselected
               selectedBoard[column][row] = -1;
           }
       }
   }
   
   /**
    * Returns the current configuration string
    * @return The configuration string
    */
   public String getString() {
       return configString;
   }
   
   /**
    * Resets the time to 0
    */
   public void resetTime() {
       seconds = 0;
   }
   
   /**
    * Returns the current time
    * @return The time in seconds
    */
   public int returnTime() {
       return seconds;
   }
175
   /**
    * Changes the selection board 2d array representation based on a selection
    * @param column The button's column dimension to change
    * @param row The button's row dimension to change
    * @param markOn Whether the mark checkbox is in use
    * @return Whether the button was a correct selection
    */
   public int selectButton(int column, int row, boolean markOn) {
       // -1 = unselected
       // 0 = correct mark (false/0)
       // 1 = correct selection (true/1)
       // 2 = incorrect mark(false/0) or selection(true/1)
188
       // select the chosen button accordingly, return associated number
       if ((board[column][row] == 1) && (markOn == false)) {
           // if mark is unselected, and button is true set to 1 (correct selection/true)
           selectedBoard[column][row] = 1;
           return 1;
       } else if ((board[column][row] == 0) && (markOn == true)) {
           // if mark is selected, and button is false set to 0 (correct mark/false)
           selectedBoard[column][row] = 0;
           return 0;
       } else {
           // otherwise set to 2 (incorrect)
           selectedBoard[column][row] = 2;
           return 2;
       }
   }
   
   /**
    * Changes the boards dimension
    * @param newDimension The new dimension for the board
    */
   public void setDimension(int newDimension) {
       dimension = newDimension;
   }
   
   /**
    * Gets the dimension of the model
    * @return the dimension size
    */
   public int getDimension() {
       return dimension;
   }
220
   /**
    * Checks if a specific button is selected or not
    * @param column The button's column dimension to check
    * @param row The button's column dimension to check
    * @return Whether the button is selected and if it is correct
    */
   public int checkButtonSelected(int column, int row) {
       // return the provided buttons status
       return (selectedBoard[column][row]);
   }
231
   /**
    * Checks the solution for a specific button
    * @param column The button's column dimension to check
    * @param row The button's column dimension to check
    * @return The button's solution
    */
   public int checkSolution(int column, int row) {
       // return the provided buttons solution
       return (board[column][row]);
   }
242
   /**
    * Resets the selection boards 2d array representation to all unselected and timer to 0
    */
   public void reset() {
       // set each button to unselected
       int column = 0;
       int row = 0;
       for (row = 0; row < dimension; row++) {
           for (column = 0; column < dimension; column++) {
               selectedBoard[column][row] = -1;
           }
       }
       seconds = 0;
   }
257
   /**
    * Starts and keeps track of the timer on the GUI
    * @param gameView The GameView that will update the timer for
    */
   public void startTimer(GameView gameView) {
       // Timer task
       timerTask = new TimerTask() {
           public void run() {
               seconds++;
               // Update your interface
               gameView.updateTimer(seconds);
           }
       };
       try {
           timer.scheduleAtFixedRate(timerTask, 0, 1000);
       } catch (Exception e) {
           // Eventual treatment
275
       }
   }
}
279

Exported from Notepad++

 /*
  * File name: GameView.java
  * Author: Mostapha A
  * Purpose: This makes the splash screen and creates/maintains visual components
  * Class list: Game.java, GameView.java, GameModel.java, GameController.java
  */

 package piccross;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.GridLayout;
import java.awt.Toolkit;

import javax.swing.BorderFactory;
import javax.swing.BoxLayout;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.JTextPane;
import javax.swing.JWindow;
import javax.swing.ScrollPaneConstants;
import javax.swing.border.Border;
import javax.swing.text.SimpleAttributeSet;
import javax.swing.text.StyleConstants;
import javax.swing.text.StyledDocument;

import java.awt.event.ActionListener;
import java.awt.event.ItemListener;

/**
 * GameView class that sets up the splash screen and visual game components
 * 
 * @author Mostapha Abdelaziz
 * @version 1.1
 * @see piccross package, Piccross.java, GameController.java
 * @since Java 16
 */
public class GameView extends JFrame {
    /** Required long value */
    private static final long serialVersionUID = 1L;
    /** A grey border for use on different elements */
    private static Border greyBorder = BorderFactory.createMatteBorder(2, 2, 2, 2, new Color(70, 70, 70));
    /** A blue border for use on different elements */
    private static Border blueBorder = BorderFactory.createMatteBorder(3, 3, 3, 3, new Color(97, 197, 255));
    /** A grey background color for use on different elements */
    private static Color greyBG = new Color(84, 91, 102);
    /** A light grey background color for use on different elements */
    private static Color lightGreyBG = new Color(107, 112, 122);
    /** This is the check box for marking */
    private JCheckBox mark = new JCheckBox();
    /** This is the history area, the text box in the control panel */
    private JTextArea historyArea = new JTextArea();
    /** The panel that will contain the play area, hint area and mark check box */
    private static JPanel playArea;
    /**
     * The panel that will contain the logo and control panel elements score, time,
     * history area and reset button
     */
    private static JPanel controlPanel = new JPanel();
    /** The text box for the score */
    private JTextField score;
    /** The text box for the time */
    private JTextField time;
    /** The array that holds all the play buttons */
    private JButton[][] playButtons;
    /** The array that holds all the hint areas */
    private JPanel[] hintAreas;
    /** The array that holds the hint texts for the top hints */
    private JTextPane[] hintTextTop;
    /** The array that holds the hint texts/labels for the side hints */
    private JLabel[] hintTextSide;
    /** Keeps track of the board dimension */
    private int dimension = 5;

    /**
     * Default constructor, set the name
     */
    GameView() {
        // set window name
        super("piccross - mostapha");
    }

    /**
     * Sets up all visual components of the piccross game
    * 
    * @param menuHandler        Tha handler for the menu
    * @param playButtonHandler  The handler for the playing buttons
    * @param resetButtonHandler The handler for the reset button
    * @param checkBoxHandler    The handler for the mark check box
    */
   public void startGame(ActionListener menuHandler, ActionListener playButtonHandler,
           ActionListener resetButtonHandler, ItemListener checkBoxHandler) {
       // set attributes for main window
       setSize(987, 710);
       getContentPane().setBackground(greyBG);
       setResizable(false);
112
       // hides window if they close from the window button
       addWindowListener(new java.awt.event.WindowAdapter() {
           @Override
           public void windowClosing(java.awt.event.WindowEvent windowEvent) {
               setVisible(false);
           }
       });
       
       // set the layout for our main window
       setLayout(new BorderLayout());
123
       // set the image for application
       ImageIcon miniLogo;
       try {
           miniLogo = new ImageIcon("images/logomini.png");
           setIconImage(miniLogo.getImage());
       } catch (Exception e) {
           // print error and default image will be displayed
           e.printStackTrace();
       }
133
       // set up menu
       setUpMenu(menuHandler);
136
       // call methods that setup the separate panels
       mark.addItemListener(checkBoxHandler);
       setUpControlPanel(resetButtonHandler);
       playArea = new JPanel();
       setUpPlayingArea(playButtonHandler, checkBoxHandler);
142
       // add components
       add(controlPanel, BorderLayout.WEST);
       add(playArea, BorderLayout.CENTER);
146
       // set visible as true and center in the screen
       setVisible(true);
       setLocationRelativeTo(null);
       pack();
   }
   
   /**
    * sets the window as visible
    */
   public void setVisible() {
       setVisible(true);
   }
   
   /**
    * Returns whether the mark check box is selected
    * @return Selected status of mark check box
    */
   public boolean checkMark() {
       return mark.isSelected();
   }
167
   /**
    * Resets a games playing area visual components
    * 
    * @param playButtonHandler The handler for play buttons
    * @param checkBoxHandler   The handler for the check box
    */
   public void newGame(ActionListener playButtonHandler, ItemListener checkBoxHandler) {
       // remove components to update
       remove(playArea);
       playArea.removeAll();
       // set up playing are again
       setUpPlayingArea(playButtonHandler, checkBoxHandler);
       revalidate();
       repaint();
       // re add and validate
       add(playArea, BorderLayout.CENTER);
       revalidate();
       repaint();
   }
187
   /**
    * Sets up the menu bar and all it's items
    * 
    * @param menuHandler The handler for the menu items
    */
   public void setUpMenu(ActionListener menuHandler) {
       // create all the image icons
       // ImageIcon newGameIcon;
       ImageIcon solutionIcon;
       ImageIcon exitIcon;
       ImageIcon coloursIcon;
       ImageIcon aboutIcon;
       /*
        * new game will be sub menu for different dimensions, no icon try { newGameIcon
        * = new ImageIcon("images/newgame.gif"); } catch (Exception e) { // print error
        * and no image will be displayed instead of selected image e.printStackTrace();
        * newGameIcon = new ImageIcon(); }
        */
       try {
           solutionIcon = new ImageIcon("images/solution.gif");
       } catch (Exception e) { // print error and no image will be displayed instead of selected image
           e.printStackTrace();
           solutionIcon = new ImageIcon();
       }
       try {
           exitIcon = new ImageIcon("images/exit.gif");
       } catch (Exception e) { // print error and no image will be displayed instead of selected image
           e.printStackTrace();
           exitIcon = new ImageIcon();
       }
       try {
           coloursIcon = new ImageIcon("images/colours.gif");
       } catch (Exception e) { // print error and no image will be displayed instead of selected image
           e.printStackTrace();
           coloursIcon = new ImageIcon();
       }
       try {
           aboutIcon = new ImageIcon("images/about.gif");
       } catch (Exception e) { // print error and no image will be displayed instead of selected image
           e.printStackTrace();
           aboutIcon = new ImageIcon();
       }
       // Action commands
       // 13 = 3x3 grid
       // 15 = 5x5 grid
       // 110 = 10x10 grid
       // 2 = solution
       // 3 = exit
       // 4 = colours
       // 5 = about
238
       // Game menu
       JMenu gameMenu = new JMenu("Game");
241
       // create submenu for new game
       JMenu newGameMenu = new JMenu("New");
244
       // create new game menu options
       JMenuItem newGame3 = new JMenuItem("3x3 Game");
       newGameMenu.add(newGame3);
       newGame3.setActionCommand("13");
       newGame3.addActionListener(menuHandler);
       JMenuItem newGame5 = new JMenuItem("5x5 Game");
       newGameMenu.add(newGame5);
       newGame5.setActionCommand("15");
       newGame5.addActionListener(menuHandler);
       JMenuItem newGame10 = new JMenuItem("10x10 Game");
       newGameMenu.add(newGame10);
       newGame10.setActionCommand("110");
       newGame10.addActionListener(menuHandler);
258
       // add new game to game menu
       gameMenu.add(newGameMenu);
261
       // create solution menu item - add in Game menu
       JMenuItem solutionItem = new JMenuItem("Solution", solutionIcon);
       gameMenu.add(solutionItem);
       solutionItem.setActionCommand("2");
       solutionItem.addActionListener(menuHandler);
267
       // create exit menu item - add in Game menu
       JMenuItem exitItem = new JMenuItem("Exit", exitIcon);
       gameMenu.add(exitItem);
       exitItem.setActionCommand("3");
       exitItem.addActionListener(menuHandler);
273
       // create menu bar, add game menu
       JMenuBar menuBar = new JMenuBar();
       setJMenuBar(menuBar);
       menuBar.add(gameMenu);
278
       // create help menu
       JMenu helpMenu = new JMenu("Help");
281
       // create colours menu item - add in Help menu
       JMenuItem coloursItem = new JMenuItem("Colours", coloursIcon);
       helpMenu.add(coloursItem);
       coloursItem.setActionCommand("4");
       coloursItem.addActionListener(menuHandler);
287
       // create about menu item - add in Help menu
       JMenuItem aboutItem = new JMenuItem("About", aboutIcon);
       helpMenu.add(aboutItem);
       aboutItem.setActionCommand("5");
       aboutItem.addActionListener(menuHandler);
293
       // add help menu to menu bar
       menuBar.add(helpMenu);
296
   }
298
   /**
    * Adds to the history area a passed through message
    * 
    * @param message The string to be added to the history area
    */
   public void historyAreaMessage(String message) {
       historyArea.append(message);
       historyArea.setCaretPosition(historyArea.getDocument().getLength());
   }
308
   /**
    * Changes a buttons colour
    * 
    * @param column The button's column dimension
    * @param row    The button's row dimension
    * @param colour The colour to change to
    */
   public void changeButton(int column, int row, Color colour) {
       // change the indicated button to the indicated colour
       playButtons[column][row].setBackground(colour);
   }
320
   /**
    * Writes the hints in the hint areas
    * 
    * @param hintsTop  The hints to be written in the top hint areas
    * @param hintsSide The hints to be written in the side hint areas
    */
   public void writeHints(Integer[][] hintsTop, Integer[][] hintsSide) {
       int i = 0;
       int j = 0;
       String hint;
331
       // loop to write hints in the top hint areas
       for (i = 0; i < dimension; i++) {
           // reset hint
           hint = "";
           for (j = 0; j < 6; j++) {
               // if the hint is not 0, store at end of string
               if (hintsTop[i][j] != 0) {
                   hint = hint + hintsTop[i][j].toString() + "\n";
               } else {
                   // otherwise, hint is 0, put an empty space at the beginning of string
                   hint = " \n" + hint;
               }
           }
           // store all the hints in the corresponding hint label for hint area
           hintTextTop[i].setText(hint);
           hintTextTop[i].setBackground(lightGreyBG);
           hintTextTop[i].setHighlighter(null);
           hintTextTop[i].setEditable(false);
           // center the hints
           StyledDocument doc = hintTextTop[i].getStyledDocument();
           SimpleAttributeSet center = new SimpleAttributeSet();
           StyleConstants.setAlignment(center, StyleConstants.ALIGN_CENTER);
           doc.setParagraphAttributes(0, doc.getLength(), center, false);
       }
356
       // loop to write hints in the side hint areas
       for (i = 0; i < dimension; i++) {
           // reset hint
           hint = "";
           for (j = 0; j < 6; j++) {
               // if the hint is not 0, store at end of string
               if (hintsSide[i][j] != 0) {
                   hint = hint + "   " + hintsSide[i][j].toString();
               } else {
                   // otherwise, hint is 0, put an empty space at the beginning of string
                   hint = "   " + hint;
               }
           }
           // store all the hints in the corresponding hint label for hint area
           hint = hint + " ";
           hintTextSide[i].setText(hint);
           hintTextSide[i].setBackground(lightGreyBG);
       }
   }
376
   /**
    * Resets the history area and score
    */
   public void reset() {
       // set each button colour to white
       int row = dimension;
       int column = dimension;
       for (row = 0; row < dimension; row++) {
           for (column = 0; column < dimension; column++) {
               playButtons[column][row].setBackground(Color.WHITE);
           }
       }
       mark.setSelected(false);
       historyArea.setText("");
391
       updateScore(0);
   }
394
   /**
    * Updates the score
    * 
    * @param scoreNum The new score
    */
   public void updateScore(Integer scoreNum) {
       score.setText(scoreNum.toString());
   }
403
   /**
    * Updates the timer
    * 
    * @param seconds The new time
    */
   public void updateTimer(Integer seconds) {
       time.setText(seconds.toString());
   }
412
   /**
    * Creates and sets up the logo and control panel elements, including score,
    * time, history text area and reset button
    */
   public void setUpControlPanel(ActionListener resetButtonHandler) {
       // set up the panels and layouts
       controlPanel.setLayout(new BorderLayout());
       controlPanel.setBackground(greyBG);
       controlPanel.setPreferredSize(new Dimension(300, 650));
       // panel for scrolling history area
       JPanel historyAreaPanel = new JPanel();
       historyAreaPanel.setBackground(greyBG);
       historyAreaPanel.setLayout(new BorderLayout());
       // panel that will contain logo, and panel that contains the score and time
       JPanel topArea = new JPanel();
       topArea.setLayout(new BorderLayout());
       topArea.setBackground(greyBG);
       // panel that will contain the score and time
       JPanel scoreAndTime = new JPanel();
       scoreAndTime.setLayout(new BorderLayout());
       scoreAndTime.setBackground(greyBG);
       // panel that contains the score label and text box
       JPanel scorePanel = new JPanel();
       scorePanel.setLayout(new BorderLayout());
       scorePanel.setBackground(greyBG);
       scorePanel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
       // panel that contains the time label and text box
       JPanel timePanel = new JPanel();
       timePanel.setLayout(new BorderLayout());
       timePanel.setBackground(greyBG);
       timePanel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
       // panel that will contain the reset button
       JPanel resetPanel = new JPanel();
       resetPanel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
       resetPanel.setBackground(greyBG);
448
       // configure the elements that will be placed in the panels
       // configure the label for score
       JLabel labelScore = new JLabel("score ");
       labelScore.setForeground(Color.white);
       labelScore.setFont(controlPanel.getFont().deriveFont(25f));
454
       // configure the score text box
       score = new JTextField();
       score.setEditable(false);
       score.setText("0");
       score.setBorder(blueBorder);
       score.setBackground(lightGreyBG);
       score.setForeground(Color.white);
       score.setFont(controlPanel.getFont().deriveFont(18f));
       score.setHorizontalAlignment(JTextField.CENTER);
464
       // configure the label for the time
       JLabel labelTime = new JLabel("time ");
       labelTime.setForeground(Color.white);
       labelTime.setFont(controlPanel.getFont().deriveFont(25f));
469
       // configure the text box for the time
       time = new JTextField();
       time.setEditable(false);
       time.setText("time");
       time.setBorder(blueBorder);
       time.setBackground(lightGreyBG);
       time.setForeground(Color.white);
       time.setFont(controlPanel.getFont().deriveFont(18f));
       time.setHorizontalAlignment(JTextField.CENTER);
479
       // configure history area text box
       historyArea.setEditable(false);
       historyArea.setFont(controlPanel.getFont().deriveFont(18f));
       historyArea.setText("");
       // historyArea.setBorder(blueBorder);
       historyArea.setBackground(lightGreyBG);
       historyArea.setForeground(Color.white);
       // historyArea.setPreferredSize(new Dimension(280, 370));
488
       // create scrolling pane for history area
       JScrollPane scrollingHistory = new JScrollPane(historyArea);
       scrollingHistory.setBackground(greyBG);
       scrollingHistory.setBorder(blueBorder);
       // scrollingHistory.setPreferredSize(new Dimension(280, 370));
       scrollingHistory.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_NEVER);
495
       // add history area elements
       historyAreaPanel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
       historyAreaPanel.add(scrollingHistory, BorderLayout.CENTER);
499
       // configure the reset button
       JButton reset = new JButton();
       reset.addActionListener(resetButtonHandler);
       reset.setPreferredSize(new Dimension(100, 40));
       reset.setAlignmentX(Component.CENTER_ALIGNMENT);
       reset.setBackground(new Color(84, 91, 102));
       reset.setForeground(Color.white);
       reset.setBorder(blueBorder);
       reset.setText("reset");
       reset.setFont(controlPanel.getFont().deriveFont(25f));
510
       // Create and configure a label for the logo image
       JLabel logo = new JLabel();
       ImageIcon logoImg;
       try {
           logoImg = new ImageIcon("images/logocpl.png");
           logo.setIcon(logoImg);
           logo.setPreferredSize(new Dimension(300, 100));
       } catch (Exception e) {
           // print error and display no image
           e.printStackTrace();
       }
522
       // add all elements to their respective panels
       // the score
       scorePanel.add(labelScore, BorderLayout.WEST);
       scorePanel.add(score, BorderLayout.CENTER);
       // the time
       timePanel.add(labelTime, BorderLayout.WEST);
       timePanel.add(time, BorderLayout.CENTER);
       // reset button
       resetPanel.add(reset);
532
       // add our element panels to organizational panels
       scoreAndTime.add(scorePanel, BorderLayout.NORTH);
       scoreAndTime.add(timePanel, BorderLayout.SOUTH);
       topArea.add(logo, BorderLayout.NORTH);
       topArea.add(scoreAndTime, BorderLayout.CENTER);
538
       // add all the panels to the control panel that will be placed west on main
       // window
       controlPanel.add(topArea, BorderLayout.NORTH);
       controlPanel.add(historyAreaPanel, BorderLayout.CENTER);
       controlPanel.add(resetPanel, BorderLayout.SOUTH);
   }
545
   /**
    * Changes the boards dimension
    * 
    * @param newDimension The new dimension
    */
   public void setDimension(int newDimension) {
       dimension = newDimension;
   }
554
   /**
    * Displays a dialog at the end of the game
    * 
    * @param score The user's score
    */
   public void endGame(int score) {
       // get end game images
       ImageIcon victory;
       ImageIcon failure;
564
       // if perfect score show victory else defeat
       if (score == dimension * dimension) {
           try {
               victory = new ImageIcon("images/gamepicwinner.png");
               JOptionPane.showMessageDialog(null, null, "Victory!", JOptionPane.INFORMATION_MESSAGE, victory);
           } catch (Exception e) { // print error and no image will be displayed instead of selected image
               e.printStackTrace();
               JOptionPane.showMessageDialog(null, "You won!", "Victory!", JOptionPane.INFORMATION_MESSAGE, null);
           }
       } else {
           try {
               failure = new ImageIcon("images/gamepicend.png");
               JOptionPane.showMessageDialog(null, null, "Defeat!", JOptionPane.INFORMATION_MESSAGE, failure);
           } catch (Exception e) { // print error and no image will be displayed instead of selected image
               e.printStackTrace();
               JOptionPane.showMessageDialog(null, "You lost the game!", "Defeat!", JOptionPane.INFORMATION_MESSAGE,
                       null);
           }
       }
   }
585
   /**
    * Displays a dialog for about menu item
    */
   public void aboutDialog() {
       // get end game images
       ImageIcon about;
592
       try {
           about = new ImageIcon("images/piccross.png");
           JOptionPane.showMessageDialog(null, null, "About", JOptionPane.INFORMATION_MESSAGE, about);
       } catch (Exception e) { // print error and no image will be displayed instead of selected image
           e.printStackTrace();
           JOptionPane.showMessageDialog(null, "About", "About", JOptionPane.INFORMATION_MESSAGE, null);
       }
   }
601
   /**
    * Creates and sets up the mark check box and playing area elements, including
    * the buttons and hint area
    */
   public void setUpPlayingArea(ActionListener playButtonHandler, ItemListener checkBoxHandler) {
       // array for all the button names/action codes
       String[] buttonNames;
       // create an array for all the buttons, size of grid
       playButtons = new JButton[dimension][dimension];
       // create a panel to add the buttons to
       JPanel buttonGrid = new JPanel();
       buttonGrid.setLayout(new GridLayout(dimension, dimension));
       // create arrays for the hint areas
       hintAreas = new JPanel[dimension + dimension];
       hintTextTop = new JTextPane[dimension];
       hintTextSide = new JLabel[dimension];
       // variables for grid size, and looping
       int i = 0;
       int row = 0;
       int column = 0;
622
       // set the JPanel for the play area attributes
       playArea.setLayout(new GridBagLayout());
       playArea.setBackground(greyBG);
       playArea.setBorder(BorderFactory.createEmptyBorder());
       // gridbaglayout constraints
       GridBagConstraints c = new GridBagConstraints();
629
       // set amount of names
       buttonNames = new String[dimension * dimension];
632
       // set up the panel for the mark box
       JPanel markPanel = new JPanel();
       // create check box and mark label
       JLabel markLabel = new JLabel("mark");
       markLabel.setForeground(Color.white);
       markLabel.setFont(controlPanel.getFont().deriveFont(25f));
       // set the item listener and add
       mark.setBackground(greyBG);
641
       // add the mark elements to the mark panel
       markPanel.add(markLabel);
       markPanel.add(mark);
       markPanel.setBackground(greyBG);
646
       // add mark panel to playing area
       c.gridx = 1;
       c.gridy = 1;
       playArea.add(markPanel, c);
651
       // loop to set the hint area
       for (i = 0; i < (dimension * 2); i++) {
           // create a panel
           JPanel hintArea = new JPanel();
656
           // set attributes
           hintArea.setBackground(lightGreyBG);
659
           // set positioning in play area
           // if top row
           if (i < dimension) {
               hintArea.setBorder(BorderFactory.createMatteBorder(2, 2, 0, 2, greyBG));
               hintArea.setPreferredSize(new Dimension((500 / dimension), 150));
               hintArea.setLayout(new BoxLayout(hintArea, BoxLayout.PAGE_AXIS));
666
               c.gridy = 0; // doesnt change
               c.gridx = i + 2; // moves over one
669
               // size
               c.gridheight = 2;
               c.gridwidth = 1;
           } else {
               // if vertical/side hint area
               hintArea.setBorder(BorderFactory.createMatteBorder(2, 2, 2, 0, greyBG));
               hintArea.setPreferredSize(new Dimension(150, (500 / dimension)));
               hintArea.setLayout(new BorderLayout());
678
               c.gridx = 0; // doesnt change
               c.gridy = i + 2 - dimension; // moves down one
681
               // size
               c.gridheight = 1;
               c.gridwidth = 2;
           }
           c.fill = GridBagConstraints.BOTH;
687
           // add text and change postioning depending on top or side
           if (i < dimension) {
               // top hints
               // create and add a text panel to top areas area
               JTextPane hintLabel = new JTextPane();
               hintLabel.setFont(controlPanel.getFont().deriveFont(18f));
               hintLabel.setForeground(Color.WHITE);
695
               hintLabel.setAlignmentX(Component.CENTER_ALIGNMENT);
               hintLabel.setAlignmentY(Component.BOTTOM_ALIGNMENT);
698
               // add to array
               hintTextTop[i] = hintLabel;
               // add to JPanel hintArea
               hintArea.add(hintTextTop[i]);
           } else {
               // side hints
               // create and add a text panel to top areas area
               JLabel hintLabel = new JLabel("", JLabel.RIGHT);
               hintLabel.setFont(controlPanel.getFont().deriveFont(18f));
               hintLabel.setForeground(Color.WHITE);
709
               hintLabel.setAlignmentX(Component.RIGHT_ALIGNMENT);
               hintLabel.setAlignmentY(Component.CENTER_ALIGNMENT);
712
               // add to array
               hintTextSide[i - dimension] = hintLabel;
               // add to JPanel hintArea
               hintArea.add(hintTextSide[i - dimension], BorderLayout.EAST);
           }
718
           // add to array list
           hintAreas[i] = hintArea;
721
           // add to play area
           playArea.add(hintAreas[i], c);
       }
725
       // loop for grid size and create buttons
       for (i = 0; i < (dimension * dimension); i++) {
           // reset column after reaches gridSize
           if (column >= dimension) {
               column = 0;
               row++;
           }
733
           // create button name/action
           buttonNames[i] = (column + 1) + "," + (row + 1);
736
           // create and add button to array list
           playButtons[column][row] = createButton(buttonNames[i], playButtonHandler);
739
           // thicker border for outside edge
           if (column == 0 && row == 0) {
               // top left corner
               playButtons[column][row].setBorder(BorderFactory.createMatteBorder(4, 4, 2, 2, new Color(70, 70, 70)));
           } else if (column == dimension - 1 && row == 0) {
               // top right corner
               playButtons[column][row].setBorder(BorderFactory.createMatteBorder(4, 2, 2, 4, new Color(70, 70, 70)));
           } else if (column == 0 && row == dimension - 1) {
               // bottom left corner
               playButtons[column][row].setBorder(BorderFactory.createMatteBorder(2, 4, 4, 2, new Color(70, 70, 70)));
           } else if (column == dimension - 1 && row == dimension - 1) {
               // bottom right corner
               playButtons[column][row].setBorder(BorderFactory.createMatteBorder(2, 2, 4, 4, new Color(70, 70, 70)));
           } else if (column == 0) {
               // left edge
               playButtons[column][row].setBorder(BorderFactory.createMatteBorder(2, 4, 2, 2, new Color(70, 70, 70)));
           } else if (row == 0) {
               // top edge
               playButtons[column][row].setBorder(BorderFactory.createMatteBorder(4, 2, 2, 2, new Color(70, 70, 70)));
           } else if (column == dimension - 1) {
               // right edge
               playButtons[column][row].setBorder(BorderFactory.createMatteBorder(2, 2, 2, 4, new Color(70, 70, 70)));
           } else if (row == dimension - 1) {
               // bottom edge
               playButtons[column][row].setBorder(BorderFactory.createMatteBorder(2, 2, 4, 2, new Color(70, 70, 70)));
           }
766
           // add to panel
           buttonGrid.add(playButtons[column][row]);
769
           column++;
       }
772
       // add button grid to play area layout
       // set positions
       c.gridx = 2;
       c.gridy = 2;
777
       // size
       c.gridheight = dimension;
       c.gridwidth = dimension;
       c.fill = GridBagConstraints.BOTH;
782
       // add to play area
       playArea.add(buttonGrid, c);
   }
786
   /**
    * Creates a button and sets it up for actions
    * 
    * @param name          The name of the button, or the position
    * @param buttonHandler The action listener/event handler for the button
    * @return Returns the created button
    */
   public JButton createButton(String name, ActionListener buttonHandler) {
       // create button
       JButton button = new JButton();
797
       // set attributes
       button.setPreferredSize(new Dimension((500 / dimension), (500 / dimension)));
       button.setFocusable(false);
       button.setBackground(Color.white);
       button.setBorder(greyBorder);
       // button.setText(name);
804
       // set the action
       button.setActionCommand(name);
       button.addActionListener(buttonHandler);
808
       // return the created button
       return button;
   }
812
   /**
    * GameSplash class that sets up the splash screen
    * 
    * @author Mostapha Abdelaziz
    * @version 1.0
    * @see piccross package, Piccross.java
    * @since Java 16
    */
   public static class GameSplash extends JWindow {
       /** Required long value */
       private static final long serialVersionUID = 1L;
824
       /**
        * Displays a splash screen for 5 seconds
        */
       public void showSplashWindow() {
           // create panel that will hold image
           JPanel splashPanel = new JPanel(new BorderLayout());
831
           // create a label to place splash screen image
           JLabel label;
           try {
               label = new JLabel(new ImageIcon("images/loadingscreen.gif"));
           } catch (Exception e) {
               // print error and no image will be displayed instead of selected image
               e.printStackTrace();
               label = new JLabel("No image");
           }
841
           // add the image to our panel
           splashPanel.add(label, BorderLayout.CENTER);
844
           // get the size of the screen
           Dimension screen = Toolkit.getDefaultToolkit().getScreenSize();
847
           // calculate the position to place window in center of screens
           int x = (screen.width - (600)) / 2;
           int y = (screen.height - (300)) / 2;
851
           // set the window size and put in the center of the screen
           setBounds(x, y, (600), (300));
854
           // replace the window content with our image in the panel
           setContentPane(splashPanel);
857
           // ensure splash window is visible
           setVisible(true);
860
           // keep the screen up for 5 seconds
           try {
               // splash screen displays for 5000 milliseconds
               Thread.sleep(5000);
           } catch (InterruptedException e) {
               // print error if one is caught
               e.printStackTrace();
               System.out.println("Interrupted Exception " + e);
           }
870
           // release resources
           dispose();
       }
   }
}

Exported from Notepad++

 /*
  * File name: GameController.java
  * Author: Mostapha A
  * Purpose: Manages the timer and deals with actions
  * Class list: Game.java, GameView.java, GameModel.java, GameController.java
  */

 package piccross;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;

import javax.swing.JButton;
import javax.swing.JColorChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;

/**
 * GameController class that sets up the pic cross game
 * 
 * @author Mostapha Abdelaziz
 * @version 2.1 
 * @see piccross package, Game.java, GameModel.java, GameView.java
 * @since Java 16
 */
public class GameController extends JFrame {
    /**
     * Default variable
     */
    private static final long serialVersionUID = 1L;
    /**
     * The view portion of the game, will be set to what is passed through from the
     * main
     */
    private GameView gameView;
    /**
     * The model portion of the game, will be set to what is passed through from the
     * main
     */
    private GameModel gameModel;
    /** Keeps track of current dimension/grid size */
    private int dimension = 5;
    /** Keeps track of the score */
    private int score = 0;
    /** Keeps track of how many buttons selected for checking end game */
    private int selections = 0;
    /** Stores the colour for correct selections */
    private static Color correctColour = new Color(97, 197, 255);
    /** Stores the colour for correct marked selections */
    private static Color markedColour = new Color(195, 180, 165);
    /** Stores the colour for incorrect selections */
    private static Color errorColour = new Color(200, 86, 70);
    /** The handler for the mark check box */
    CheckBoxHandler checkBoxHandler = new CheckBoxHandler();
    /** This is the time and score, it is set to 0 until the game is finished */
    private static String gameInfo = "0#0";

    /**
     * Constructor for controller, takes in GameView and GameModel objects
     * 
     * @param view  The view portion of the game
     * @param model The model portion of the game
     */
    public GameController(GameView view, GameModel model) {
        // set to class variables
        gameView = view;
        gameModel = model;
    }

    /**
     * Starts the game, creates visual components and data needed
     */
    public void startGame(String gameConfig) {
        // create data for game logic
        if (gameConfig == "") {
            gameModel.generateString();
            gameModel.generateBoard(gameModel.getString());
        } else {
            gameModel.generateBoard(gameConfig);
            dimension = gameModel.getDimension();
            gameView.setDimension(dimension);
        }

        score = 0;
        // create all the visual components
        gameView.startGame(new MenuHandler(), new PlayButtonHandler(), new ResetHandler(), checkBoxHandler);
        /*
        gameView.reset();
        gameModel.reset();
        gameView.newGame(new PlayButtonHandler(), checkBoxHandler);
        */
        
        // setup hints
       setupHints();
       // start time
       int time = gameModel.returnTime();
       if (time == 0) {
           gameModel.startTimer(gameView);
       } else {
           gameModel.resetTime();
       }
       
   }
   
   /**
    * Sets the dimension for controller
    * @param newDimension The new dimension value
    */
   public void setDimension(int newDimension) {
       dimension = newDimension;
   }
118
   /**
    * Return the current time and score
    * 
    * @return The time and score in a string
    */
   public String returnInfo() {
       return gameInfo;
   }
127
   /**
    * Calculates the hints and sends them to the View to write
    */
   public void setupHints() {
       // create hint arrays, and write in hint areas
       int hintDimension = 6;
       Integer[][] hintsTop = new Integer[dimension][hintDimension];
       Integer[][] hintsSide = new Integer[dimension][hintDimension];
       // variables for loops
       int j;
       int i;
       int hintCounterSide;
       int hintCounterTop;
       int rowHint;
       int colHint;
       int rowHintPrev;
       int colHintPrev;
145
       // set hints to 0 by default
       for (i = 0; i < dimension; i++) {
           for (j = 0; j < hintDimension; j++) {
               hintsTop[i][j] = 0;
               hintsSide[i][j] = 0;
           }
       }
153
       // loop to check solution for hints
       for (i = 0; i < dimension; i++) {
           // hints and related variables start/reset at 0
           rowHint = 0;
           colHint = 0;
           rowHintPrev = 0;
           colHintPrev = 0;
           hintCounterSide = 0;
           hintCounterTop = 0;
           for (j = 0; j < dimension; j++) {
               // check how many trues are in a row for the hintsSide (row)
               if (gameModel.checkSolution(j, i) == 1) {
                   // increment current hint if the solution is true
                   rowHint++;
               } else {
                   // otherwise set to 0
                   rowHint = 0;
               }
172
               // check if the current hint is 0, and previous was not we are storing hint, or
               // if it is the last loop
               if ((rowHint == 0) && (rowHintPrev > 0)) {
                   // store previous hint
                   hintsSide[i][hintCounterSide] = rowHintPrev;
                   hintCounterSide++;
               } else if (j == dimension - 1) {
                   // if its last loop store the current row hint
                   hintsSide[i][hintCounterSide] = rowHint;
                   hintCounterSide++;
               }
184
               // set the previous row hint to current
               rowHintPrev = rowHint;
187
               // check how many trues are in a row for the hintsTop (column)
               if (gameModel.checkSolution(i, j) == 1) {
                   // increment current hint if the solution is true
                   colHint++;
               } else {
                   // otherwise set to 0
                   colHint = 0;
               }
196
               // check if the current hint is 0, and previous was not we are storing hint, or
               // if it is the last loop
               if ((colHint == 0) && (colHintPrev > 0)) {
                   // store previous hint
                   hintsTop[i][hintCounterTop] = colHintPrev;
                   hintCounterTop++;
               } else if (j == dimension - 1) {
                   // if its last loop store the current column hint
                   hintsTop[i][hintCounterTop] = colHint;
                   hintCounterTop++;
               }
208
               // set the previous column hint to current
               colHintPrev = colHint;
           }
212
       }
214
       // call function to write to hint areas
       gameView.writeHints(hintsTop, hintsSide);
   }
218
   /**
    * Works with the view to change the colours of the buttons
    * 
    * @param whichColour indicates which colour (selection/marked/error) to change
    */
   private void changeColours(int whichColour) {
       int column = 0;
       int row = 0;
       Color colour;
228
       // set colour based on whats selected
       if (whichColour == 0) {
           colour = markedColour;
       } else if (whichColour == 1) {
           colour = correctColour;
       } else {
           colour = errorColour;
       }
237
       // loop through the grid of buttons, changing corresponding colour
       for (row = 0; row < dimension; row++) {
           for (column = 0; column < dimension; column++) {
               // check the button selection status and update it's colour if it matches
               if (gameModel.checkButtonSelected(column, row) == whichColour) {
                   gameView.changeButton(column, row, colour);
               }
           }
       }
   }
248
   /**
    * Shows the solution on the buttons
    */
   private void showSolution() {
       int column = 0;
       int row = 0;
255
       // loop through the grid of buttons, changing corresponding colour
       for (row = 0; row < dimension; row++) {
           for (column = 0; column < dimension; column++) {
               // check the button solution and change button
               if (gameModel.checkSolution(column, row) == 0) {
                   gameModel.selectButton(column, row, true);
                   gameView.changeButton(column, row, markedColour);
               } else {
                   gameModel.selectButton(column, row, false);
                   gameView.changeButton(column, row, correctColour);
               }
           }
       }
   }
270
   /**
    * Creates a new game
    */
   public void createNewGame() {
       gameView.newGame(new PlayButtonHandler(), checkBoxHandler);
   }
   
   /**
    * Resets the controller variables keeping track of the game
    */
   public void resetController() {
       selections = 0;
       score = 0;
   }
   
   /**
    * Inner action listener class for managing the playing buttons
    * 
    * @author Mostapha Abdelaziz
    * @version 1.0
    * @since Java 16
    * @see GameController
    */
   private class PlayButtonHandler implements ActionListener {
       /**
        * This is called when a playing area button is clicked, it will print the
        * position in the history area
        * 
        * @param e The event object with the event information
        */
       @Override
       public void actionPerformed(ActionEvent e) {
           String actionCommand = e.getActionCommand();
           // split the action command into integers for column and row
           String[] dimensions = actionCommand.split(",");
           int column = Integer.parseInt(dimensions[0]) - 1;
           int row = Integer.parseInt(dimensions[1]) - 1;
308
           // print action to history area (text area in control panel) and console
           gameView.historyAreaMessage("Pos " + actionCommand + " clicked;\n");
           System.out.println(actionCommand);
312
           // check if the button is selected
           if (gameModel.checkButtonSelected(column, row) == -1) {
               // call the model to keep track of selections, and set button color
               int selection = gameModel.selectButton(column, row, gameView.checkMark());
               // 0 = correct mark (false/0)
               // 1 = correct selection (true/1)
               // 2 = incorrect mark(false/0) or selection(true/1)
               if (selection == 0) {
                   score++;
                   gameView.changeButton(column, row, markedColour);
               } else if (selection == 1) {
                   score++;
                   gameView.changeButton(column, row, correctColour);
               } else {
                   score--;
                   gameView.changeButton(column, row, errorColour);
               }
               // increment selections
               selections++;
               // if we reached end of the game, show dialog
               if (selections == dimension * dimension) {
                   gameView.endGame(score);
                   int time = gameModel.returnTime();
                   gameInfo = time + "#" + score;
               }
           }
339
           // update the score
           gameView.updateScore(score);
342
       }
344
   }
346
   /**
    * Inner action listener class for managing the reset button
    * 
    * @author Mostapha Abdelaziz
    * @version 1.0
    * @since Java 16
    * @see GameController
    */
   private class ResetHandler implements ActionListener {
       /**
        * This is called when the reset button is clicked, it will clear the history
        * area
        * 
        * @param e The event object with the event information
        */
       @Override
       public void actionPerformed(ActionEvent e) {
           // clear the history area text
           gameView.historyAreaMessage("");
           System.out.println("History area cleared");
367
           // reset buttons
           gameView.reset();
           gameModel.reset();
371
           // reset score
           score = 0;
           selections = 0;
       }
   }
377
   /**
    * Inner item listener class for managing the mark check box
    * 
    * @author Mostapha Abdelaziz
    * @version 1.0
    * @since Java 16
    * @see GameController
    */
   private class CheckBoxHandler implements ItemListener {
       /**
        * This is called when the mark check box is changed
        * 
        * @param e The event object with the event information
        */
       @Override
       public void itemStateChanged(ItemEvent e) {
           // if the check box is selected or unselected print info and toggle our variable
           if (gameView.checkMark() == true) {
               gameView.historyAreaMessage("Mark set;" + "\n");
               System.out.println("Mark set;");
           } else {
               gameView.historyAreaMessage("Mark reset;" + "\n");
               System.out.println("Mark reset;");
           }
       }
   }
404
   /**
    * Inner action listener class for managing the menus
    * 
    * @author Mostapha Abdelaziz
    * @version 1.0
    * @since Java 16
    * @see GameController
    */
   private class MenuHandler implements ActionListener {
       /**
        * This is called when any menu item is selected
        * 
        * @param e The event object with the event information
        */
       @Override
       public void actionPerformed(ActionEvent e) {
           // 13 = 3x3 grid
           // 15 = 5x5 grid
           // 110 = 10x10 grid
           // 2 = solution
           // 3 = exit
           // 4 = colours
           // 5 = about
428
           String menuChoice = e.getActionCommand();
430
           // depending on menu choice do something
           if (menuChoice == "13") {
               // make a new game with a 3x3 grid
               System.out.println("menu choice 3x3 grid selected");
435
               // reset view and model
               gameView.reset();
               gameModel.reset();
               resetController();
440
               // set new dimension
               dimension = 3;
               gameView.setDimension(dimension);
               gameModel.setDimension(dimension);
445
               // reset play area
               gameView.newGame(new PlayButtonHandler(), checkBoxHandler);
448
               // create data for game logic
               gameModel.generateString();
               gameModel.generateBoard(gameModel.getString());
452
               // setup hints
               setupHints();
455
           } else if (menuChoice == "15") {
               // make a new game with a 5x5 grid
               System.out.println("menu choice 5x5 grid selected");
               // reset view and model
               gameView.reset();
               gameModel.reset();
               resetController();
463
               // set new dimension
               dimension = 5;
               gameView.setDimension(dimension);
               gameModel.setDimension(dimension);
468
               // reset play area
               gameView.newGame(new PlayButtonHandler(), checkBoxHandler);
471
               // create data for game logic
               gameModel.generateString();
               gameModel.generateBoard(gameModel.getString());
475
               // setup hints
               setupHints();
           } else if (menuChoice == "110") {
               // make a new game with a 10x10 grid
               System.out.println("menu choice 10x10 grid selected");
               // reset view and model
               gameView.reset();
               gameModel.reset();
               resetController();
               
               // set new dimension
               dimension = 10;
               gameView.setDimension(dimension);
               gameModel.setDimension(dimension);
490
               // reset play area
               gameView.newGame(new PlayButtonHandler(), checkBoxHandler);
493
               // create data for game logic
               gameModel.generateString();
               gameModel.generateBoard(gameModel.getString());
497
               // setup hints
               setupHints();
           } else if (menuChoice == "2") {
               // display the solution, set score to 0
               System.out.println("menu choice solution selected");
               gameModel.reset();
               gameView.reset();
               showSolution();
               score = 0;
507
               // get solution string
               String solution = gameModel.getString();
               String[] rows = solution.split(",");
               // print to history area
               for (String row : rows) {
                   gameView.historyAreaMessage(row + "\n");
                   System.out.println(row);
               }
           } else if (menuChoice == "3") {
               // exit the game
               System.out.println("menu choice exit selected");
               System.exit(0);
           } else if (menuChoice == "4") {
               // display colour chooser
               System.out.println("menu choice colour selected");
               new ColourChooser();
           } else if (menuChoice == "5") {
               // display about dialog
               System.out.println("menu choice about selected");
               gameView.aboutDialog();
           }
       }
530
   }
532
   /**
    * Inner colour chooser class deals with changing the colours in the menu
    * 
    * @author Mostapha Abdelaziz
    * @version 1.0
    * @see piccross package, GameController.java, GameModel.java
    * @since Java 16
    */
   private class ColourChooser extends JFrame implements ActionListener {
       /** Default variable */
       private static final long serialVersionUID = 1L;
       /** The label that will display the correct selection colour */
       private JLabel correctLabel;
       /** The label that will display the marked selection colour */
       private JLabel markedLabel;
       /** The label that will display the incorrect selection colour */
       private JLabel errorLabel;
550
       /**
        * Constructor for the menu option to change colour, creates a new frame with
        * selections
        */
       ColourChooser() {
           // new frame for choosing colours
           JFrame coloursFrame = new JFrame("Choose Colours");
           coloursFrame.setLayout(new BorderLayout());
559
           // Three panels for each Colour
           JPanel correctPanel = new JPanel();
           correctPanel.setLayout(new BorderLayout());
           JPanel markedPanel = new JPanel();
           markedPanel.setLayout(new BorderLayout());
           JPanel errorPanel = new JPanel();
           errorPanel.setLayout(new BorderLayout());
567
           // create labels and buttons for each colour
           correctLabel = new JLabel();
           correctLabel.setBackground(correctColour);
           correctLabel.setPreferredSize(new Dimension(150, 80));
           correctLabel.setOpaque(true);
           markedLabel = new JLabel();
           markedLabel.setBackground(markedColour);
           markedLabel.setPreferredSize(new Dimension(150, 80));
           markedLabel.setOpaque(true);
           errorLabel = new JLabel();
           errorLabel.setPreferredSize(new Dimension(150, 80));
           errorLabel.setBackground(errorColour);
           errorLabel.setOpaque(true);
581
           // buttons
           JButton correctButton = new JButton("Colour 1: Correct");
           correctButton.setPreferredSize(new Dimension(150, 30));
           correctButton.setActionCommand("correct");
           correctButton.addActionListener(this);
           JButton markedButton = new JButton("Colour 2: Marked");
           markedButton.setPreferredSize(new Dimension(150, 30));
           markedButton.setActionCommand("marked");
           markedButton.addActionListener(this);
           JButton errorButton = new JButton("Colour 3: Error");
           errorButton.setPreferredSize(new Dimension(150, 30));
           errorButton.setActionCommand("error");
           errorButton.addActionListener(this);
595
           // add labels and buttons to their respective panels
           correctPanel.add(correctLabel, BorderLayout.NORTH);
           correctPanel.add(correctButton, BorderLayout.SOUTH);
           markedPanel.add(markedLabel, BorderLayout.NORTH);
           markedPanel.add(markedButton, BorderLayout.SOUTH);
           errorPanel.add(errorLabel, BorderLayout.NORTH);
           errorPanel.add(errorButton, BorderLayout.SOUTH);
603
           // add panels to frame
           coloursFrame.add(correctPanel, BorderLayout.WEST);
           coloursFrame.add(markedPanel, BorderLayout.CENTER);
           coloursFrame.add(errorPanel, BorderLayout.EAST);
608
           // set dialog size and visibility
           coloursFrame.setSize(470, 150);
           coloursFrame.setVisible(true);
       }
613
       /**
        * Action listener for keeping track of which colours are being changed
        */
       public void actionPerformed(ActionEvent e) {
           // store action command
           String colourButton = e.getActionCommand();
620
           // change colours with a colour chooser depending on button
           if (colourButton == "correct") {
               // change the correct colour, and corresponding colour in the chooser and
               // buttons
               Color c = JColorChooser.showDialog(this, "Correct Colour", correctColour);
               if (c != null) {
                   correctColour = c;
                   correctLabel.setBackground(c);
                   changeColours(1);
               }
           } else if (colourButton == "marked") {
               // change the marked colour, and corresponding colour in the chooser and buttons
               Color c = JColorChooser.showDialog(this, "Marked Colour", markedColour);
               if (c != null) {
                   markedColour = c;
                   markedLabel.setBackground(c);
                   changeColours(0);
               }
           } else if (colourButton == "error") {
               // change the error colour, and corresponding colour in the chooser and buttons
               Color c = JColorChooser.showDialog(this, "Error Colour", errorColour);
               if (c != null) {
                   errorColour = c;
                   errorLabel.setBackground(c);
                   changeColours(2);
               }
           }
       }
   }
650
}