peet/oopuebung
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

added uebung04 task

Browse Source
This commit is contained in:
Johannes Schmelz 2025-05-02 14:01:50 +02:00
parent 38a6313e08
commit 192db94f14
8 changed files with 482 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
uebung04/chess/Board.java Normal file
View File

@ -0,0 +1,54 @@
package chess;
import java.util.ArrayList;
public class Board {
private final Piece[][] field = new Piece[8][8];
private final ArrayList<Piece> pieces = new ArrayList<Piece>();
void add(Piece piece) {
if (piece.getBoard() != this)
throw new IllegalArgumentException("wrong board");
final Piece existing = pieceAt(piece.getRow(), piece.getCol());
if (existing != null)
throw new IllegalArgumentException("already occupied by " +
existing.toString());
field[piece.getRow() - 1][piece.getCol() - 1] = piece;
pieces.add(piece);
}
public void printBoard() {
System.out.println(" 1 2 3 4 5 6 7 8");
System.out.println(" +---+---+---+---+---+---+---+---+");
for (int row = 1; row <= 8; row++) {
System.out.print("" + row + " ");
for (int col = 1; col <= 8; col++) {
final Piece p = pieceAt(row, col);
final char c = p == null ? ' ' : p.charRep();
System.out.print("| " + c + " ");
}
System.out.println("|");
System.out.println(" +---+---+---+---+---+---+---+---+");
}
}
public Piece pieceAt(int row, int col) {
return field[row - 1][col - 1];
}
public void check() {
for (Piece p1 : pieces) {
System.out.println(p1.toString());
for (Piece p2 : pieces)
if (p1 != p2)
if (p1.canCapture(p2))
System.out.println(" can capture " + p2.toString());
else
System.out.println(" cannot capture " + p2.toString());
}
}
public String toString() {
return pieces.toString();
}
}

15
uebung04/chess/Chess.java Normal file
View File

@ -0,0 +1,15 @@
package chess;
public class Chess {
public static void main(String[] args) {
final Board board = new Board();
final Piece p1 = new Queen(Color.black, board, 1, 4);
final Piece p2 = new Queen(Color.white, board, 8, 4);
final Piece p3 = new Knight(Color.white, board, 3, 3);
final Piece p4 = new Knight(Color.black, board, 6, 4);
System.out.println(board);
System.out.println(board.toString());
board.printBoard();
board.check();
}
}

168
uebung04/chess/ChessTest.java Normal file
View File

