Computer Science 252
Problem Solving with Java

Spring 2015, The College of Saint Rose

TicTacToeSwing Demo

A working demo of TicTacToeSwing will appear below. Click inside the applet to interact with it.



TicTacToeSwing BlueJ Project

Click here to download a BlueJ project for TicTacToeSwing.


TicTacToeSwing Source Code

The Java source code for TicTacToeSwing is below. Click on a file name to download it.


TicTacToeSwing.java

/*
 * Example TicTacToe: A Java Swing implementation of a Tic-Tac-Toe game
 *
 * Jim Teresco, The College of Saint Rose, CSC 523, Summer 2014
 * Updated for CSC 252, Spring 2015
 *
 * Based on Objectdraw version, also by Jim Teresco
 * 
 * $Id: TicTacToe.java 2383 2014-06-18 19:49:50Z terescoj $
 */

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Container;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JApplet;
import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JPanel;

public class TicTacToeSwing extends JApplet implements ActionListener {
    
    // some constants to define parameters of the game
    private static final int GAME_SIZE = 3;
    private static final Color BUTTON_COLOR = Color.yellow;

    // Denote value of a square to show who has played there
    private static final int EMPTY = 0;
    private static final int X_MARK = 1;
    private static final int O_MARK = 2;

    // The grid contents: int values that will contain the int
    // values above, and the actual JButton objects we will
    // use for game play
    private int[][] marks;
    private JButton[][] buttons;

    // Whose turn it is next
    private int nextMark = X_MARK;

    // Whether the game has been won or not
    private boolean gameOver = false;

    // the label that will give game status
    private JLabel messageLabel;
    
    // the play again button
    private JButton playAgain;
    
    public void init() {
        
        Container contentPane = getContentPane();
        
        // create our int representation of the game status
        marks = new int[GAME_SIZE][GAME_SIZE];
        
        // we start with a panel at the top for a message
        JPanel topPanel = new JPanel();
        
        messageLabel = new JLabel("");
        messageLabel.setFont(new Font("Serif", Font.BOLD, 36));
        topPanel.add(messageLabel);
        contentPane.add(topPanel, BorderLayout.NORTH);
        
        // the grid for game play
        buttons = new JButton[GAME_SIZE][GAME_SIZE];
        JPanel gamePanel = new JPanel();
        gamePanel.setLayout(new GridLayout(GAME_SIZE, GAME_SIZE));
        for (int row = 0; row < GAME_SIZE; row++) {
            for (int col = 0; col < GAME_SIZE; col++) {
                buttons[row][col] = new JButton("X");
                buttons[row][col].addActionListener(this);
                buttons[row][col].setFont(new Font("Sans Serif", Font.BOLD, 72));
                buttons[row][col].addActionListener(this);
                buttons[row][col].setBackground(Color.black);
                buttons[row][col].setOpaque(true);
                gamePanel.add(buttons[row][col]);
            }
        }
        contentPane.add(gamePanel, BorderLayout.CENTER);
        
        // and a button at the bottom for restarting the game
        JPanel bottomPanel = new JPanel();
        playAgain = new JButton("Play Again");
        playAgain.addActionListener(this);
        bottomPanel.add(playAgain);
        contentPane.add(bottomPanel, BorderLayout.SOUTH);
        
        contentPane.validate();
        
        reset(); // initialize game play
    }
    
    // everything that needs to happen for the start of a new game
    private void reset() {
    
        for (int row = 0; row < GAME_SIZE; row++) {
            for (int col = 0; col < GAME_SIZE; col++) {
                buttons[row][col].setText("");
                marks[row][col] = EMPTY;
            }
        }
        gameOver = false;
        messageLabel.setText("Welcome! X goes first!");
        nextMark = X_MARK;
        playAgain.setEnabled(false);
    }
    
    /**
     * Check to see if the game is won as a result of a mark being placed
     * at position row, col.  The game is over if an entire row, column, or
     * diagonal has the same pieces.
     * 
     * @param row the row number (0, 1, 2) of the cell just marked
     * @param col the column number (0, 1, 2) of the cell just marked
     * @param matchMark the mark, X_MARK or O_MARK, just placed
     * 
     * @return true if the current player now has won the game, false otherwise
     */
    private boolean checkGameWon(int row, int col, int matchMark) {
        return checkForRowWin(row, matchMark)
        || checkForColWin(col, matchMark)
        || checkForDiagWin(matchMark)
        || checkForDiag2Win(matchMark); 
    }

