From ae6fdf67b7e5623ab5be176660cfc22aba315798 Mon Sep 17 00:00:00 2001
From: Nabil Alsharif <blit32@gmail.com>
Date: Mon, 25 Feb 2013 17:10:32 +0200
Subject: [PATCH] First versio. Wrote it for fun so I didn't use version
 control

---
 .../tictactoe/TicTacToeAIPlayer.java          | 107 ++++++++++
 .../tictactoe/TicTacToeBoard.java             | 182 ++++++++++++++++++
 .../tictactoe/TicTacToeException.java         |   8 +
 .../tictactoe/TicTacToeGame.java              |  85 ++++++++
 .../tictactoe/TicTacToeHumanPlayer.java       |  89 +++++++++
 .../tictactoe/TicTacToePlayer.java            |   6 +
 .../tictactoe/TicTacToePlayerFactory.java     |  27 +++
 .../tictactoe/ui/TicTacToeBoardView.java      | 160 +++++++++++++++
 .../tictactoe/ui/TicTacToeGameView.java       |  19 ++
 .../ui/TicTacToePlayerSelectionView.java      |  87 +++++++++
 10 files changed, 770 insertions(+)
 create mode 100644 src/com/circuitsofimagination/tictactoe/TicTacToeAIPlayer.java
 create mode 100644 src/com/circuitsofimagination/tictactoe/TicTacToeBoard.java
 create mode 100644 src/com/circuitsofimagination/tictactoe/TicTacToeException.java
 create mode 100644 src/com/circuitsofimagination/tictactoe/TicTacToeGame.java
 create mode 100644 src/com/circuitsofimagination/tictactoe/TicTacToeHumanPlayer.java
 create mode 100644 src/com/circuitsofimagination/tictactoe/TicTacToePlayer.java
 create mode 100644 src/com/circuitsofimagination/tictactoe/TicTacToePlayerFactory.java
 create mode 100644 src/com/circuitsofimagination/tictactoe/ui/TicTacToeBoardView.java
 create mode 100644 src/com/circuitsofimagination/tictactoe/ui/TicTacToeGameView.java
 create mode 100644 src/com/circuitsofimagination/tictactoe/ui/TicTacToePlayerSelectionView.java

