Page History

Det naturlige er å bruke en to-dimensjonal tabell til å representere brettet og en enum til å representere brikkene (null er tom). En kan evt. bruke en annen type verdi for brikken, så lenge en kan representere tre ulike tilstander tom, sort og hvit, så int, char og Boolean duger (men ikke boolean). Brikken selv trenger ingen innkapsling, men brettet gjør, så det er naturlig å lage en Brett-klasse med et privat brett-felt av typen Piece[][]. Piece er her brikke-typen. En trenger innkapslingsmetoder for å lese og sette en rute, i tillegg til korrekt initialisering til en tabell med dimensjonene 8x8 i konstruktøren.

En annen løsning er definere en egen brikketype, som har en char, enum eller int som felt. Dette støtter endring av fargen, tilsvarende å snu brikken, istedenfor å erstatte den. I praksis går det for det samme.

To løsningsvarianter som ikke er gode, men som heller ikke gir trekk (dersom de fungerer):

• Mange definerte en brikkeklasse som inneholdt posisjonen til brikken, gjerne samtidig som at brettet var definert som char[][]. Posisjonen i brikken ble i praksis ikke brukt.
• Mange brukte String-baserte posisjoner i innkapslingen, istedenfor x,y, antageligvis pga. måten dette ble brukt på i sjakkoppgaven året før. Dette er noe som bør håndteres ifm. brukerinput, ikke i innkapslingen til brettet.

Selv om man ikke får trekk for slikt, så sluker det tid på eksamen, og gjør koden unødvendig komplisert.

public class Board {
	public static final int BOARD_WIDTH = 8;
	public static final int BOARD_HEIGHT = 8;
	
	private Piece[][] board;
	
	public Board() {
		board = new Piece[BOARD_HEIGHT][BOARD_WIDTH];
		board[3][3] = Piece.WHITE;
		board[3][4] = Piece.BLACK;
		board[4][4] = Piece.WHITE;
		board[4][3] = Piece.BLACK;
	}
	
	public boolean isLegalPosition(int x, int y) {
		return x >= 0 && x < BOARD_WIDTH && y >= 0 && y < BOARD_HEIGHT;
	}
	
	public Piece getPiece(int x, int y) {
		return isLegalPosition(x, y) ? board[y][x] : null;
	}
	
	public void setPiece(int x, int y, Piece piece) {
		if (isLegalPosition(x, y)) {
			board[y][x] = piece;
		}
	}
}
public enum Piece {
	BLACK, WHITE;
	// hjelpemetode som returnerer den andre brikkefargen (ift. this)	
	public Piece other() {
		switch (this) {
		case BLACK: return WHITE;
		case WHITE: return BLACK;
		}
		return null;
	}
}

Det spørres kun etter en forklaring, så det er et spørsmål hvor mye kode som behøves. Det skal en del til for at en tekstlig forklaring viser at en behersker alle detaljene, så noe kode er nok nødvendig.

Det er greit om en bruker unntak i get/setPiece, når en har ulovlige koordinater. En bør da bruke IllegalArgumentException, i hvert fall en RuntimeException, altså unchecked exception.

Den kan også være naturlig å legge til noen hjelpemetoder for metoden i punkt b), selv om det ikke er rene innkapslingsmetoder.

public enum Direction {
	NORTH(0, -1), NORTHEAST(1, -1), EAST(1, 0), SOUTHEAST(1, 1), SOUTH(0, 1), SOUTHWEST(-1, 1), WEST(-1, 0), NORTHWEST(-1, -1);
	public final int dx, dy;
	private Direction(int dx, int dy) {
		this.dx = dx;
		this.dy = dy;
	}
}

Her er det vesentlig å definere naturlige parameterlister, f.eks. utnytte Direction-enum’en og brikketypen og kalle eksisterende metoder, der det er nyttig. Følgende hjelpemetode i Board-klassen, for å telle og bytte når det er lov, er nyttig:

public int count(Piece piece, int x, int y, Direction direction, boolean replace) {
	int count = 0;
	x += direction.dx;
	y += direction.dy;
	while (getPiece(x, y) == piece.other()) {
		count++;
		x += direction.dx;
		y += direction.dy;
	}
	if (getPiece(x, y) != piece) {
		count = 0;
	}
	if (count > 0 && replace) {
		x -= direction.dx;
		y -= direction.dy;
		while (getPiece(x, y) == piece.other()) {
			setPiece(x, y, piece);
			x -= direction.dx;
			y -= direction.dy;
		}
	}
	return count;
}

Her kan en vise at en kan bruke Direction-klassen for å lete i en bestemt retning. Dersom metoden ligger utenfor Board-klasse, så må en bruke innkapslingsmetodene. Her har vi gjort det selv om metoden ligger i Board-klassen, såkalt intern innkapsling. Noen har klart å bruke findSequence fra oppgave 1 og det er greit.