    /**
     * Check to see if the game is a tie: all positions are occupied,
     * but no one has won.
     * 
     * @return true if all positions are occupied
     */
    private boolean checkAllFilled() {
        for (int row = 0; row < GAME_SIZE; row++) {
            for (int col = 0; col < GAME_SIZE; col++) {
                if (marks[row][col] == EMPTY) {
                    return false;
                }
            }
        }
        return true;
    }

    /**
     * Check for a win in the given row by the player with the 
     * given mark.
     * 
     * @param row the row number to check
     * @param matchMark the mark, X_MARK or O_MARK, just placed
     * 
     * @return whether the given row contains all matchMark entries
     */
    private boolean checkForRowWin(int row, int matchMark) {
        for (int col = 0; col < GAME_SIZE; ++col) {
            if (marks[row][col] != matchMark) {
                return false;
            }
        }
        return true;
    }

    /**
     * Check for a win in the given column by the player with the 
     * given mark.
     * 
     * @param col the column number to check
     * @param matchMark the mark, X_MARK or O_MARK, just placed
     * 
     * @return whether the given column contains all matchMark entries
     */
    private boolean checkForColWin(int col, int matchMark) {
        for (int row=0; row < GAME_SIZE; ++row) {
            if (marks[row][col] != matchMark) {
                return false;
            }   
        }
        return true;
    }

    /**
     * Check for a win in the main diagonal by the player with the 
     * given mark.  This is the diagonal from the top left to bottom right.
     * 
     * @param matchMark the mark, X_MARK or O_MARK, just placed
     * 
     * @return whether the main diagonal contains all matchMark entries
     */
    private boolean checkForDiagWin(int matchMark) {
        for (int i = 0; i < GAME_SIZE; ++i) {
            if (marks[i][i] != matchMark) {
                return false;   
            }
        }
        return true;
    }

    /**
     * Check for a win in the off diagonal by the player with the 
     * given mark.  This is the diagonal from the bottom left to top right.
     * 
     * @param matchMark the mark, X_MARK or O_MARK, just placed
     * 
     * @return whether the off diagonal contains all matchMark entries
     */
    private boolean checkForDiag2Win(int matchMark) {
        for (int i = 0; i < GAME_SIZE; ++i) {
            if (marks[i][GAME_SIZE-i-1] != matchMark) {
                return false;   
            }
        }
        return true;
    }

        /**
     * Draw the appropriate mark in the appropriate row/col in
     * the Tic-Tac-Toe board
     * 
     * @param row the row number (0, 1, 2) of the cell to mark
     * @param col the column number (0, 1, 2) of the cell to mark
     * @param mark what to mark, X_MARK or O_MARK
     */
    private void drawMark(int row, int col, int mark) {
        if (mark == X_MARK) {
            buttons[row][col].setText("X");
        } else {
            buttons[row][col].setText("O");
        }
    }


    public void actionPerformed(ActionEvent eventInfo) {
        
        if (eventInfo.getSource() == playAgain) {
            // this can only happen if the button is enabled, so
            // we reset unconditionally here
            reset();
        }
        else {
            // Figure out which cell in the grid was clicked in
            int col = 0;
            int row = 0;
            
            for (int r = 0; r < GAME_SIZE; r++) {
                for (int c = 0; c < GAME_SIZE; c++) {
                    if (eventInfo.getSource() == buttons[r][c]) {
                        col = c;
                        row = r;
                    }
                }
            }

            // Make sure the grid is empty before adding a mark.
            // Also make sure the game is not already over
            if (marks[row][col] == EMPTY && !gameOver) {
                // Add the mark
                marks[row][col] = nextMark;

                drawMark(row, col, nextMark);

                // See if the game is won
                if (checkGameWon(row, col, nextMark)) {
                    if (nextMark == X_MARK) {
                        messageLabel.setText("X Wins!");
                    } else {
                        messageLabel.setText("O Wins!");
                    }
                    gameOver = true;
                }

                // see if it's a tie
                if (!gameOver && checkAllFilled()) {
                    messageLabel.setText("It's a tie!");
                    gameOver = true;
                }

                if (!gameOver) {
                    // switch players
                    if (nextMark == X_MARK) {
                        nextMark = O_MARK;
                        messageLabel.setText("O's Turn");
                    } else {
                        nextMark = X_MARK;
                        messageLabel.setText("X's Turn");
                    }
                }
                else {
                    // if the game is over, we enable the play again button
                    playAgain.setEnabled(true);
                }
            }
        }
    }
}