Crabs/3DChess
2
1
Fork 0
Code Issues 3 Pull Requests Actions Packages Projects Releases 2 Wiki Activity

change project structure

Browse Source
This commit is contained in:
Simon Pribylski
2025-04-05 10:18:02 +02:00
parent a0af8caf57
commit 9af06e36f8
25 changed files with 57 additions and 56 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
app/src/main/java/chess/controller/commands/CastlingCommand.java Normal file
View File

@@ -0,0 +1,24 @@
package chess.controller.commands;
import chess.controller.OutputSystem;
import chess.controller.PlayerCommand;
import chess.model.Game;
public class CastlingCommand extends PlayerCommand {
@Override
public CommandResult execute(Game game, OutputSystem outputSystem) {
// we must promote the pending pawn before
if (game.pawnShouldBePromoted())
return CommandResult.NotAllowed;
return CommandResult.NotAllowed;
}
@Override
public void undo(Game game, OutputSystem outputSystem) {
// TODO Auto-generated method stub
throw new UnsupportedOperationException("Unimplemented method 'undo'");
}
}

41
app/src/main/java/chess/controller/commands/GetAllowedMovesCommand.java Normal file
View File

@@ -0,0 +1,41 @@
package chess.controller.commands;
import java.util.ArrayList;
import java.util.List;
import chess.controller.Command;
import chess.controller.OutputSystem;
import chess.model.ChessBoard;
import chess.model.Coordinate;
import chess.model.Game;
import chess.model.Piece;
public class GetAllowedMovesCommand extends Command {
private final Coordinate start;
private List<Coordinate> destinations;
public GetAllowedMovesCommand(Coordinate start) {
this.start = start;
this.destinations = new ArrayList<>();
}
@Override
public CommandResult execute(Game game, OutputSystem outputSystem) {
final ChessBoard board = game.getBoard();
Piece piece = board.pieceAt(start);
if (piece == null)
return CommandResult.NotAllowed;
if (piece.getColor() != game.getPlayerTurn())
return CommandResult.NotAllowed;
this.destinations = board.getAllowedMoves(start);
return CommandResult.NotMoved;
}
public List<Coordinate> getDestinations() {
return destinations;
}
}

33
app/src/main/java/chess/controller/commands/GetPieceAtCommand.java Normal file
View File

@@ -0,0 +1,33 @@
package chess.controller.commands;
import chess.controller.Command;
import chess.controller.OutputSystem;
import chess.model.Coordinate;
import chess.model.Game;
import chess.model.Piece;
public class GetPieceAtCommand extends Command{
private final Coordinate pieceCoords;
private Piece piece;
public GetPieceAtCommand(Coordinate pieceCoords) {
this.pieceCoords = pieceCoords;
this.piece = null;
}
@Override
public CommandResult execute(Game game, OutputSystem outputSystem) {
if (!pieceCoords.isValid())
return CommandResult.NotAllowed;
this.piece = game.getBoard().pieceAt(pieceCoords);
return CommandResult.NotMoved;
}
public Piece getPiece() {
return piece;
}
}

24
app/src/main/java/chess/controller/commands/GrandCastlingCommand.java Normal file
View File

@@ -0,0 +1,24 @@
package chess.controller.commands;
import chess.controller.OutputSystem;
import chess.controller.PlayerCommand;
import chess.model.Game;
public class GrandCastlingCommand extends PlayerCommand {
@Override
public CommandResult execute(Game game, OutputSystem outputSystem) {
// we must promote the pending pawn before
if (game.pawnShouldBePromoted())
return CommandResult.NotAllowed;
return CommandResult.NotAllowed;
}
@Override
public void undo(Game game, OutputSystem outputSystem) {
// TODO Auto-generated method stub
throw new UnsupportedOperationException("Unimplemented method 'undo'");
}
}

80
app/src/main/java/chess/controller/commands/MoveCommand.java Normal file
View File

