[ 사이클1 - 미션 (보드 초기화 + 기물 이동)] 고래 미션 제출합니다.

src/main/java/Application.java

@@ -0,0 +1,14 @@
+import domain.GameManager;
+import java.util.Scanner;
+import view.InputView;
+import view.OutputView;
+
+public class Application {
+    public static void main(String[] args) {
+        GameManager gameManager = new GameManager(
+                new InputView(new Scanner(System.in)),
+                new OutputView()
+        );
+        gameManager.play();
+    }
+}

src/main/java/domain/Destinations.java

@@ -0,0 +1,28 @@
+package domain;
+
+import java.util.List;
+
+public class Destinations {
+    private final List<Position> positions;
+
+    public Destinations(List<Position> positions) {
+        validate(positions);
+        this.positions = List.copyOf(positions);
+    }
+
+    private void validate(List<Position> positions) {
+        if (positions.isEmpty()) {
+            throw new IllegalArgumentException("이동 가능한 목적지가 없습니다.");
+        }
+    }
+
+    public List<Position> getPositions() {
+        return positions;
+    }
+
+    public void validateDestinations(Position target) {
+        if (!positions.contains(target)) {
+            throw new IllegalArgumentException("이동할 수 없는 위치입니다.");
+        }
+    }
+}

src/main/java/domain/Game.java

@@ -0,0 +1,53 @@
+package domain;
+
+import domain.board.Board;
+import domain.piece.Piece;
+import domain.player.Players;
+import java.util.Map;
+
+public class Game {
+    private Board board;
+    private final Players players;
+
+    public Game(Board board, Players players) {
+        this.board = board;
+        this.players = players;
+    }
+
+    public Side getCurrentSide() {
+        return players.getCurrentSide();
+    }
+
+    public Destinations selectSource(Position position) {
+        Piece piece = board.getPiece(position);
+        players.getCurrentPlayer().validateAlly(piece);
+        return findDestinations(position);
+    }
+
+    public void move(Position source, Position target) {
+        Destinations destinations = selectSource(source);
+        destinations.validateDestinations(target);
+        movePiece(source, target);
+        players.switchPlayer();
+    }
+
+    private Destinations findDestinations(Position position) {
+        return board.findDestinations(position);
+    }
+
+    private void movePiece(Position source, Position target) {
+        this.board = board.movePiece(source, target);
+    }
+
+    public Map<Position, Piece> getBoard() {
+        return board.getBoard();
+    }
+
+    public boolean isOver() {
+        return board.isGameOver();
+    }
+
+    public String getWinner() {
+        return players.getWaitingPlayerName();
+    }
+}

src/main/java/domain/GameManager.java

@@ -0,0 +1,89 @@
+package domain;
+
+import domain.board.Board;
+import domain.board.BoardFactory;
+import domain.board.Formation;
+import domain.board.FormationCommand;
+import domain.player.Name;
+import domain.player.Players;
+import java.util.List;
+import java.util.function.Supplier;
+import view.InputParser;
+import view.InputView;
+import view.OutputView;
+
+public class GameManager {
+    private final InputView inputView;
+    private final OutputView outputView;
+
+    public GameManager(InputView inputView, OutputView outputView) {
+        this.inputView = inputView;
+        this.outputView = outputView;
+    }
+
+    public void play() {
+        Game game = initializeGame();
+        outputView.printBoard(game.getBoard());
+        while (!game.isOver()) {
+            playTurn(game);
+        }
+        outputView.printWinner(game.getWinner());
+    }
+
+    private Game initializeGame() {
+        Name choName = getPlayerName(Side.CHO);
+        Players players = retry(() -> {
+            Name hanName = getPlayerName(Side.HAN);
+            return Players.createInitial(choName, hanName);
+        });
+        Board board = BoardFactory.create(getFormation(Side.CHO), getFormation(Side.HAN));
+        return new Game(board, players);
+    }
+
+    private Name getPlayerName(Side side) {
+        return retry(() -> InputParser.parseName(inputView.readPlayerName(side)));
+    }
+
+    private Formation getFormation(Side side) {
+        return retry(() -> Formation.from(FormationCommand.from(inputView.readFormation(side))));
+    }
+
+    private void playTurn(Game game) {
+        Position source = selectPiecePosition(game);
+        retry(() -> {
+            Position target = InputParser.parsePosition(inputView.readTargetPosition());
+            game.move(source, target);
+        });
+        outputView.printBoard(game.getBoard());
+    }
+
+    private Position selectPiecePosition(Game game) {
+        return retry(() -> {
+            Position position = InputParser.parsePosition(inputView.readSourcePosition(game.getCurrentSide()));
+            List<Position> destinations = game.selectSource(position).getPositions();
+            outputView.printDestinations(destinations);
+            return position;
+        });
+    }
+
+    private <T> T retry(Supplier<T> supplier) {
+        while (true) {
+            try {
+                return supplier.get();
+            } catch (IllegalArgumentException e) {
+                outputView.printError(e.getMessage());
+            }
+        }
+    }
+
+    private void retry(Runnable action) {
+        while (true) {
+            try {
+                action.run();
+                return;
+            } catch (IllegalArgumentException e) {
+                outputView.printError(e.getMessage());
+            }
+        }
+    }
+}

