# Version
version=0.1 beta

# Declare minimum and maximum number of players for this game
min.num.players=2
max.num.players=2

# Must be a "colour.1" to "colour.x" where x = max.num.players
player.colour.0=255,255,255
player.colour.1=0,0,0

# Server
jogre.server.title=JOGRE TicTacToe Server

# Client
jogre.client.title=JOGRE TicTacToe Client
jogre.client.welcome.message=Welcome to JOGRE TicTacToe!
jogre.table.title=Jogre TicTacToe Table

# Must be a "player.label.0" to "player.label.x"
# where x = max.num.players - 1 (from game.properties)
player.label.0=X
player.label.1=O

package org.jogre.tictactoe.server;

import java.net.Socket;

import org.jogre.common.JogreModel;
import org.jogre.server.JogreServer;
import org.jogre.server.ServerConnectionThread;

// TicTacToeServer Server.
public class TicTacToeServer extends JogreServer {

  // Constructor
  public TicTacToeServer (String [] args) {
    super (args); // Call super constructor and pass in command line args
  }

  // Return the correct type of connection thread for this server.
  public ServerConnectionThread connect (Socket connection, JogreServer server) {
    return new TicTacToeServerConnectionThread (connection, server);
  }

  // Return the correct game model (ignore)
  public JogreModel getJogreModel () {
    return null;
  }

  // Main method.
  public static void main (String [] args) {
    TicTacToeServer server = new TicTacToeServer (args);
    server.run ();      // Run the server
  }
}

package org.jogre.tictactoe.server;

import java.net.Socket;

import org.jogre.common.TransmissionException;
import org.jogre.server.JogreServer;
import org.jogre.server.ServerConnectionThread;

// Server thread which deals with any client requests.
public class TicTacToeServerConnectionThread extends ServerConnectionThread {

  // Constructor
  public TicTacToeServerConnectionThread (Socket clientSocket, JogreServer server) {
    super(clientSocket, server);
  }

  // This method reads a message going to the server and does something with it
  public void parse (String messageType, String inString) throws TransmissionException {
    if (messageType.equals ("Undefined")) {
      // Will fill this in later
    }
    else
      super.parse (messageType, inString);  // Super classes deals with most messages
  }
}

package org.jogre.tictactoe.client;

import java.net.Socket;

import org.jogre.client.ClientConnectionThread;

// TicTacToe Client connection thread which sends/recieves information to/from the server.
public class TicTacToeClientConnectionThread extends ClientConnectionThread {

  protected ITicTacToeClient clientInterface;

  // Constructor for a client connection thread
  protected TicTacToeClientConnectionThread (
      Socket connection, String username, ITicTacToeClient clientInterface) {
    super(connection, username, clientInterface);

    this.clientInterface = clientInterface;    // link to client frame (through interface)
  }

  // This method reads a message going to the server and does something with it
  public void parse (String messageType, String inString) {
    if (messageType.equals ("Undefined")) {
      // Will fill this in later
    }
    else
      super.parse (messageType, inString);  // Super classes deals with most messages
  }
}

package org.jogre.tictactoe.client;

import org.jogre.client.IClient;

// Interface which sits between the ClientConnectionThread a frame.
public interface ITicTacToeClient extends IClient {

  // Fill in later
}

package org.jogre.tictactoe.client;

import java.net.Socket;

import org.jogre.awt.JogreClientFrame;
import org.jogre.awt.JogreTableFrame;
import org.jogre.client.ClientConnectionThread;
import org.jogre.client.IClient;

// Tic-tac-toe client frame
public class TicTacToeClientFrame extends JogreClientFrame implements ITicTacToeClient {

  public TicTacToeClientFrame () {
    super ();
  }

  // Return the correct client connection thread
  public ClientConnectionThread getClientConnectionThread (
    Socket connection, String username, IClient clientInterface
  ) {
    return new TicTacToeClientConnectionThread (
      connection, username, (ITicTacToeClient)clientInterface);
  }

  // Return the correct table frame (each game).
  public JogreTableFrame getJogreTableFrame (ClientConnectionThread conn, int tableNum) {
    return new TicTacToeTableFrame (conn, tableNum);
  }

  // Main method where this class gets run.
  public static void main (String [] args) {
    TicTacToeClientFrame frame = new TicTacToeClientFrame ();
  }
}

package org.jogre.tictactoe.client;