@@ -0,0 +1,80 @@
package chess.controller.commands;
import chess.controller.OutputSystem;
import chess.controller.PlayerCommand;
import chess.model.ChessBoard;
import chess.model.Coordinate;
import chess.model.Game;
import chess.model.Move;
import chess.model.Piece;
import chess.model.visitor.PiecePathChecker;
public class MoveCommand extends PlayerCommand {
private final Move move;
private Piece deadPiece;
public MoveCommand(Move move) {
this.move = move;
this.deadPiece = null;
}
public Move getMove() {
return move;
}
@Override
public CommandResult execute(Game game, OutputSystem outputSystem) {
final ChessBoard board = game.getBoard();
// we must promote the pending pawn before
if (game.pawnShouldBePromoted())
return CommandResult.NotAllowed;
Piece piece = board.pieceAt(move.getStart());
if (piece == null)
return CommandResult.NotAllowed;
if (piece.getColor() != game.getPlayerTurn())
return CommandResult.NotAllowed;
boolean valid = new PiecePathChecker(board, move).isValid();
if (!valid)
return CommandResult.NotAllowed;
this.deadPiece = board.pieceAt(move.getFinish());
board.applyMove(move);
if (board.isKingInCheck(game.getPlayerTurn())) {
board.undoLastMove();
return CommandResult.NotAllowed;
}
if (game.pawnShouldBePromoted())
return CommandResult.ActionNeeded;
return CommandResult.Moved;
}
@Override
public void undo(Game game, OutputSystem outputSystem) {
final ChessBoard board = game.getBoard();
board.undoMove(move, deadPiece);
}
@Override
public void postExec(Game game, OutputSystem outputSystem) {
tryPromote(game, outputSystem);
}
private void tryPromote(Game game, OutputSystem outputSystem) {
Coordinate pawnPos = game.pawnPromotePosition();
if (pawnPos == null)
return;
outputSystem.promotePawn(pawnPos);
}
}

58
app/src/main/java/chess/controller/commands/NewGameCommand.java Normal file
View File

@@ -0,0 +1,58 @@
package chess.controller.commands;
import chess.controller.Command;
import chess.controller.OutputSystem;
import chess.model.ChessBoard;
import chess.model.Color;
import chess.model.Coordinate;
import chess.model.Game;
import chess.model.pieces.Bishop;
import chess.model.pieces.King;
import chess.model.pieces.Knight;
import chess.model.pieces.Pawn;
import chess.model.pieces.Queen;
import chess.model.pieces.Rook;
public class NewGameCommand extends Command {
public CommandResult execute(Game game, OutputSystem outputSystem) {
final ChessBoard board = game.getBoard();
board.clearBoard();
for (int i = 0; i < 8; i++) {
board.pieceComes(new Pawn(Color.Black), new Coordinate(i, 1));
board.pieceComes(new Pawn(Color.White), new Coordinate(i, Coordinate.VALUE_MAX - 2));
}
board.pieceComes(new Rook(Color.Black), new Coordinate(0, 0));
board.pieceComes(new Rook(Color.Black), new Coordinate(Coordinate.VALUE_MAX - 1, 0));
board.pieceComes(new Rook(Color.White), new Coordinate(0, Coordinate.VALUE_MAX - 1));
board.pieceComes(new Rook(Color.White), new Coordinate(Coordinate.VALUE_MAX - 1, Coordinate.VALUE_MAX - 1));
board.pieceComes(new Knight(Color.Black), new Coordinate(1, 0));
board.pieceComes(new Knight(Color.Black), new Coordinate(Coordinate.VALUE_MAX - 2, 0));
board.pieceComes(new Knight(Color.White), new Coordinate(1, Coordinate.VALUE_MAX - 1));
board.pieceComes(new Knight(Color.White), new Coordinate(Coordinate.VALUE_MAX - 2, Coordinate.VALUE_MAX - 1));
board.pieceComes(new Bishop(Color.Black), new Coordinate(2, 0));
board.pieceComes(new Bishop(Color.Black), new Coordinate(Coordinate.VALUE_MAX - 3, 0));
board.pieceComes(new Bishop(Color.White), new Coordinate(2, Coordinate.VALUE_MAX - 1));
board.pieceComes(new Bishop(Color.White), new Coordinate(Coordinate.VALUE_MAX - 3, Coordinate.VALUE_MAX - 1));
board.pieceComes(new Queen(Color.Black), new Coordinate(3, 0));
board.pieceComes(new King(Color.Black), new Coordinate(4, 0));
board.pieceComes(new Queen(Color.White), new Coordinate(3, Coordinate.VALUE_MAX - 1));
board.pieceComes(new King(Color.White), new Coordinate(4, Coordinate.VALUE_MAX - 1));
game.resetPlayerTurn();
outputSystem.gameStarted();
outputSystem.playerTurn(game.getPlayerTurn());
return CommandResult.NotMoved;
}
}