@ -0,0 +1,168 @@
package chess;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import static org.junit.Assert.assertEquals;
public class ChessTest {
// Das Zeilenende wird auf Windows-Systemen anders codiert als auf Nicht-Windows-Systemen.
// Die folgende Zeile ermittelt die aktuelle Codierung.
// EOL = "End of Line"
private static final String LS = System.lineSeparator();
private static final String HE = " 1 2 3 4 5 6 7 8" + LS;
private static final String LI = " +---+---+---+---+---+---+---+---+" + LS;
private static final String EMP = " | | | | | | | | |" + LS;
private static final String WK1 = " | n | | | | | | | |" + LS;
private static final String WQ3 = " | | | q | | | | | |" + LS;
private static final String CO1 = " | | | n | | N | Q | | |" + LS;
private static final String INIT_BOARD = board(EMP, EMP, EMP, EMP, EMP, EMP, EMP, EMP);
private static final String WK61_BOARD = board(EMP, EMP, EMP, EMP, EMP, WK1, EMP, EMP);
private static final String APP1_BOARD = board(EMP, EMP, EMP, EMP, WQ3, CO1, EMP, EMP);
private static final String CHECK_TEXT1 = "white queen at (4, 2)" + LS +
" cannot capture black queen at (8, 6)" + LS +
" cannot capture white knight at (6, 4)" + LS +
"black queen at (8, 6)" + LS +
" cannot capture white queen at (4, 2)" + LS +
" can capture white knight at (6, 4)" + LS +
"white knight at (6, 4)" + LS +
" cannot capture white queen at (4, 2)" + LS +
" cannot capture black queen at (8, 6)" + LS;
private static final String CHECK_TEXT2 = "white knight at (6, 3)" + LS +
" cannot capture black knight at (6, 5)" + LS +
" cannot capture black queen at (6, 6)" + LS +
" cannot capture white queen at (5, 3)" + LS +
"black knight at (6, 5)" + LS +
" cannot capture white knight at (6, 3)" + LS +
" cannot capture black queen at (6, 6)" + LS +
" can capture white queen at (5, 3)" + LS +
"black queen at (6, 6)" + LS +
" cannot capture white knight at (6, 3)" + LS +
" cannot capture black knight at (6, 5)" + LS +
" cannot capture white queen at (5, 3)" + LS +
"white queen at (5, 3)" + LS +
" cannot capture white knight at (6, 3)" + LS +
" cannot capture black knight at (6, 5)" + LS +
" cannot capture black queen at (6, 6)" + LS;
private static String board(String... s) {
if (s.length != 8)
throw new IllegalArgumentException("Expected 8, but got " + s.length + " arguments");
StringBuilder sb = new StringBuilder();
sb.append(HE).append(LI);
for (int i = 1; i <= 8; i++)
sb.append(i).append(s[i - 1]).append(LI);
return sb.toString();
}
private Board board;
private final ByteArrayOutputStream printed = new ByteArrayOutputStream();
private final PrintStream printStream = new PrintStream(printed, true);
@Before
public void setup() {
board = new Board();
printed.reset();
System.setOut(printStream);
}
@After
public void tearDown() {
printStream.close();
}
@Test
public void testEmpty() {
board.printBoard();
assertEquals(INIT_BOARD, printed.toString());
}
@Test(expected = IllegalArgumentException.class)
public void testInvalidPos1() {
new Knight(Color.white, board, 0, 4);
}
@Test(expected = IllegalArgumentException.class)
public void testInvalidPos2() {
new Queen(Color.white, board, 0, 4);
}
@Test
public void testWhiteknight() {
final Piece knight = new Knight(Color.white, board, 6, 1);
checkPieces(1);
assertEquals(knight, board.pieceAt(6, 1));
board.printBoard();
assertEquals(WK61_BOARD, printed.toString());
}
@Test
public void test3Pieces() {
final Piece queen1 = new Queen(Color.white, board, 4, 2);
final Piece queen2 = new Queen(Color.black, board, 8, 6);
final Piece knight = new Knight(Color.white, board, 6, 4);
Assert.assertFalse(queen1.canCapture(queen2));
Assert.assertFalse(queen1.canCapture(knight));
Assert.assertFalse(queen2.canCapture(queen1));
Assert.assertTrue(queen2.canCapture(knight));
Assert.assertFalse(knight.canCapture(queen1));
Assert.assertFalse(knight.canCapture(queen2));
checkPieces(3);
assertEquals(queen1, board.pieceAt(4, 2));
assertEquals(queen2, board.pieceAt(8, 6));
assertEquals(knight, board.pieceAt(6, 4));
board.check();
assertEquals(CHECK_TEXT1, printed.toString());
}
@Test
public void test4Pieces() {
final Piece knight1 = new Knight(Color.white, board, 6, 3);
final Piece knight2 = new Knight(Color.black, board, 6, 5);
final Piece queen1 = new Queen(Color.black, board, 6, 6);
final Piece queen2 = new Queen(Color.white, board, 5, 3);
checkPieces(4);
assertEquals(knight1, board.pieceAt(6, 3));
assertEquals(knight2, board.pieceAt(6, 5));
assertEquals(queen1, board.pieceAt(6, 6));
assertEquals(queen2, board.pieceAt(5, 3));
board.printBoard();
assertEquals(APP1_BOARD, printed.toString());
Assert.assertFalse(knight1.canCapture(knight2));
Assert.assertFalse(knight1.canCapture(queen1));
Assert.assertFalse(knight1.canCapture(queen2));
Assert.assertFalse(knight2.canCapture(knight1));
Assert.assertFalse(knight2.canCapture(queen1));
Assert.assertTrue(knight2.canCapture(queen2));
Assert.assertFalse(queen1.canCapture(knight1));
Assert.assertFalse(queen1.canCapture(knight2));
Assert.assertFalse(queen1.canCapture(queen2));
Assert.assertFalse(queen2.canCapture(knight1));
Assert.assertFalse(queen2.canCapture(knight2));
Assert.assertFalse(queen2.canCapture(queen1));
printed.reset();
board.check();
assertEquals(CHECK_TEXT2, printed.toString());
}
private void checkPieces(int expectedNumPieces) {
int numPieces = 0;
for (int row = 1; row < 9; row++)
for (int col = 1; col < 9; col++)
if (board.pieceAt(row, col) != null)
numPieces++;
assertEquals(expectedNumPieces, numPieces);
}
@Test
public void testRunWithErrors() {
final Piece rook = new Rook(Color.white, board, 1, 1);
assertEquals(rook, board.pieceAt(1, 1));
}
}

