[CC150v5] 8.8 Design Othello Game - Shuatiblog.com

[CC150v5] 8.8 Design Othello Game - Shuatiblog.com

Othello is played as follows: Each Othello piece is white on one side and black on the other. When a piece is surrounded by its opponents on both the left and right sides, or both the top and bottom, it is said to be captured and its color is flipped.
The win is assigned to the person with the most pieces. Implement the object-oriented design for Othello.

Class

1. Game
   1. Two Player objects
   2. a board object
   3. singleton class (unless otherwise specified, this needs to be discussed)
2. Board
   1. Keep the score (black/white count). Of course we can put score in Game Class as well, it seems logically related to the board a bit more.
   2. Array of Piece objects
   3. getScore() method
3. Piece
   1. stores color info
   2. flip() function
4. Player
   1. stores color info
   2. playPiece() method
5. Color Enum
6. Direction Enum

Functions

1. placePiece() by the Player (which triggers the following 2 methods)
2. private flipSection(Position fromWhere, Color c, Direction up/down/left/right) by the board
3. private updateScore() by the board
4. getScore() by the board

Follow up: Do we need separate Board and Game classes?

Strictly speaking, no. The drawback is adding an extra layers. A function that calls Game class is immediately calling Board class.
But keeping the objects separate allows us to have a logical separation between the board (which contains just logic involving placing pieces) and the game (which involves times, game flow, etc.).

Conclusion

This is an easy, and very standard OOD question. Keep the logic clear, design the layers and object hierarchy, and the rest of things will come naturally.
https://github.com/niannianli/Object-orientedDesign/blob/master/src/oodesign/Game8.java
public class Game8 {
private Player[] players;
private Board board;
private final int ROWS = 10;
private final int COLUMNS = 10;

private Game8() {
board = new Board(ROWS, COLUMNS);
players = new Player[2];
players[0] = new Player(Color.Black);
players[1] = new Player(Color.White);

}

public static Game8 getInstance() {
Game8 instance = null;
if (instance == null)
instance = new Game8();
return instance;

}

public Board getBoard() {
return board;
}
}

enum Direction {
left, right, up, down
}

enum Color {
White, Black
}

/*
 * The Board class managers the actual pieces themselves. It does not handle
 * much of the game play, leaving that up to the Game class.
 */

class Board {
private int blackCount = 0;
private int whiteCount = 0;
@SuppressWarnings("unused")
private Piece[][] board;

public Board(int rows, int columns) {
board = new Piece[rows][columns];
}

public void initialize() {
// initialize center black and white pieces
}

// attempt to place a piece of color color at(row, column)
// return true if we were successful
public boolean placeColor(int row, int column, Color color) {
return false;

}

// flips pieces starting at(row, column)
// and proceeding in direction d
@SuppressWarnings("unused")
private int flipSection(int row, int column, Color color, Direction d) {
return column;
}

public int getScoreForColor(Color c) {
if (c == Color.Black)
return blackCount;
else
return whiteCount;
}

// update board with additional newPieces pieces of color
// newColor, decrease score of opposite color
public void updateScore(Color newColor, int newPieces) {
}

}

/*
 * As described earlier, we implement the black and white pieces with the Piece
 * class, which has a simple Color variable representing whetehr it is a black
 * or white piece
 */
class Piece {
private Color color;

public Piece(Color c) {
color = c;
}

public void flip() {
if (color == Color.Black)
color = Color.White;
else
color = Color.Black;
}

public Color getColor() {
return color;
}
}

/*
 * The Player holds only a very limited amount of information. It does not even
 * hold its own score, but it does have a method one can call to get the score.
 * Player.getScore() will call out ot the GameManager to retrieve this value.
 */
class Player {
private Color color;

public Player(Color c) {
color = c;
}

public int getScore() {
return 0;
}

public boolean playPiece(int r, int c) {
return Game8.getInstance().getBoard().placeColor(r, c, color);
}

public Color getColor() {
return color;
}
}
http://www.math.grin.edu/~rebelsky/Courses/152/98S/Assignments/design.04.html
Read full article from [CC150v5] 8.8 Design Othello Game - Shuatiblog.com