import javax.swing.*;

import org.jogre.awt.JogreTableFrame;
import org.jogre.client.ClientConnectionThread;

// Jogre table frame
public class TicTacToeTableFrame extends JogreTableFrame {

  // Constructor which passes a client connection thread and a table
  public TicTacToeTableFrame (ClientConnectionThread conn, int tableNum) {
    super(conn, tableNum);
    
    // Set icon
    ImageIcon barIcon = new ImageIcon ("images/tictactoe_icon.gif");
    this.setIconImage(barIcon.getImage());
    
    // Fill in rest later
  }
}

package org.jogre.tictactoe.client;

import org.jogre.common.JogreModel;

// Model which holds the data for a game of TicTacToe
public class TicTacToeModel extends JogreModel {

  // Declare constans to define model
  public static final int BLANK = -1;
  public static final int X     = 0;
  public static final int O     = 1;

  // model (3x3 two dimensional integer array)
  private int [][] data = new int [3][3];

  // Constructor
  public TicTacToeModel() {
    super();
    reset ();
  }

  // Start method which calls reset method (resets the model).
  public void start() {
    reset ();
  }

  // reset the model back to zeros
  private void reset () {
    for (int x = 0; x < 3; x++) {
      for (int y = 0; y < 3; y++) {
        data [x][y] = BLANK;
      }
    }
    refreshObservers();     // inform view
  }

  // return data at a particular point
  public int getData (int x, int y) {
    return data [x][y];
  }

  // set data at a point
  public void setData (int x, int y, int value) {
    data [x][y] = value;
    refreshObservers();   // update any views on this model
  }
}

package org.jogre.tictactoe.awt;

import java.awt.*;
import javax.swing.ImageIcon;

import org.jogre.awt.AbstractBoardComponent;
import org.jogre.tictactoe.client.TicTacToeModel;

// TicTacToe visual board component (view of the model).
public class TicTacToeBoardComponent extends AbstractBoardComponent {
  
  // Declare constants which define what the board looks like
  private static final int NUM_OF_ROWS_COLS = 3;
  private static final int CELL_SIZE = 100;
  private static final int CELL_SPACING = 1;
  private static final int BORDER_SPACING = 0;
  
  // Link to the model
  protected TicTacToeModel model;
  
  // Images for an X and an O
  private static final ImageIcon [] images = {
    new ImageIcon ("images/x.gif"),
    new ImageIcon ("images/o.gif")};
  
  // Constructor which creates the board
  public TicTacToeBoardComponent (TicTacToeModel model) {
    // Call constructor in AbstractBoardComponent
    super (NUM_OF_ROWS_COLS, NUM_OF_ROWS_COLS, CELL_SIZE, CELL_SPACING,
         0, 0, false, false, false);

    this.model = model;     // link to model

    // set colours
    setColours (Color.white, Color.white, Color.black, Color.white);
  }

  // Update the graphics depending on the model
  public void paintComponent (Graphics g) {
    // Draw the board (AbstractBoardComponent)
    super.paintComponent (g);

    // draw each TicTacToe piece on the board (loop through the model)
    for (int x = 0; x < 3; x++) {
      for (int y = 0; y < 3; y++) {
        // get piece from model
        int piece = model.getData(x, y);

        // Now get screen co-ordinates (AbstractBoardComponent)
        Point screen = getScreenCoords (x, y);
        
        // If piece isn't an blank piece then draw the image on the screen
        if (piece != TicTacToeModel.BLANK) {
          Image image = images [piece].getImage();
          g.drawImage (image, screen.x, screen.y, null);  // draw image
        }
      }
    }
  }
}

package org.jogre.tictactoe.client;

import java.awt.Point;
import java.awt.event.MouseEvent;

import org.jogre.client.JogreController;
import org.jogre.tictactoe.awt.TicTacToeBoardComponent;

// Controller which updates the model and listens to user input on the visual board.
public class TicTacToeController extends JogreController {
  
  // links to game data and the board component
  protected TicTacToeModel model;
  protected TicTacToeBoardComponent boardComponent;
  
  // Constructor
  public TicTacToeController(TicTacToeModel model, TicTacToeBoardComponent boardComponent) {
    super(model, boardComponent);

    this.model = model;           // set fields
    this.boardComponent = boardComponent;
  }
  