src/main/java/domain/Position.java

@@ -0,0 +1,91 @@
+package domain;
+
+import domain.strategy.Direction;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+public class Position {
+    private static final Map<Integer, Position> CACHE = new HashMap<>();
+
+    public static final int MIN = 0;
+    public static final int MAX_X = 8;
+    public static final int MAX_Y = 9;
+
+    private final int x;
+    private final int y;
+
+    static {
+        for (int x = MIN; x <= MAX_X; x++) {
+            for (int y = MIN; y <= MAX_Y; y++) {
+                CACHE.put(generateKey(x, y), new Position(x, y));
+            }
+        }
+    }
+
+    private Position(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    public static Position of(int x, int y) {
+        validateRange(x, y);
+        return CACHE.get(generateKey(x, y));
+    }
+
+    private static void validateRange(int x, int y) {
+        if (!isWithinRange(x, y)) {
+            throw new IllegalArgumentException(String.format("범위를 벗어난 좌표입니다: (%d, %d)", x, y));
+        }
+    }
+
+    public boolean canMove(Direction direction) {
+        return isWithinRange(this.x + direction.getDx(), this.y + direction.getDy());
+    }
+
+    public boolean canMove(List<Direction> sequence) {
+        if (sequence.isEmpty()) {
+            return true;
+        }
+
+        Direction direction = sequence.getFirst();
+        if (!canMove(direction)) {
+            return false;
+        }
+
+        return move(direction).canMove(sequence.subList(1, sequence.size()));
+    }
+
+    public Position move(Direction direction) {
+        return Position.of(this.x + direction.getDx(), this.y + direction.getDy());
+    }
+
+    public static boolean isWithinRange(int x, int y) {
+        return x >= MIN && x <= MAX_X && y >= MIN && y <= MAX_Y;
+    }
+
+    private static int generateKey(int x, int y) {
+        return x * 31 + y;
+    }
+
+    public int getX() { return x; }
+    public int getY() { return y; }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof Position position)) return false;
+        return x == position.x && y == position.y;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(x, y);
+    }
+
+    @Override
+    public String toString() {
+        return String.format("(%d, %d)", x, y);
+    }
+}

src/main/java/domain/Side.java

@@ -0,0 +1,78 @@
+package domain;
+
+import java.util.List;
+
+public enum Side {
+    CHO("초") {
+        @Override
+        public int baseY() {
+            return 0;
+        }
+
+        @Override
+        public int generalY() {
+            return 1;
+        }
+
+        @Override
+        public int cannonY() {
+            return 2;
+        }
+
+        @Override
+        public int soldierY() {
+            return 3;
+        }
+
+        @Override
+        public List<Integer> formationX() {
+            return List.of(1, 2, 6, 7);
+        }
+    },
+    HAN("한") {
+        @Override
+        public int baseY() {
+            return 9;
+        }
+
+        @Override
+        public int generalY() {
+            return 8;
+        }
+
+        @Override
+        public int cannonY() {
+            return 7;
+        }
+
+        @Override
+        public int soldierY() {
+            return 6;
+        }
+
+        @Override
+        public List<Integer> formationX() {
+            return List.of(7, 6, 2, 1);
+        }
+    };
+
+    private final String name;
+
+    Side(String name) {
+        this.name = name;
+    }
+
+    public abstract int baseY();
+    public abstract int generalY();
+    public abstract int cannonY();
+    public abstract int soldierY();
+    public abstract List<Integer> formationX();
+
+    public boolean isAlly(Side other) {
+        return this.equals(other);
+    }
+
+    public String getName() {
+        return name;
+    }
+}