public int countTraps(Piece piece, int x, int y, Direction direction) {
	return countAndReplace(piece, x, y, direction, false);
}
public boolean canTrap(Piece piece, int x, int y) {
	int count = 0;
	for (Direction direction: Direction.values()) {
		count += countAndReplace(piece, x, y, direction, false);
	}
	return count > 0;
}
public void place(Piece piece, int x, int y) {
	setPiece(x, y, piece);
	for (Direction direction: Direction.values()) {
		countAndReplace(piece, x, y, direction, true);
	}
}

De tre metodene over er de som etterspørres i oppgaven, og må ha analoge parameter- og returtyper. canTrap summerer antallet som fanges og returnerer true om antallet er > 0. place()-metoden plasserer en brikke på en bestemt posisjon og bytter ut alle som blir fanget. I begge disse får en vist at en kan iterere over alle verdiene i en enum med values()-metoden.

Her er litt av poenget å dele opp problemet i passende metoder og evt. klasser. Det er ikke nødvendig å ha en egen klasse for selve spillet, men det gir ekstra poeng. Denne vil i så fall holde rede på brettet og hvem sin tur det er. Uansett bør en ha metoder for å skrive ut tilstanden, dvs. brettet og hvem sin tur det er, finne ut om spilleren må passe, dvs. ingen posisjoner er lovlige for en gitt spiller, og for å utføre en plassering. I main-metoden brukes så disse metodene.

main-metoden bør gå i løkke og lese input fra brukeren, oversette dette til en posisjon på brettet og utføre plasseringen. Det bør sjekkes for lovlighet, om en må passe og om spillet er ferdig. Spillerne må veksle mellom å ha turen. Det er ikke nødvendig å kopiere input- og output-formatet vist i oppgaven, men brettet og hvem som har turen bør skrives. (I etterkant angrer jeg på at jeg tok med +’ene i utskriften, siden det lurte mange til å ha dem med i brettrepresentasjonen.)

Det er mange detaljer som kan bli feil i en besvarelse, og vi ser mest på struktur og logikk og mindre på kodingsteknikk. Fullstendig utskrift og gode feilmeldinger er ikke viktig. Vi foretrekker kode, men gode forklaringer kan gi nesten full pott.

Her er en mulig Reversi-klasse:  

private Board board;
private Piece turn;
public Reversi() {
	board = new Board();
	turn = Piece.BLACK;
}
private void printState(boolean coordinates) {
	if (coordinates) {
		System.out.println(" abcdefgh");
	}
	for (int y = 0; y < Board.BOARD_HEIGHT; y++) {
		if (coordinates) {
			System.out.print(y + 1);
		}
		for (int x = 0; x < Board.BOARD_WIDTH; x++) {
			Piece piece = board.getPiece(x, y);
			System.out.print(piece == null ? (board.canTrap(turn, x, y) ? '+' : '.') : (piece == Piece.BLACK ? 'x' : (piece == Piece.WHITE ? 'o' : '?')));
		}
		if (coordinates) {
			System.out.print(y + 1);
		}
		System.out.println();
	}
	if (coordinates) {
		System.out.println(" abcdefgh");
	}
	System.out.println("It is " + turn + "'s turn");
}
private void pass() {
	turn = turn.other();
}
private void place(int x, int y) {
	board.place(turn, x, y);
	turn = turn.other();
}
	
public static void main(String[] args) {
	Reversi reversi = new Reversi();
	Scanner scanner = new Scanner(System.in);
	reversi.printState(true);
	while (scanner.hasNextLine()) {
		String line = scanner.nextLine();
		if (line == null || line.length() == 0) {
			break;
		}
		if (line.length() > 1) {
			char first = line.charAt(0), last = line.charAt(line.length() - 1);
			int x = first - 'a', y = last - '1';
			if (! reversi.board.isLegalPosition(x, y)) {
				System.out.println(first + "," + last + " is not a valid board location");
			} else if (reversi.board.getPiece(x, y) != null) {
				System.out.println("There is already a piece at " + x + "," + y);
			} else {
				if (reversi.board.canTrap(reversi.turn, x, y)) {
					reversi.place(x, y);
				} else {
					System.out.println(x + "," + y + " is not a valid place to put a " + reversi.turn + " piece");
				}
			}
		}
		reversi.printState(true);
		if (! reversi.board.canTrap(reversi.turn)) {
			System.out.println(reversi.turn + "must pass");
			reversi.pass();
			if (! reversi.board.canTrap(reversi.turn)) {
				System.out.println(reversi.turn + "must also pass");
				break;
			}
		}
	}
	int whiteCount = reversi.board.count(Piece.WHITE);
	int blackCount = reversi.board.count(Piece.BLACK);
	System.out.println("There are " + whiteCount + " white piece and " + blackCount + " black pieces left, hence ");
	if (whiteCount > blackCount) {
		System.out.println("white wins!");
	} else if (blackCount > whiteCount) {
		System.out.println("black wins!");
	} else {
		System.out.println("a draw");
	}
}