  // Overwrite the mousePressed method
  public void mousePressed (MouseEvent e) {

    // ensure game is started and it is this players turn
    if (isGamePlaying() && isThisPlayersTurn ()) {

      // get board point from screen position of mouse click
      Point board = boardComponent.getBoardCoords (e.getX(), e.getY());
      
      // ensure board point is in range (0 to 2)
      if (board.x >= 0 && board.x < 3 && board.y >= 0 && board.y < 3) {
        
        // check model at this point is BLANK and it is this persons go
        if (model.getData(board.x, board.y) == TicTacToeModel.BLANK) {

          int value = getCurrentPlayerSeatNum();
          move (board.x, board.y, value);   // move

          checkGameOver ();   // check to see if the games overv
        }
      }
    }
  }

  // Update the model
  public void move (int x, int y, int value) {
    // update model and change player turn
    model.setData (x, y, value);

    // next player turn.
    nextPlayer ();
  }

  // Check to see if the game is over
  private void checkGameOver () { }    // fill in later.
}

package org.jogre.tictactoe.client;

import javax.swing.*;

import org.jogre.awt.JogreTableFrame;
import org.jogre.client.ClientConnectionThread;
import org.jogre.tictactoe.awt.TicTacToeBoardComponent;

// Jogre table frame
public class TicTacToeTableFrame extends JogreTableFrame {

  private TicTacToeModel model;                        // model reference
  private TicTacToeBoardComponent boardComponent;      // board reference
  private TicTacToeController controller;              // controller reference

  // Constructor which passes a client connection thread and a table
  public TicTacToeTableFrame (ClientConnectionThread conn, int tableNum) {
    super(conn, tableNum);

    // Set icon
    ImageIcon barIcon = new ImageIcon ("images/tictactoe_icon.gif");
      this.setIconImage(barIcon.getImage());

    // Create model, view and register view to model
    model = new TicTacToeModel ();    // create model
    boardComponent = new TicTacToeBoardComponent (model); // board
    model.addObserver(boardComponent);          // board observes model

    // Create controller which updates model and controlls the view
    controller = new TicTacToeController (model, boardComponent);
    controller.setConnection(conn, tableNum);       // connection
    boardComponent.setController (controller);

    // Add view to a panel and set on table frame
    JPanel panel = new JPanel ();   // create a panel
    panel.add (boardComponent);     // add board to panel
    setGamePanel (panel);           // add panel to table frame

    // Set up MVC classes in super class (CONSTRUCTOR MUST CALL THIS)
    setupMVC (model, boardComponent, controller);
  }
}

package org.jogre.tictactoe.comm;

import java.util.StringTokenizer;

import org.jogre.comm.CommTableMessage;
import org.jogre.common.TransmissionException;

// Immutable communication object for a tic tac toe move.
public class CommTicTacToeMove extends CommTableMessage {

  public static final String TIC_TAC_TOE = "TIC_TAC_TOE";    // header token

  private int x, y, value;   // position of move

  // Constructor which takes a move from a player.
  public CommTicTacToeMove (String username, int tableNum, int x, int y, int value) {
    super (username, tableNum);

    // set x and y
    this.x = x;
    this.y = y;
    this.value = value;
  }

  // Constructor which takes a String from a flatten () method.
  public CommTicTacToeMove (String inString) throws TransmissionException {
    super ();
    StringTokenizer st = new StringTokenizer (inString);
    st.nextToken();       // read header token
    try {
      this.username = st.nextToken();
      this.tableNum = Integer.parseInt(st.nextToken());
      this.x = Integer.parseInt(st.nextToken());
      this.y = Integer.parseInt(st.nextToken());
      this.value = Integer.parseInt(st.nextToken());
    }
    catch (NumberFormatException nfEx) {
      throw new TransmissionException ("Error parsing string: " + inString);
    }
  }

  // Flatten the fields of this object into a String
  public String flatten () {
    return TIC_TAC_TOE + " " + username + " " + tableNum + " " +
           x + " " + y + " " + value;
  }

  // get x
  public int getX () { return x; }

  // get y
  public int getY () { return y; }

