[2단계 - 블랙잭 베팅] 리비(이근희) 미션 제출합니다.

README.md

@@ -1,7 +1,49 @@
-# java-blackjack
+# ♠️ java-blackjack ♠️
 
-블랙잭 미션 저장소
+- 블랙잭 게임을 변형한 프로그램을 구현한다.
+- 블랙잭 게임은 딜러와 플레이어 중 카드의 합이 21 또는 21에 가장 가까운 숫자를 가지는 쪽이 이기는 게임이다.
+- 카드의 숫자 계산은 카드 숫자를 기본으로 하며, 예외로 Ace는 1 또는 11로 계산할 수 있으며, King, Queen, Jack은 각각 10으로 계산한다.
+- 게임을 시작하면 플레이어는 두 장의 카드를 지급 받으며, 두 장의 카드 숫자를 합쳐 21을 초과하지 않으면서 21에 가깝게 만들면 이긴다.
+- 21을 넘지 않을 경우 원한다면 얼마든지 카드를 계속 뽑을 수 있다.
+- 딜러는 처음에 받은 2장의 합계가 16이하이면 반드시 1장의 카드를 추가로 받아야 하고, 17점 이상이면 추가로 받을 수 없다.
+- 게임을 완료한 후 각 플레이어별로 승패를 출력한다.
 
-## 우아한테크코스 코드리뷰
+# 🛠️ 기능 구현 목록
 
-- [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md)
+- [x] 입력
+    - [x] 게임에 참여할 사람의 이름을 입력 받을 수 있다.
+    - [x] 한 장 더 받을지 여부를 입력 받을 수 있다.
+- [x] 입력 검증
+    - [x] 카드 추가 여부를 올바른 형태 (y/n)으로 입력했는지 검증할 수 있다.
+- [x] 도메인
+    - [x] 이름은 빈 문자열일 수 없다.
+    - [x] 게임 참가자의 핸드에 새로운 카드를 추가할 수 있다.
+    - [x] 이름이 중복되는 플레이어는 존재할 수 없다.
+    - [x] 플레이어가 없는 경우는 게임을 시작할 수 없다.
+    - [x] 게임 참가자는 딜러 제외 3명 이하여야 한다.
+    - [x] 카드합을 계산할 때 Ace 카드는 1 또는 11로 계산한다
+    - [x] 카드합을 계산할 떄 J,Q,K카드는 각각 10으로 계산한다.
+    - [x] 점수를 계산할 때 Ace 카드가 있는 경우 21을 넘지 않으면서 가장 가깝도록 유리하게 계산한다
+    - [x] 카드합 비교를 통해서 플레이어의 승패를 결정할 수 있다.
+    - [x] 카드합 비교를 통해서 딜러의 승패를 계산할 수 있다.
+    - [x] 딜러는 17점 미만이면 카드를 받아야 한다.
+    - [x] 딜러는 17점 이상이면 카드를 그만 받아야 한다.
+    - [x] 핸드에서 에이스가 몇개있는지 파악할 수 있다
+    - [x] 핸드의 합을 계산할 수 있다.
+    - [x] 저지는 핸드에서 21에 가장 가까운 합을 구할 수 있다.
+    - [x] 핸드의 최소합이 21을 초과하면 플레이어는 버스트한다.
+    - [x] 핸드의 최소합이 21 이하면 플레이어는 카드를 뽑을지 여부를 선택할 수 있다.
+    - [x] 핸드에 카드를 추가할 수 있다.
+    - [x] 카드덱에서 카드를 지정한 개수만큼 건네줄 수 있다.
+    - [x] 카드덱에서 카드를 한 장 뽑아서 건네줄 수 있다.
+    - [x] 카드덱에서 보유한 카드 개수보다 많이 뽑으면 예외가 발생한다.
+    - [x] 참여자의 핸드에 초기 카드를 분배할 수 있다.
+    - [x] 플레이어는 10억까지 베팅할 수 있다.
+    - [x] 플레이어는 핸드를 완성시키는 단계에서 버스트 하면 금액을 모두 잃는다.
+    - [x] 처음 두 장의 카드 합이 21이 되는 블랙잭일 경우 베팅 금액의 1.5배를 추가로 얻는다. (소숫점 제거)
+    - [x] 플레이어가 블랙잭이고 딜러도 블랙잭이면 플레이어는 베팅 금액을 그대로 돌려받는다.
+    - [x] 플레이어가 딜러에게 승리하면 베팅 금액만큼을 추가로 얻는다.
+- [x] 출력
+    - [x] 각 참여자의 카드 정보를 출력할 수 있다.
+    - [x] 각 참여자의 카드 합을 출력할 수 있다.
+    - [x] 최종 승패를 출력할 수 있다.