diff --git a/src/com/circuitsofimagination/tictactoe/TicTacToeAIPlayer.java b/src/com/circuitsofimagination/tictactoe/TicTacToeAIPlayer.java
new file mode 100644
index 0000000..2f440a2
--- /dev/null
+++ b/src/com/circuitsofimagination/tictactoe/TicTacToeAIPlayer.java
@@ -0,0 +1,107 @@
+package com.circuitsofimagination.tictactoe;
+
+import com.circuitsofimagination.tictactoe.TicTacToeBoard.*;
+
+import java.util.*;
+
+public class TicTacToeAIPlayer implements TicTacToePlayer {
+
+	private TicTacToeGame game;
+	private Cell team;
+	
+	@Override
+	public void initialize(Cell team, TicTacToeGame game) {
+		this.game = game;
+		this.team = team;
+	}
+	
+	@Override
+	public Location makeMove() throws TicTacToeException {
+		List<Location> possibleLocations = game.board.emptySlots();
+		
+		float thisScore;
+		float bestScore = -1;
+		Location bestMove = null;
+		TicTacToeBoard currentBoard;
+		/*
+		 * Find the best move based on the minimax algorithm
+		 * http://en.wikipedia.org/wiki/Minimax
+		 * This is the first iteration, where on Max
+		 * We implement the first iteration here
+		 * so we can find the best move
+		 * instead of having min and max 
+		 * return both a score and location
+		 */	
+		for(Location l : possibleLocations) {
+			currentBoard = game.board.copy();
+			currentBoard.makeMove(team, l);
+			thisScore = min(currentBoard);
+			if(thisScore >= bestScore) {
+				bestScore = thisScore;
+				bestMove = l;
+			}
+		}
+		
+		return bestMove;
+	}
+	
+
+		
+	private float min(TicTacToeBoard board)throws TicTacToeException {
+		float minScore = 1;
+
+		Cell winner = board.winner();
+		if(winner != null) {
+			return evaluateWinner(winner);
+		}
+		
+		List<Location> possibleMoves = board.emptySlots();
+		float thisScore;
+		TicTacToeBoard currentBoard;
+		//TODO: We have three copies of almost the same loop
+		// Find a way to combine them
+		// aka: DRY
+		for(Location l : possibleMoves) {
+			currentBoard = board.copy();
+			currentBoard.makeMove(TicTacToeBoard.oppositePlayer(team), l);
+			thisScore = max(currentBoard);
+			if(thisScore <= minScore) {
+				minScore = thisScore;
+			}
+		}
+		return minScore;
+	}
+	
+	private float max(TicTacToeBoard board) throws TicTacToeException {
+		float maxScore = -1;
+		
+		Cell winner = board.winner();
+		if(winner != null) {
+			return evaluateWinner(winner);
+		} 
+		
+		List<Location> possibleMoves = board.emptySlots();
+		float thisScore;
+		TicTacToeBoard currentBoard;
+		for(Location l : possibleMoves) {
+			currentBoard = board.copy();
+			currentBoard.makeMove(team, l);
+			thisScore = min(currentBoard);
+			if(thisScore >= maxScore) {
+				maxScore = thisScore;
+			}
+		}
+		return maxScore;
+	}
+	
+	private float evaluateWinner(Cell winner) {
+		if((winner == null) || (winner == Cell.EMPTY)) {
+			return 0;
+		} else if(winner == team) {
+			return 1;
+		} else {
+			return -1;
+		}
+	}
+
+}
diff --git a/src/com/circuitsofimagination/tictactoe/TicTacToeBoard.java b/src/com/circuitsofimagination/tictactoe/TicTacToeBoard.java
new file mode 100644
index 0000000..048d0e5
--- /dev/null
+++ b/src/com/circuitsofimagination/tictactoe/TicTacToeBoard.java
@@ -0,0 +1,182 @@
+package com.circuitsofimagination.tictactoe;
+
+import java.util.*;
+
+public class TicTacToeBoard {
+	
+	public enum Cell {
+		EMPTY, X, O
+	}
+	
+	public static class Location {
+		public int x;
+		public int y;
+		
+		public Location(int x, int y) {
+			this.x = x;
+			this.y = y;
+		}
+		
+		@Override
+		public String toString() {
+			return "("+x+", "+y+")";
+		}
+	}
+	
+	public static final int WIDTH = 3;
+	public static final int HEIGHT=3;
+	private static final int NUM_CELLS=WIDTH*HEIGHT;
+	
+	private Cell[] board;
+	
+	public TicTacToeBoard() {
+		board = new Cell[NUM_CELLS];
+		for(int i=0; i<NUM_CELLS; i++) {
+			board[i] = Cell.EMPTY;
+		}
+	}
+	
+	/*
+	 * Private constructor used for copying (aka. cloning) boards
+	 */
+	private TicTacToeBoard(Cell[] cells){
+		board = new Cell[NUM_CELLS];
+		for(int i=0; i<NUM_CELLS; i++) {
+			board[i] = cells[i];
+		}
+	}
+	
+	/*
+	 * Helper function to flip the players
+	 */
+	public static Cell oppositePlayer(Cell team) {
+		if(team == Cell.EMPTY){
+			return Cell.EMPTY;
+		} else if(team == Cell.X){
+			return Cell.O;
+		} else {
+			return Cell.X;
+		}
+	}
+	
+	/*
+	 * Helper function for creating location instances
+	 */
+	public static Location newLocation(int x, int y) {
+		return new Location(x, y);
+	}
+
+	/*
+	 * Find the correct index in the board array for a given
+	 * x and y 
+	 */
+	private int indexFor(Location l) {
+		return l.x+(l.y*WIDTH);
+	}
+	
+	/*
+	 * Make a clone of the board. Used by AI
+	 */
+	public TicTacToeBoard copy() {
+		return new TicTacToeBoard(board);
+	}
+	
+	/*
+	 * Apply a move by a team to the board
+	 */
+	public void makeMove(Cell c, Location l) throws TicTacToeException {
+		try {
+			if(cellAt(l) != Cell.EMPTY) {
+				throw new TicTacToeException("Cell is already take");
+			} else {
+				board[indexFor(l)] = c;
+			}
+		}catch(IndexOutOfBoundsException exc){
+			throw new TicTacToeException("Invalid cell");
+		}
+	}
+	
+	/*
+	 * Returns the value of a given cell
+	 */
+	public Cell cellAt(Location l) {
+		return board[indexFor(l)];
+	}
+	
+	/*
+	 * Check if there are any winners
+	 * return values:
+	 * 	X = Player X has won
+	 * 	O = Player O has won
+	 *  EMPTY = Game is a Draw
+	 *  null = Neither player has won yet
+	 * 
+	 */
+	public Cell winner() {
+		//TODO: Get rid of magic numbers
+		int[][] winning_indexes = new int[][]{
+				// Horizontal lines
+				{0, 1, 2},
+				{3, 4, 5},
+				{6, 7, 8},
+				
+				// Vertical lines
+				{0, 3, 6},
+				{1, 4, 7},
+				{2, 5, 8},
+				
+				// Diagonals
+				{0, 4, 8},
+				{2, 4, 6}
+		};
+		
+		// Return the winner if there is one
+		for(int i=0; i<winning_indexes.length; i++){
+			if(board[winning_indexes[i][0]] != Cell.EMPTY
+					&& (board[winning_indexes[i][0]] == board[winning_indexes[i][1]]) 
+					&& (board[winning_indexes[i][1]] == board[winning_indexes[i][2]])){
+				return board[winning_indexes[i][0]];
+			}
+		}
+		
+		// If there is no winner and the board in full than the game is a draw
+		// TODO: We can check if it is impossible for any one to win
+		// But that would be too much work for now
+		if(boardFull()) {
+			return Cell.EMPTY;
+		}
+		
+		// Otherwise there is no winner and the game can go on
+		return null;
+	}
+	
+	/*
+	 * Check to see if the board has been filled
+	 */
+	
+	public boolean boardFull() {
+		for(int i=0; i<NUM_CELLS; i++) {
+			if(board[i] == Cell.EMPTY) {
+				return false;
+			}
+		}
+		return true;
+	}
+	
+	/*
+	 * Return the coordinates for empty slots
+	 */
+	public List<Location> emptySlots() {
+		ArrayList<Location> slots = new ArrayList<Location>();
+		for(int y=0; y<HEIGHT; y++) {
+			for(int x=0; x<WIDTH; x++) {
+				Location l = new Location(x, y);
+				Cell c = cellAt(l);
+				if(c == Cell.EMPTY) {
+					slots.add(l);
+				}
+			}
+		}
+		return slots;
+	}
+}
diff --git a/src/com/circuitsofimagination/tictactoe/TicTacToeException.java b/src/com/circuitsofimagination/tictactoe/TicTacToeException.java
new file mode 100644
index 0000000..9000680
--- /dev/null
+++ b/src/com/circuitsofimagination/tictactoe/TicTacToeException.java
@@ -0,0 +1,8 @@
+package com.circuitsofimagination.tictactoe;
+
+public class TicTacToeException extends Exception {
+	public TicTacToeException(String message) {
+		super(message);
+	}
+
+}
diff --git a/src/com/circuitsofimagination/tictactoe/TicTacToeGame.java b/src/com/circuitsofimagination/tictactoe/TicTacToeGame.java
new file mode 100644
index 0000000..30d66f5
--- /dev/null
+++ b/src/com/circuitsofimagination/tictactoe/TicTacToeGame.java
@@ -0,0 +1,85 @@
+package com.circuitsofimagination.tictactoe;
+
+import javax.swing.JOptionPane;
+
+import com.circuitsofimagination.tictactoe.ui.*;
+import com.circuitsofimagination.tictactoe.TicTacToeBoard.*;
+
+public class TicTacToeGame implements Runnable {
+	public TicTacToeGameView gameView;
+	public TicTacToeBoardView boardView;
+	
+	public TicTacToeBoard board;
+	
+	public TicTacToePlayer xPlayer;
+	public TicTacToePlayer oPlayer;
+	
+	public TicTacToeGame(String xPlayerName, String oPlayerName) {
+		try {
+			this.xPlayer = TicTacToePlayerFactory.createPlayer(xPlayerName);
+			xPlayer.initialize(Cell.X, this);
+			this.oPlayer = TicTacToePlayerFactory.createPlayer(oPlayerName);
+			oPlayer.initialize(Cell.O,  this);
+		} catch (TicTacToeException exc) {
+			//This shouldn't happen since were using a combo box
+		}
+		board = new TicTacToeBoard();
+		boardView = new TicTacToeBoardView(board);
+		gameView = new TicTacToeGameView(boardView);		
+	}
+	
+	@Override
+	public void run() {
+		boolean playing = true;
+		Location move;
+
+		while(playing) {
+			try {
+				move = xPlayer.makeMove();
+				board.makeMove(Cell.X, move);
+				boardView.repaint();
+				if(board.winner() != null) {
+					playing = false;
+					break;
+				}
+				
+				
+				move = oPlayer.makeMove();
+				board.makeMove(Cell.O, move);
+				boardView.repaint();
+				if(board.winner() != null) {
+					playing = false;
+				}
+			} catch(TicTacToeException exc) {
+				JOptionPane.showMessageDialog(gameView, exc.getMessage(), "Error", JOptionPane.ERROR_MESSAGE);
+			}
+		}
+		
+		String message = null;
+		Cell winner  = board.winner();
+		if (winner ==  Cell.X) {
+			message = "X wins!!";
+		} else if(winner ==  Cell.O) {
+			message = "O wins!!";
+		}else {
+			message = "Game is a draw";
+		}
+		
+		JOptionPane.showMessageDialog(gameView, message, "Game Over", JOptionPane.INFORMATION_MESSAGE);
+	}
+	
+	public static void startGame(String xPlayerName, String oPlayerName) {
+		TicTacToeGame theGame = new TicTacToeGame(xPlayerName, oPlayerName);
+		// Run the game in a seperate thread so that blocking calls
+		// by the game (e.g. makeMove) won't block the GUI events
+		Thread gameThread = new Thread(theGame);
+		gameThread.setDaemon(true);
+		gameThread.start();
+	}
+	
+	public static void main(String [] args) {
+		TicTacToePlayerSelectionView selector = new TicTacToePlayerSelectionView(null, "Select Players", true);
+		selector.execute();
+	}
+	
+}
diff --git a/src/com/circuitsofimagination/tictactoe/TicTacToeHumanPlayer.java b/src/com/circuitsofimagination/tictactoe/TicTacToeHumanPlayer.java
new file mode 100644
index 0000000..8c493e0
--- /dev/null
+++ b/src/com/circuitsofimagination/tictactoe/TicTacToeHumanPlayer.java
@@ -0,0 +1,89 @@
+package com.circuitsofimagination.tictactoe;
+
+import java.awt.Point;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+
+import com.circuitsofimagination.tictactoe.TicTacToeBoard.*;
+
+import java.util.*;
+import java.util.concurrent.*;
+
+public class TicTacToeHumanPlayer implements TicTacToePlayer {
+
+	TicTacToeGame game;
+	Cell team;
+	MoveMouseListener moveListener = new MoveMouseListener();
+	LinkedList<Point> clickBuffer;
+	
+	Semaphore bufferLock;
+	Semaphore emptyLock;
+	
+	@Override
+	public void initialize(Cell team, TicTacToeGame game) {
+		this.game = game;
+		this.team = team;
+	}
+
+	@Override
+	public Location makeMove() throws TicTacToeException { 
+		// makeMove is called by the game thread
+		// But the event listener is called from Swing's
+		// event dispatch thread
+		// so we have to do a little cross-thread syncronization
+		clickBuffer = new LinkedList<Point>(); //Clear any previous
+		bufferLock = new Semaphore(1); // The buffer is ready for use
+		emptyLock = new Semaphore(0); // And there are 0 items in the buffer
+		
+		// Add the listener when we start 
+		// waiting for the human to make a move
+		game.boardView.addMouseListener(moveListener);
+		Location move = null;
+		
+		// Keep trying until the user click on a valid location
+		while(move == null) {
+			move = getMove();
+		}
+		
+		// And remove the listener once were found a valid move
+		game.boardView.removeMouseListener(moveListener);
+		return move;
+	}
+	
+	private Location getMove() {
+		Location l = null;
+		try {
+			// It is necessary to acquire the emptyLock
+			// before the bufferLock so we don't end up with a 
+			// deadlock
+			emptyLock.acquire();
+			bufferLock.acquire();
+			Point thePoint = clickBuffer.poll();
+			if(thePoint != null) {
+				l = game.boardView.translatePoint(thePoint);
+			}
+		} catch (InterruptedException exc) {
+			exc.printStackTrace();
+		} finally {
+			bufferLock.release();
+			emptyLock.release();
+		}
+		return l;
+	}
+	
+	private class MoveMouseListener extends MouseAdapter {
+		public void mouseClicked(MouseEvent evt) {
+			Point clickPoint = evt.getPoint();
+			try {
+				bufferLock.acquire();
+				clickBuffer.add(clickPoint);
+				emptyLock.release();
+			} catch (InterruptedException exc) {
+				exc.printStackTrace();
+			} finally {
+				bufferLock.release();
+			}
+		}
+	}
+
+}
diff --git a/src/com/circuitsofimagination/tictactoe/TicTacToePlayer.java b/src/com/circuitsofimagination/tictactoe/TicTacToePlayer.java
new file mode 100644
index 0000000..af0a4ab
--- /dev/null
+++ b/src/com/circuitsofimagination/tictactoe/TicTacToePlayer.java
@@ -0,0 +1,6 @@
+package com.circuitsofimagination.tictactoe;
+
+public interface TicTacToePlayer {
+	public void initialize(TicTacToeBoard.Cell team, TicTacToeGame game);
+	public TicTacToeBoard.Location makeMove() throws TicTacToeException;
+}
diff --git a/src/com/circuitsofimagination/tictactoe/TicTacToePlayerFactory.java b/src/com/circuitsofimagination/tictactoe/TicTacToePlayerFactory.java
new file mode 100644
index 0000000..01254f8
--- /dev/null
+++ b/src/com/circuitsofimagination/tictactoe/TicTacToePlayerFactory.java
@@ -0,0 +1,27 @@
+package com.circuitsofimagination.tictactoe;
+
+public class TicTacToePlayerFactory {
+	public static final String AI_PLAYER_NAME = "Positronic Brain";
+	public static final String HUMAN_PLAYER_NAME = "Human Brain";
+	
+	public static final String[] PLAYER_NAMES = {
+		AI_PLAYER_NAME,
+		HUMAN_PLAYER_NAME
+	};
+	
+	public static TicTacToePlayer createPlayer(String name) throws TicTacToeException {
+		TicTacToePlayer thePlayer = null;
+		switch(name) {
+		case AI_PLAYER_NAME:
+			thePlayer = new TicTacToeAIPlayer();
+			break;
+		case HUMAN_PLAYER_NAME:
+			thePlayer = new TicTacToeHumanPlayer();
+			break;
+		default:
+			throw new TicTacToeException("Invalid player type");
+		}
+		return thePlayer;
+	}
+
+}
diff --git a/src/com/circuitsofimagination/tictactoe/ui/TicTacToeBoardView.java b/src/com/circuitsofimagination/tictactoe/ui/TicTacToeBoardView.java
new file mode 100644
index 0000000..70975bd
--- /dev/null
+++ b/src/com/circuitsofimagination/tictactoe/ui/TicTacToeBoardView.java
@@ -0,0 +1,160 @@
+package com.circuitsofimagination.tictactoe.ui;
+
+import java.awt.BasicStroke;
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.Point;
+import java.awt.RenderingHints;
+import java.awt.geom.Ellipse2D;
+import java.awt.geom.Line2D;
+import java.awt.geom.Rectangle2D;
+
+import javax.swing.JPanel;
+
+import com.circuitsofimagination.tictactoe.*;
+import com.circuitsofimagination.tictactoe.TicTacToeBoard.Cell;
+import com.circuitsofimagination.tictactoe.TicTacToeBoard.Location;
+
+public class TicTacToeBoardView extends JPanel {
+	private TicTacToeBoard theBoard;
+
+	/*
+	 * Variables used for drawing the board
+	 * and translating between locations on the screen
+	 * to cells on the board
+	 */
+	private double padding_height;
+	private double padding_width;
+	
+	private double board_width;
+	private double board_height;
+	
+	private double cell_width;
+	private double cell_height;
+	
+	private double cell_padding_width;
+	private double cell_padding_height;
+	
+	public TicTacToeBoardView(TicTacToeBoard board) {
+		super();
+		theBoard = board;
+		
+		setBackground(Color.white);
+		setDoubleBuffered(true);
+	}
+	
+	@Override
+	public void paint(Graphics g) {
+		super.paint(g);
+		Graphics2D g2 = (Graphics2D) g;
+		
+		RenderingHints rh = new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+		g2.setRenderingHints(rh);
+		
+		Dimension size = getSize();
+		double width = size.getWidth();
+		double height = size.getHeight();
+		
+		g2.setBackground(Color.white);
+		
+		padding_height = height/8;
+		padding_width = width/8;
+		
+		board_width = width - (2*padding_width);
+		board_height = height - (2*padding_height);
+		
+		cell_width = board_width/TicTacToeBoard.WIDTH;
+		cell_height = board_height/TicTacToeBoard.HEIGHT;
+		
+		cell_padding_height = cell_height/8;
+		cell_padding_width = cell_width/8;
+		
+		// Temp variables used for drawing the board
+		int i;
+		Line2D line;
+		
+		// Draw the vertical lines....
+		for(i=1; i<TicTacToeBoard.WIDTH; i++) {
+			double x = padding_width+(i*cell_width);
+			line = new Line2D.Double(x, padding_height, x, height-padding_height);
+			g2.draw(line);
+		}
+		// ... and the horizontal ones
+		for(i=1; i<TicTacToeBoard.HEIGHT; i++) {
+			double y = padding_height+(i*cell_height);
+			line = new Line2D.Double(padding_width, y, width-padding_width, y);
+			g2.draw(line);
+		}
+		
+		for(int x=0; x<TicTacToeBoard.WIDTH; x++) {
+			for(int y=0; y<TicTacToeBoard.HEIGHT; y++) {
+				Location l = new Location(x, y);
+				if(theBoard.cellAt(l) == Cell.X){
+					drawX(g2, l);
+				}
+				if(theBoard.cellAt(l) == Cell.O) {
+					drawO(g2, l);
+				}
+			}
+		}
+	}
+	
+	/*
+	 * Translate a point from a location on the screen to a location on the game board
+	 * Returns null if the point is not on the board
+	 */
+	public Location translatePoint(Point p){
+		double x = p.getX();
+		double y = p.getY();
+		if(x < padding_width
+				|| x > (padding_width + board_width)
+				|| y < padding_height
+				|| y > (padding_height + board_height)
+		) {
+			return null;
+		} 
+		
+		x = x - padding_width;
+		y = y - padding_height;
+		x = Math.floor(x/cell_width);
+		y = Math.floor(y/cell_height);
+		return TicTacToeBoard.newLocation((new Double(x)).intValue(), (new Double(y)).intValue());
+	}
+	
+	/*
+	 * Translate a location to the upper left corder of the cell on the screen it belongs to
+	 */
+	public Point translateLocation(Location l) {
+		double x = padding_width + (cell_width * l.x);
+		double y = padding_height + (cell_height * l.y);
+		return new Point((new Double(x)).intValue(), (new Double(y)).intValue());
+	}
+	
+	private void drawX(Graphics2D g, Location l) {
+		Point where = translateLocation(l);
+		Line2D l1 = new Line2D.Double(
+				where.getX() + cell_padding_width, 
+				where.getY() + cell_padding_height, 
+				cell_width+where.getX() - cell_padding_width, 
+				cell_height+where.getY() - cell_padding_height);
+		Line2D l2 = new Line2D.Double(
+				where.getX() + cell_width - cell_padding_width, 
+				where.getY() + cell_padding_height, 
+				where.getX() + cell_padding_width, 
+				where.getY() + cell_height - cell_padding_height);
+		g.draw(l1);
+		g.draw(l2);
+	}
+	
+	private void drawO(Graphics2D g, Location l) {
+		Point where = translateLocation(l);
+		Ellipse2D circle = new Ellipse2D.Double(
+				where.getX() + cell_padding_width, 
+				where.getY() + cell_padding_height, 
+				cell_width - (2*cell_padding_width), 
+				cell_height - (2*cell_padding_height));
+		g.draw(circle);
+	}
+}
diff --git a/src/com/circuitsofimagination/tictactoe/ui/TicTacToeGameView.java b/src/com/circuitsofimagination/tictactoe/ui/TicTacToeGameView.java
new file mode 100644
index 0000000..15b1e47
--- /dev/null
+++ b/src/com/circuitsofimagination/tictactoe/ui/TicTacToeGameView.java
@@ -0,0 +1,19 @@
+package com.circuitsofimagination.tictactoe.ui;
+
+import javax.swing.JFrame;
+
+public class TicTacToeGameView extends JFrame {
+	private TicTacToeBoardView board;
+	
+	public TicTacToeGameView(TicTacToeBoardView b) {
+		board = b;
+		add(board);
+		setTitle("Tic Tac Toe");
+		setDefaultCloseOperation(EXIT_ON_CLOSE);
+		setSize(300, 280);
+		setLocationRelativeTo(null);
+		setVisible(true); 
+		setResizable(false);
+		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+	}
+}
diff --git a/src/com/circuitsofimagination/tictactoe/ui/TicTacToePlayerSelectionView.java b/src/com/circuitsofimagination/tictactoe/ui/TicTacToePlayerSelectionView.java
new file mode 100644
index 0000000..d1d6009
--- /dev/null
+++ b/src/com/circuitsofimagination/tictactoe/ui/TicTacToePlayerSelectionView.java
@@ -0,0 +1,87 @@
+package com.circuitsofimagination.tictactoe.ui;
+
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+import javax.swing.Box;
+import javax.swing.BoxLayout;
+import javax.swing.JButton;
+import javax.swing.JComboBox;
+import javax.swing.JDialog;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+
+import java.awt.Container;
+import java.awt.Dialog;
+
+import com.circuitsofimagination.tictactoe.*;
+
+public class TicTacToePlayerSelectionView extends JDialog implements ActionListener {
+	
+	private JComboBox<String> xPlayerCombo;
+	private JComboBox<String> oPlayerCombo;
+	private JButton playButton;
+	private JButton quitButton;
+	
+	public TicTacToePlayerSelectionView(Dialog owner, String title, boolean modal) {
+		super(owner, title, modal);
+	}
+
+	public void execute() {
+		addComponents();
+		setVisible(true);
+	}
+	
+	private void addComponents() {
+		
+		Container contentPane = this.getContentPane();
+		xPlayerCombo = new JComboBox<String>(TicTacToePlayerFactory.PLAYER_NAMES);
+		oPlayerCombo = new JComboBox<String>(TicTacToePlayerFactory.PLAYER_NAMES);
+	
+		playButton = new JButton("Play!");
+		playButton.addActionListener(this);
+		
+		quitButton = new JButton("Quit :-(");
+		quitButton.addActionListener(this);
+	
+		contentPane.setLayout(new BoxLayout(contentPane, BoxLayout.Y_AXIS));
+		
+		JPanel xPlayerPane = new JPanel();
+		xPlayerPane.setLayout(new BoxLayout(xPlayerPane, BoxLayout.X_AXIS));
+		xPlayerPane.add(new JLabel("Player X:"));
+		xPlayerPane.add(xPlayerCombo);
+		contentPane.add(xPlayerPane);
+		contentPane.add(Box.createVerticalGlue());
+		
+		JPanel oPlayerPane = new JPanel();
+		oPlayerPane.setLayout(new BoxLayout(oPlayerPane, BoxLayout.X_AXIS));
+		oPlayerPane.add(new JLabel("Player O:"));
+		oPlayerPane.add(oPlayerCombo);
+		contentPane.add(oPlayerPane);
+		contentPane.add(Box.createVerticalGlue());
+		
+		JPanel buttonPane = new JPanel();
+		buttonPane.setLayout(new BoxLayout(buttonPane, BoxLayout.X_AXIS));
+		buttonPane.add(playButton);
+		buttonPane.add(quitButton);
+		contentPane.add(buttonPane);
+		
+		setSize(300, 200);
+	}
+
+	@Override
+	public void actionPerformed(ActionEvent evt) {
+		if(evt.getSource() == playButton) {
+			this.setVisible(false);
+
+			String xPlayerName = (String)xPlayerCombo.getSelectedItem();
+			String oPlayerName = (String)oPlayerCombo.getSelectedItem();
+
+			TicTacToeGame.startGame(xPlayerName, oPlayerName);
+		}
+		
+		if(evt.getSource() == quitButton) {
+			this.setVisible(false);
+		}
+	}
+}