  // get value
  public int getValue () { return value; }
}

  // (New import - don't copy line)

  import org.jogre.tictactoe.comm.CommTicTacToeMove;

  // (New method - don't copy line)

  // Update the model
  public void move (int x, int y, int value) {
    // update model and change player turn
    model.setData (x, y, value);

    // next player turn.
    nextPlayer ();

    // send move to other user
    CommTicTacToeMove move = new CommTicTacToeMove
      (conn.getUsername(), tableNum, x, y, value);
    conn.send(move);
  }

  // (New import - don't copy line)

  import org.jogre.tictactoe.comm.CommTicTacToeMove;

  // (Update method - don't copy line)

  // This method reads a message going to the server and does something with it
  public void parse (String messageType, String inString) throws TransmissionException {
    if (messageType.equals (CommTicTacToeMove.TIC_TAC_TOE)) {
      // Create communication object and send other table
      CommTicTacToeMove move = new CommTicTacToeMove (inString);
      transmitToTable (move.getUsername(), move.getTableNum(), move);
    }
    else
      super.parse (messageType, inString);  // Super classes deals with most messages
  }

package org.jogre.tictactoe.client;

import org.jogre.client.IClient;
import org.jogre.tictactoe.comm.CommTicTacToeMove;

// Interface which sits between the ClientConnectionThread a frame.
public interface ITicTacToeClient extends IClient {

  public void ticTacToeMove (CommTicTacToeMove move);
}

  // (New import - don't copy line)

  import org.jogre.tictactoe.comm.CommTicTacToeMove;
  import org.jogre.common.TransmissionException;

  // (Update method - don't copy line)

  // This method reads a message going to the server and does something with it.
  public void parse (String messageType, String inString)  {
    try {
      if (messageType.equals (CommTicTacToeMove.TIC_TAC_TOE)) {
        // Create communication object and send other table
        CommTicTacToeMove move = new CommTicTacToeMove (inString);
        clientInterface.ticTacToeMove (move);
      }
      else
        super.parse (messageType, inString);  // Super classes deals with most messages.
    }
    catch (TransmissionException transEx) {
      transEx.printStackTrace();
    }
  }

  // (New import - don't copy line)

  import org.jogre.tictactoe.comm.CommTicTacToeMove;

  // (New method - don't copy line)

  // Tic tac toe move
  public void ticTacToeMove (CommTicTacToeMove move) {
    // retreive correct table and send message to it
    int table = move.getTableNum();
    TicTacToeTableFrame frame = (TicTacToeTableFrame)getTableFrame (table);
    frame.ticTacToeMove (move);     // delegate to the correct table
  }

  // (New import - don't copy line)

  import org.jogre.tictactoe.comm.CommTicTacToeMove;

  // (New method - don't copy line)

  // Tic tac toe move
  public void ticTacToeMove (CommTicTacToeMove move) {
    model.setData (move.getX(), move.getY(), move.getValue());
  }

  // (2 New methods - don't copy line)

  // return true if the game is won by this player
  public boolean isGameWon (int player) {
    // check y axis
    for (int x = 0; x < 3; x++) {
      int count = 0;
      for (int y = 0; y < 3; y++) {
        if (data[x][y] == player)
          count++;
      }
      if (count == 3) return true;
    }
    // check x axis
    for (int y = 0; y < 3; y++) {
      int count = 0;
      for (int x = 0; x < 3; x++) {
        if (data[x][y] == player)
          count++;
      }
      if (count == 3) return true;
    }
    // check diagonals
    if (data[0][0] == player && data [1][1] == player && data [2][2] == player)
      return true;
    if (data[0][2] == player && data [1][1] == player && data [2][0] == player)
      return true;
    return false;
  }

  // return true if all 9 spaces are taken
  public boolean isNoCellsLeft () {
    int count = 0;
    // check each cell
    for (int x = 0; x < 3; x++) {
      for (int y = 0; y < 3; y++) {
        if (data[x][y] != BLANK)
          count++;
      }
    }
    return (count == 9);    // if all 9 spaces filled return true
  }

  // (New import - don't copy line)

  import org.jogre.comm.CommGameOver;

  // (Update method - don't copy line)

  // Check to see if the game is over or not.
  private void checkGameOver () {
    // Status is either -1, DRAW or WIN
    int status = -1;
    if (model.isGameWon (getCurrentPlayerSeatNum()))
      status = CommGameOver.WIN;
    else if (model.isNoCellsLeft ())
      status = CommGameOver.DRAW;

    // Create game over object if a win or draw
    if (status != -1 && conn != null) {
      CommGameOver gameOver = new CommGameOver
        (conn.getUsername(), status, tableNum, 0);
      conn.send (gameOver);
    }
  }