5
uebung04/chess/Color.java Normal file
View File

@ -0,0 +1,5 @@
package chess;
public enum Color {
black, white
}

28
uebung04/chess/Knight.java Normal file
View File

@ -0,0 +1,28 @@
package chess;
import static java.lang.Math.abs;
public class Knight extends Piece {
public Knight(Color color, Board board, int row, int col) {
super(color, board, row, col);
}
@Override
public char charRep() {
return getColor() == Color.white ? 'n' : 'N';
}
@Override
public String toString() {
return "" + getColor() + " knight at (" + getRow() + ", " + getCol() + ")";
}
@Override
public boolean canCapture(Piece other) {
if (getBoard() != other.getBoard() || getColor() == other.getColor())
return false;
final int dr = abs(getRow() - other.getRow());
final int dc = abs(getCol() - other.getCol());
return dr == 2 && dc == 1 || dr == 1 && dc == 2;
}
}

38
uebung04/chess/Piece.java Normal file
View File

@ -0,0 +1,38 @@
package chess;
public abstract class Piece {
private Color color;
private Board board;
private int row;
private int col;
protected Piece(Color color, Board board, int row, int col) {
if (row < 1 || row > 8 || col < 1 || col > 8)
throw new IllegalArgumentException("Invalid pos " + row + "/" + col);
this.color = color;
this.board = board;
this.row = row;
this.col = col;
board.add(this);
}
public Color getColor() {
return color;
}
public Board getBoard() {
return board;
}
public int getRow() {
return row;
}
public int getCol() {
return col;
}
public abstract char charRep();
public abstract boolean canCapture(Piece other);
}

40
uebung04/chess/Queen.java Normal file
View File

@ -0,0 +1,40 @@
package chess;
import static java.lang.Integer.signum;
import static java.lang.Math.abs;
public class Queen extends Piece {
public Queen(Color color, Board board, int row, int col) {
super(color, board, row, col);
}
@Override
public char charRep() {
return getColor() == Color.white ? 'q' : 'Q';
}
@Override
public String toString() {
return "" + getColor() + " queen at (" + getRow() + ", " + getCol() + ")";
}
@Override
public boolean canCapture(Piece other) {
if (getBoard() != other.getBoard() || getColor() == other.getColor())
return false;
if (other.getRow() != getRow() &&
other.getCol() != getCol() &&
abs(other.getRow() - getRow()) != abs(other.getCol() - getCol()))
return false;
final int dr = signum(other.getRow() - getRow());
final int dc = signum(other.getCol() - getCol());
int r = getRow() + dr;
int c = getCol() + dc;
while (r != other.getRow() || c != other.getCol()) {
if (getBoard().pieceAt(r, c) != null) return false;
r += dr;
c += dc;
}
return true;
}
}

134
uebung04/tournament/TournamentTest.java Normal file
View File