src/main/java/blackjack/Application.java

@@ -0,0 +1,16 @@
+package blackjack;
+
+import blackjack.view.InputView;
+import blackjack.view.MessageResolver;
+import blackjack.view.OutputView;
+
+public class Application {
+
+    public static void main(String[] args) {
+        InputView inputView = new InputView(new InputMapper());
+        OutputView outputView = new OutputView(new MessageResolver());
+
+        BlackJackGame blackJackGame = new BlackJackGame(inputView, outputView);
+        blackJackGame.run();
+    }
+}

src/main/java/blackjack/BlackJackGame.java

@@ -0,0 +1,57 @@
+package blackjack;
+
+import blackjack.domain.bet.PlayerBets;
+import blackjack.domain.card.CardDeck;
+import blackjack.domain.card.Hand;
+import blackjack.domain.player.Dealer;
+import blackjack.domain.player.Player;
+import blackjack.domain.player.PlayerName;
+import blackjack.domain.player.Players;
+import blackjack.domain.result.PlayerProfits;
+import blackjack.view.InputView;
+import blackjack.view.OutputView;
+import java.util.List;
+
+public class BlackJackGame {
+
+    private final InputView inputView;
+    private final OutputView outputView;
+
+    public BlackJackGame(InputView inputView, OutputView outputView) {
+        this.inputView = inputView;
+        this.outputView = outputView;
+    }
+
+    public void run() {
+        CardDeck cardDeck = CardDeck.createShuffledDeck();
+        Players players = initPlayers(cardDeck);
+        PlayerBets playerBets = inputView.readBetInformation(players);
+        Dealer dealer = new Dealer(Hand.createHandFrom(cardDeck));
+        outputView.printParticipantInitialHand(dealer, players);
+
+        completePlayersHand(players, cardDeck);
+        dealer.completeHand(cardDeck);
+        outputView.printCompletedHandsStatus(dealer, players);
+
+        PlayerProfits playerProfits = playerBets.calculateProfitResult(dealer);
+        outputView.printProfitResults(playerProfits);
+    }
+
+    private Players initPlayers(CardDeck cardDeck) {
+        List<PlayerName> playerNames = inputView.readNames();
+        return new Players(playerNames.stream()
+                .map(playerName -> new Player(playerName, Hand.createHandFrom(cardDeck)))
+                .toList());
+    }
+
+    private void completePlayersHand(Players players, CardDeck cardDeck) {
+        players.getPlayers().forEach(player -> completePlayerHand(player, cardDeck));
+    }
+
+    private void completePlayerHand(Player participant, CardDeck cardDeck) {
+        while (participant.canHit() && inputView.readDrawDecision(participant.getName()).isYes()) {
+            participant.appendCard(cardDeck.popCard());
+            outputView.printPlayerHand(participant);
+        }
+    }
+}

src/main/java/blackjack/InputMapper.java

@@ -0,0 +1,22 @@
+package blackjack;
+
+import blackjack.domain.DrawDecision;
+import blackjack.domain.player.PlayerName;
+import java.util.Arrays;
+import java.util.List;
+
+public class InputMapper {
+
+    private static final String DELIMITER = ",";
+
+    public List<PlayerName> mapToPlayerNames(String target) {
+        String[] split = target.split(DELIMITER);
+        return Arrays.stream(split)
+                .map(PlayerName::new)
+                .toList();
+    }
+
+    public DrawDecision mapToDrawDecision(String target) {
+        return DrawDecision.from(target);
+    }
+}

src/main/java/blackjack/domain/DrawDecision.java

