opdshe

README.md

@@ -1,2 +1,32 @@
 # java-chess
 체스 게임 저장소
+
+### 구현해야 할 기능 구현 목록
+[입력]
+- 사용자로부터 커맨드 입력 받기
+  - 시작 : start
+  - 종료 : end
+  - 이동 : move sourcePosition targetPosition
+
+- 게임이 끝나면 바로 종료할 지 점수 볼 지 입력
+  - 종료 : end
+  - 점수 및 승자 보기 : status
+
+[게임 과정]
+- a2와 같은 형태의 위치값을 좌표평면 위치로 변환하는 기능
+- 체스판 초기화
+- 각 말들의 이동 로직 구현
+- 게임 종료 기능 
+  - King이 잡히면 종료
+- 점수 계산 기능 
+  - queen : 9점
+  - rook : 5점
+  - bishop : 3점
+  - knight : 2.5점
+  - pawn
+    - 세로 줄에 같은 색 폰이 있으면 0.5
+    - 없으면 1
+
+[출력]
+- 체스판 출력 기능
+- 점수 및 승자 출력 기능

src/main/java/chess/controller/Application.java

@@ -0,0 +1,7 @@
+package chess.controller;
+
+public class Application {
+    public static void main(String[] args) {
+        ChessGameController.play();
+    }
+}

src/main/java/chess/controller/ChessGameController.java

@@ -0,0 +1,24 @@
+package chess.controller;
+
+import chess.domain.command.Command;
+import chess.domain.command.CommandMapper;
+import chess.view.InputView;
+import chess.view.OutputView;
+
+public class ChessGameController {
+    public static void play() {
+        OutputView.printGreetingMessage();
+        getCommand();
+    }
+
+    private static Command getCommand() {
+        Command command = null;
+        try {
+            command = CommandMapper.find(InputView.getCommand());
+        } catch (Exception e) {
+            OutputView.printMessageAndNewLine(e.getMessage());
+            getCommand();
+        }
+        return command;
+    }
+}

src/main/java/chess/domain/ChessBoard.java

@@ -0,0 +1,14 @@
+package chess.domain;
+
+import chess.domain.player.Player;
+import chess.domain.player.Team;
+
+public class ChessBoard {
+    private Player white;
+    private Player black;
+
+    public ChessBoard() {
+        white = new Player(Team.WHITE);
+        black = new Player(Team.WHITE);
+    }
+}

src/main/java/chess/domain/command/Command.java

@@ -0,0 +1,5 @@
+package chess.domain.command;
+
+public interface Command {
+    void execute();
+}

src/main/java/chess/domain/command/CommandMapper.java

@@ -0,0 +1,28 @@
+package chess.domain.command;
+
+import chess.validators.CommandValidator;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+
+public class CommandMapper {
+    private static final Map<Predicate<String>, Supplier<Command>> mapper = new HashMap<>();
+
+    static {
+        mapper.put(StartCommand::isStart, StartCommand::new);
+        mapper.put(EndCommand::isEnd, EndCommand::new);
+        mapper.put(StatusCommand::isStatus, StatusCommand::new);
+    }
+
+    public static Command find(String rawCommand) {
+        CommandValidator.validateCommand(rawCommand);
+        for (Map.Entry<Predicate<String>, Supplier<Command>> entry : mapper.entrySet()) {
+            if (entry.getKey().test(rawCommand)) {
+                return entry.getValue().get();
+            }
+        }
+        return new MoveCommand(rawCommand);
+    }
+}

src/main/java/chess/domain/command/EndCommand.java

@@ -0,0 +1,13 @@
+package chess.domain.command;
+
+public class EndCommand implements Command {
+    private static final String COMMAND = "end";
+
+    public static boolean isEnd(String operation) {
+        return COMMAND.equals(operation.toLowerCase());
+    }
+
+    @Override
+    public void execute() {
+    }
+}

src/main/java/chess/domain/command/MoveCommand.java

@@ -0,0 +1,22 @@
+package chess.domain.command;
+
+import utils.CommandSplitter;
+
+public class MoveCommand implements Command {
+    private static final String COMMAND = "move";
+    private static final int SOURCE_INDEX = 0;
+    private static final int DESTINATION_INDEX = 1;
+
+    private String source;
+    private String dest;
+
+    public MoveCommand(String rawCommand) {
+        String[] splitCommand = CommandSplitter.getSourceAndDest(rawCommand);
+        source = splitCommand[SOURCE_INDEX];
+        dest = splitCommand[DESTINATION_INDEX];
+    }
+
+    @Override
+    public void execute() {
+    }
+}

src/main/java/chess/domain/command/StartCommand.java

@@ -0,0 +1,16 @@
+package chess.domain.command;
+
+public class StartCommand implements Command {
+    private static final String COMMAND = "start";
+
+    public StartCommand() {
+    }
+
+    public static boolean isStart(String operation) {
+        return COMMAND.equals(operation.toLowerCase());
+    }
+
+    @Override
+    public void execute() {
+    }
+}

src/main/java/chess/domain/command/StatusCommand.java

@@ -0,0 +1,13 @@
+package chess.domain.command;
+
+public class StatusCommand implements Command {
+    private static final String COMMAND = "status";
+
+    public static boolean isStatus(String operation) {
+        return COMMAND.equals(operation.toLowerCase());
+    }
+
+    @Override
+    public void execute() {
+    }
+}

src/main/java/chess/domain/piece/Bishop.java

@@ -0,0 +1,9 @@
+package chess.domain.piece;
+
+public class Bishop extends Piece {
+    private static final char representation = 'b';
+
+    public Bishop(Location location) {
+        super(representation, location);
+    }
+}