88
app/src/main/java/chess/controller/commands/PromoteCommand.java Normal file
View File

@@ -0,0 +1,88 @@
package chess.controller.commands;
import chess.controller.OutputSystem;
import chess.controller.PlayerCommand;
import chess.model.ChessBoard;
import chess.model.Color;
import chess.model.Coordinate;
import chess.model.Game;
import chess.model.Piece;
import chess.model.pieces.Bishop;
import chess.model.pieces.Knight;
import chess.model.pieces.Pawn;
import chess.model.pieces.Queen;
import chess.model.pieces.Rook;
public class PromoteCommand extends PlayerCommand {
public enum PromoteType {
Queen,
Rook,
Bishop,
Knight
}
private final PromoteType promoteType;
private Coordinate pieceCoords;
public PromoteCommand(PromoteType promoteType) {
this.promoteType = promoteType;
}
@Override
public CommandResult execute(Game game, OutputSystem outputSystem) {
final ChessBoard board = game.getBoard();
this.pieceCoords = game.pawnPromotePosition();
if (this.pieceCoords == null)
return CommandResult.NotAllowed;
Piece pawn = board.pieceAt(this.pieceCoords);
if (pawn == null || !(pawn instanceof Pawn))
return CommandResult.NotAllowed;
int destY = this.pieceCoords.getY();
int enemyLine = pawn.getColor() == Color.White ? 0 : 7;
if (destY != enemyLine)
return CommandResult.NotAllowed;
board.pieceComes(createPiece(this.promoteType, pawn.getColor()), this.pieceCoords);
return CommandResult.Moved;
}
private Piece createPiece(PromoteType promoteType, Color color) {
switch (promoteType) {
case Queen:
return new Queen(color);
case Bishop:
return new Bishop(color);
case Knight:
return new Knight(color);
case Rook:
return new Rook(color);
default:
return null;
}
}
@Override
public void undo(Game game, OutputSystem outputSystem) {
final ChessBoard board = game.getBoard();
Piece promoted = board.pieceAt(this.pieceCoords);
assert promoted != null;
Color player = promoted.getColor();
board.pieceComes(new Pawn(player), this.pieceCoords);
}
}

23
app/src/main/java/chess/controller/commands/SurrenderCommand.java Normal file
View File

@@ -0,0 +1,23 @@
package chess.controller.commands;
import chess.controller.Command;
import chess.controller.OutputSystem;
import chess.model.Color;
import chess.model.Game;
public class SurrenderCommand extends Command {
private final Color player;
public SurrenderCommand(Color player) {
this.player = player;
}
@Override
public CommandResult execute(Game game, OutputSystem outputSystem) {
outputSystem.hasSurrendered(player);
outputSystem.winnerIs(Color.getEnemy(player));
return CommandResult.NotMoved;
}
}

15
app/src/main/java/chess/controller/commands/UndoCommand.java Normal file
View File

@@ -0,0 +1,15 @@
package chess.controller.commands;
import chess.controller.Command;
import chess.controller.OutputSystem;
import chess.model.Game;
public class UndoCommand extends Command{
@Override
public CommandResult execute(Game game, OutputSystem outputSystem) {
//TODO
return CommandResult.Moved;
}
}