@@ -0,0 +1,26 @@
+package blackjack.domain;
+
+import java.util.Arrays;
+
+public enum DrawDecision {
+
+    YES("y"),
+    NO("n");
+
+    private final String code;
+
+    DrawDecision(String code) {
+        this.code = code;
+    }
+
+    public static DrawDecision from(String code) {
+        return Arrays.stream(values())
+                .filter(drawDecision -> drawDecision.code.equals(code))
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException("[ERROR] " + YES.code + "또는 " + NO.code + "로 입력해주세요"));
+    }
+
+    public boolean isYes() {
+        return this == YES;
+    }
+}

src/main/java/blackjack/domain/Score.java

@@ -0,0 +1,47 @@
+package blackjack.domain;
+
+import java.util.Objects;
+
+public class Score {
+
+    private static final int MAX_SCORE = 21;
+
+    private final int value;
+
+    public Score(int value) {
+        this.value = value;
+    }
+
+    public boolean isAbove(Score target) {
+        return this.value > target.value;
+    }
+
+    public boolean isMaxScore() {
+        return value == MAX_SCORE;
+    }
+
+    public boolean isBustScore() {
+        return value > MAX_SCORE;
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        Score score = (Score) o;
+        return value == score.value;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(value);
+    }
+}

src/main/java/blackjack/domain/bet/BetAmout.java

@@ -0,0 +1,24 @@
+package blackjack.domain.bet;
+
+public class BetAmout {
+
+    private static final int MAX = 1_000_000_000;
+    private static final int MIN = 1_000;
+
+    private final int amount;
+
+    public BetAmout(int amount) {
+        validateRange(amount);
+        this.amount = amount;
+    }
+
+    public Profit calculateProfit(double leverage) {
+        return new Profit((int) (amount * leverage));
+    }
+
+    private void validateRange(int amount) {
+        if (amount < MIN || MAX < amount) {
+            throw new IllegalArgumentException("[ERROR] 베팅 금액은 " + MIN + "부터 " + MAX + "이하까지 가능합니다.");
+        }
+    }
+}

src/main/java/blackjack/domain/bet/PlayerBets.java

@@ -0,0 +1,30 @@
+package blackjack.domain.bet;
+
+import blackjack.domain.player.Dealer;
+import blackjack.domain.player.Player;
+import blackjack.domain.result.GameResult;
+import blackjack.domain.result.PlayerProfits;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class PlayerBets {
+
+    private final Map<Player, BetAmout> playerBets;
+
+    public PlayerBets(Map<Player, BetAmout> playerBets) {
+        this.playerBets = playerBets;
+    }
+
+    public PlayerProfits calculateProfitResult(Dealer dealer) {
+        return new PlayerProfits(playerBets.keySet().stream()
+                .collect(Collectors.toMap(
+                        player -> player,
+                        player -> (calculatePlayerProfit(player, dealer)))));
+    }
+
+    private Profit calculatePlayerProfit(Player player, Dealer dealer) {
+        GameResult gameResult = GameResult.of(dealer, player);
+        BetAmout betAmout = playerBets.get(player);
+        return betAmout.calculateProfit(gameResult.getProfitLeverage());
+    }
+}

src/main/java/blackjack/domain/bet/Profit.java

@@ -0,0 +1,41 @@
+package blackjack.domain.bet;
+
+import java.util.Objects;
+
+public class Profit {
+
+    private final int value;
+
+    public Profit(int value) {
+        this.value = value;
+    }
+
+    public Profit add(Profit other) {
+        return new Profit(this.value + other.value);
+    }
+
+    public Profit inverse() {
+        return new Profit(-1 * value);
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        Profit profit = (Profit) o;
+        return value == profit.value;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(value);
+    }
+}

src/main/java/blackjack/domain/card/Card.java

@@ -0,0 +1,43 @@
+package blackjack.domain.card;
+
+import java.util.Objects;
+
+public class Card {
+
+    private final CardShape cardShape;
+    private final CardNumber cardNumber;
+
+    public Card(CardShape cardShape, CardNumber cardNumber) {
+        this.cardShape = cardShape;
+        this.cardNumber = cardNumber;
+    }
+
+    public boolean isAce() {
+        return cardNumber.isAce();
+    }
+
+    public CardNumber getCardNumber() {
+        return cardNumber;
+    }
+
+    public CardShape getCardShape() {
+        return cardShape;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        Card card = (Card) o;
+        return cardShape == card.cardShape && cardNumber == card.cardNumber;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(cardShape, cardNumber);
+    }
+}