src/main/java/chess/domain/piece/King.java

@@ -0,0 +1,9 @@
+package chess.domain.piece;
+
+public class King extends Piece {
+    private static final char representation = 'k';
+
+    public King(Location location) {
+        super(representation, location);
+    }
+}

src/main/java/chess/domain/piece/Knight.java

@@ -0,0 +1,9 @@
+package chess.domain.piece;
+
+public class Knight extends Piece {
+    private static final char representation = 'n';
+
+    public Knight(Location location) {
+        super(representation, location);
+    }
+}

src/main/java/chess/domain/piece/Location.java

@@ -0,0 +1,27 @@
+package chess.domain.piece;
+
+import java.util.Objects;
+
+public class Location {
+    private int y;
+    private int x;
+
+    public Location(int y, int x) {
+        this.y = y;
+        this.x = x;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Location location = (Location) o;
+        return y == location.y &&
+                x == location.x;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(y, x);
+    }
+}

src/main/java/chess/domain/piece/Pawn.java

@@ -0,0 +1,9 @@
+package chess.domain.piece;
+
+public class Pawn extends Piece {
+    private static final char representation = 'p';
+
+    public Pawn(Location location) {
+        super(representation, location);
+    }
+}

src/main/java/chess/domain/piece/Piece.java

@@ -0,0 +1,11 @@
+package chess.domain.piece;
+
+public class Piece {
+    private char representation;
+    private Location location;
+
+    public Piece(char representation, Location location) {
+        this.representation = representation;
+        this.location = location;
+    }
+}

src/main/java/chess/domain/piece/Pieces.java

@@ -0,0 +1,11 @@
+package chess.domain.piece;
+
+import java.util.List;
+
+public class Pieces {
+    private List<Piece> pieces;
+
+    public Pieces(List<Piece> pieces) {
+        this.pieces = pieces;
+    }
+}

src/main/java/chess/domain/piece/PiecesCreator.java

@@ -0,0 +1,62 @@
+package chess.domain.piece;
+
+import chess.domain.player.Team;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class PiecesCreator {
+    private static final int WHITE_PAWN_ROW = 6;
+    private static final int BLACK_PAWN_ROW = 1;
+    private static final int WHITE_NOBLE_ROW = 7;
+    private static final int BLACK_NOBLE_ROW = 0;
+    private static final int MAX_POSITION_OF_CHESS_BOARD = 8;
+
+    private PiecesCreator() {
+    }
+
+
+    public static Pieces createPieces(Team team) {
+        List<Piece> pieces = new ArrayList<>();
+        addPawns(pieces, team);
+        addNobles(pieces, team);
+        return new Pieces(pieces);
+    }
+
+    private static void addNobles(List<Piece> pieces, Team team) {
+        int nobleRow = getNobleRow(team);
+        pieces.add(new Rook(new Location(nobleRow, 0)));
+        pieces.add(new Knight(new Location(nobleRow, 1)));
+        pieces.add(new Bishop(new Location(nobleRow, 2)));
+        pieces.add(new Queen(new Location(nobleRow, 3)));
+        pieces.add(new King(new Location(nobleRow, 4)));
+        pieces.add(new Bishop(new Location(nobleRow, 5)));
+        pieces.add(new Knight(new Location(nobleRow, 6)));
+        pieces.add(new Rook(new Location(nobleRow, 7)));
+    }
+
+    private static void addPawns(List<Piece> pieces, Team team) {
+        int pawnRow = getPawnRow(team);
+        for (int column = 0; column < MAX_POSITION_OF_CHESS_BOARD; column++) {
+            pieces.add(new Pawn(new Location(pawnRow, column)));
+        }
+    }
+
+    private static int getNobleRow(Team team) {
+        if (isWhite(team)) {
+            return WHITE_NOBLE_ROW;
+        }
+        return BLACK_NOBLE_ROW;
+    }
+
+    private static int getPawnRow(Team team) {
+        if (isWhite(team)) {
+            return WHITE_PAWN_ROW;
+        }
+        return BLACK_PAWN_ROW;
+    }
+
+    private static boolean isWhite(Team team) {
+        return team == Team.WHITE;
+    }
+}

src/main/java/chess/domain/piece/Queen.java

@@ -0,0 +1,9 @@
+package chess.domain.piece;
+
+public class Queen extends Piece {
+    private static final char representation = 'q';
+
+    public Queen(Location location) {
+        super(representation, location);
+    }
+}

src/main/java/chess/domain/piece/Rook.java

@@ -0,0 +1,9 @@
+package chess.domain.piece;
+
+public class Rook extends Piece {
+    private static final char representation = 'r';
+
+    public Rook(Location location) {
+        super(representation, location);
+    }
+}

src/main/java/chess/domain/player/Player.java

@@ -0,0 +1,14 @@
+package chess.domain.player;
+
+import chess.domain.piece.Pieces;
+import chess.domain.piece.PiecesCreator;
+
+public class Player {
+    private Team team;
+    private Pieces pieces;
+
+    public Player(Team team) {
+        this.team = team;
+        this.pieces = PiecesCreator.createPieces(team);
+    }
+}

src/main/java/chess/domain/player/Team.java

@@ -0,0 +1,5 @@
+package chess.domain.player;
+
+public enum Team {
+    WHITE, BLACK
+}

src/main/java/chess/exceptions/NotSupportedCommandException.java

@@ -0,0 +1,9 @@
+package chess.exceptions;
+
+public class NotSupportedCommandException extends RuntimeException {
+    private static final String message = "지원하지 않는 커맨드입니다. ";
+
+    public NotSupportedCommandException() {
+        super(message);
+    }
+}