@ -0,0 +1,134 @@
package tournament;
import org.junit.Before;
import org.junit.Test;
import java.util.Collection;
import java.util.HashSet;
import java.util.Set;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThrows;
public class TournamentTest {
private static final String BORGHOFF = "Prof. Borghoff";
private static final String HOMMEL = "Prof. Hommel";
private static final String KOCH = "Prof. Koch";
private static final String MINAS = "Prof. Minas";
private static final String BUCHENRIEDER = "Prof. Buchenrieder";
private static final String DREO = "Prof. Dreo";
private static final String ROSE = "Prof. Rose";
private static final String SIEGLE = "Prof. Siegle";
private static final String TEEGE = "Prof. Teege";
private static final Set<String> SET1 = Set.of(BORGHOFF, HOMMEL, KOCH, MINAS, BUCHENRIEDER, DREO, ROSE, SIEGLE, TEEGE);
private static final Set<String> SET2 = Set.of(BORGHOFF, MINAS, SIEGLE, HOMMEL, DREO);
private static final Set<String> SET3 = Set.of(BORGHOFF, MINAS, SIEGLE);
private static final Set<String> SET4 = Set.of(MINAS, SIEGLE);
private static final Set<String> SET5 = Set.of(MINAS);
private Tournament tournament;
private Game r1s1;
private Game r1s2;
private Game r1s3;
private Game r1s4;
private Game r2s1;
private Game r2s2;
private Game r3s1;
private Game r4s1;
@Before
public void setup() {
r1s1 = new SeededGame(HOMMEL, KOCH);
r1s2 = new SeededGame(MINAS, BUCHENRIEDER);
r1s3 = new SeededGame(DREO, ROSE);
r1s4 = new SeededGame(SIEGLE, TEEGE);
r2s1 = new ByeGame(BORGHOFF, r1s1);
r2s2 = new OrdinaryGame(r1s2, r1s3);
r3s1 = new OrdinaryGame(r2s1, r2s2);
r4s1 = new OrdinaryGame(r3s1, r1s4);
tournament = new Tournament("UniBw Sportschießen", r4s1);
}
@Test
public void testBeforeFirstRound() {
assertEquals(SET1, asSet(tournament.getAllPlayers()));
assertEquals(SET1, asSet(tournament.getRemainingPlayers()));
}
@Test
public void testFirstRound() {
r1s1.setWinner(HOMMEL);
r1s2.setWinner(MINAS);
r1s3.setWinner(DREO);
r1s4.setWinner(SIEGLE);
assertEquals(SET1, asSet(tournament.getAllPlayers()));
assertEquals(SET2, asSet(tournament.getRemainingPlayers()));
}
@Test
public void testSecondRound() {
r1s1.setWinner(HOMMEL);
r1s2.setWinner(MINAS);
r1s3.setWinner(DREO);
r1s4.setWinner(SIEGLE);
r2s1.setWinner(BORGHOFF);
r2s2.setWinner(MINAS);
assertEquals(SET1, asSet(tournament.getAllPlayers()));
assertEquals(SET3, asSet(tournament.getRemainingPlayers()));
}
@Test
public void testThirdRound() {
r1s1.setWinner(HOMMEL);
r1s2.setWinner(MINAS);
r1s3.setWinner(DREO);
r1s4.setWinner(SIEGLE);
r2s1.setWinner(BORGHOFF);
r2s2.setWinner(MINAS);
r3s1.setWinner(MINAS);
assertEquals(SET1, asSet(tournament.getAllPlayers()));
assertEquals(SET4, asSet(tournament.getRemainingPlayers()));
}
@Test
public void testCompleteTournament() {
r1s1.setWinner(HOMMEL);
r1s2.setWinner(MINAS);
r1s3.setWinner(DREO);
r1s4.setWinner(SIEGLE);
r2s1.setWinner(BORGHOFF);
r2s2.setWinner(MINAS);
r3s1.setWinner(MINAS);
r4s1.setWinner(MINAS);
assertEquals(SET1, asSet(tournament.getAllPlayers()));
assertEquals(SET5, asSet(tournament.getRemainingPlayers()));
}
@Test
public void testException() {
r1s1.setWinner(HOMMEL);
r1s2.setWinner(MINAS);
r1s3.setWinner(DREO);
r1s4.setWinner(SIEGLE);
r2s1.setWinner(BORGHOFF);
r2s2.setWinner(MINAS);
r3s1.setWinner(MINAS);
assertThrows(IllegalArgumentException.class, () -> r4s1.setWinner(BUCHENRIEDER));
}
@Test(expected = IllegalStateException.class)
public void testException2() {
r4s1.setWinner(MINAS);
}
@Test
public void testException3() {
r1s1.setWinner(HOMMEL);
assertThrows(IllegalStateException.class, () -> r1s1.setWinner(HOMMEL));
}
private static <T> Set<T> asSet(Collection<T> collection) {
return new HashSet<>(collection);
}
}