[🚀 사이클2 - 미션 (블랙잭 베팅)] 이프 미션 제출합니다.

README.md

@@ -1,26 +1,52 @@
 # java-blackjack
 
+## 게임 모드
+
+### 베팅 모드
+플레이어가 베팅 금액을 걸고 게임 결과에 따라 수익/손실을 계산합니다.
+
+### 논베팅 모드
+베팅 없이 순수 승/무/패만 집계합니다.
+
+---
+
 ## 구현 기능
--  게임에 참가할 사람 이름 입력
--  카드 나눠주기
-  - 카드 52장 생성
-    - 정책: 사용하는 카드에 대해 정의
-        - 카드의 종류: 하트, 다이아, 클로버, 스페이드
-        - 카드의 숫자: A, 2 부터 10, J, Q, K
-  - 카드 뽑기 기능이 필요
-    - 딜러는 자기 자신의 카드도 뽑는다.
-      - 딜러는 공개카드 1장과 비공개 카드 1장씩 받고, 공개 카드 출력
-    - 참여자 별 카드 주기
-  - 참여자들 카드 목록 출력
-- 플레이어 순서대로 카드를 더 받을 것인지 확인
-  - 플레이어가 카드를 받았을 경우 현재 카드 목록 출력
-- 딜러의 Bust 판정
-  - 카드 점수 계산
-    - Ace 1/11 처리 필요
-  - 딜러의 카드 합이 16이하면 카드 1장 받기
-- 딜러 카드와 플레이어 카드 출력하기
-  - 카드 목록 출력
-  - 카드 숫자 합 출력
-- 최종 승패여부 출력
-  - 딜러의 승패 출력
-  - 플레이어별 승패 출력
+
+### 공통
+- 게임에 참가할 사람 이름 입력
+- 카드 52장 생성
+    - 카드 종류: 하트, 다이아, 클로버, 스페이드
+    - 카드 숫자: A, 2~10, J, Q, K
+- 초기 카드 배분
+    - 딜러: 공개 카드 1장, 비공개 카드 1장
+    - 플레이어: 2장
+- 플레이어 순서대로 추가 카드 수령 여부 결정
+    - 카드를 받을 경우 현재 카드 목록 출력
+- 카드 점수 계산
+    - Ace: 1 또는 11로 계산 (버스트 방지 우선)
+- 딜러 추가 카드 수령
+    - 카드 합이 16 이하면 카드 1장 추가
+- 최종 카드 목록 및 점수 출력
+
+### 베팅 모드
+- 플레이어별 베팅 금액 입력
+    - 최소 1원, 최대 100만원
+- 게임 결과별 수익 계산
+    - 승리: 베팅 금액만큼 수익
+    - 패배: 베팅 금액만큼 손실
+    - 무승부: 수익 없음
+    - 블랙잭: 베팅 금액의 1.5배 수익
+- 딜러 및 플레이어별 최종 수익 출력
+
+### 논베팅 모드
+- 딜러 및 플레이어별 최종 승/무/패 출력
+
+---
+
+## 판정 규칙
+- 버스트: 카드 합이 21 초과 시 즉시 패배
+- 블랙잭: 최초 2장으로 합이 21
+    - 플레이어만 블랙잭: 1.5배 수익
+    - 둘 다 블랙잭: 무승부
+    - 딜러만 블랙잭: 플레이어 패배
+- 점수 비교: 버스트/블랙잭 외 경우 점수가 높은 쪽 승리

src/main/java/BlackjackApplication.java

@@ -1,22 +1,14 @@
 import controller.BlackjackController;
-import java.util.List;
-import model.BlackjackService;
-import model.card.Card;
-import model.card.CardFactory;
-import model.card.CardShuffler;
-import model.card.Deck;
+import controller.GameMode;
+import model.BlackjackGame;
 import model.card.SimpleCardShuffler;
 
 public class BlackjackApplication {
 
     public static void main(String[] args) {
-        CardShuffler cardShuffler = new SimpleCardShuffler();
-        List<Card> fullCards = CardFactory.createFullCards();
-        List<Card> shuffledCards = cardShuffler.shuffle(fullCards);
-        Deck deck = new Deck(shuffledCards);
-        BlackjackService blackjackService = new BlackjackService(deck);
-
-        BlackjackController controller = new BlackjackController(blackjackService);
-        controller.run();
+        new BlackjackController<>(
+                BlackjackGame.setup(new SimpleCardShuffler()),
+                GameMode.toBettingMode()
+        ).run();
     }
 }

src/main/java/controller/BlackjackController.java

@@ -1,8 +1,6 @@
 package controller;
 
-import java.util.List;
-import model.BlackjackService;
-import model.judgement.DealerResult;
+import model.BlackjackGame;
 import model.judgement.Judgement;
 import model.judgement.PlayerResult;
 import model.paticipant.Dealer;
@@ -11,79 +9,72 @@
 import view.InputView;
 import view.OutputView;
 
-public class BlackjackController {
+public class BlackjackController<T extends Player> {
 
-    private final BlackjackService blackjackService;
+    private final BlackjackGame blackjackGame;
+    private final GameMode<T> gameMode;
 
-    public BlackjackController(BlackjackService blackjackService) {
-        this.blackjackService = blackjackService;;
+    public BlackjackController(BlackjackGame blackjackGame, GameMode<T> gameMode) {
+        this.blackjackGame = blackjackGame;
+        this.gameMode = gameMode;
     }
 
     public void run() {
         Dealer dealer = new Dealer();
-        Players players = createPlayers();
+        Players<T> players = gameMode.createPlayers();
 
-        drawInitCards(dealer, players);
-        drawMoreCardByPlayer(dealer, players);
-
-        printFinalCards(dealer, players);
-        judgeGame(dealer, players);
+        initialDeal(dealer, players);
+        proceedTurns(dealer, players);
+        finishGame(dealer, players);
     }
 
-    private Players createPlayers() {
-        List<String> names = InputView.readPlayerNames();
-        return Players.from(names);
+    private void initialDeal(Dealer dealer, Players<T> players) {
+        blackjackGame.drawInitCards(dealer, players);
+        OutputView.printCardOpen(dealer, players.players());
     }
 
-    private void drawMoreCardByPlayer(Dealer dealer, Players players) {
-        players.forEach(this::chooseHitOrStand);
+    private void proceedTurns(Dealer dealer, Players<T> players) {
+        players.forEach(this::processPlayerTurn);
+
         while (dealer.canHit()) {
             OutputView.printToOpenDealerNewCard(dealer);
-            blackjackService.drawOneCard(dealer);
+            blackjackGame.drawOneCard(dealer);
         }
     }
 
-    private void drawInitCards(Dealer dealer, Players players) {
-        blackjackService.drawTwoCards(dealer, players);
-        OutputView.printCardOpen(players);
-        OutputView.printCardByDealer(dealer);
-        OutputView.printCardByPlayers(players);
-    }
-
-    private boolean canHitMore(Player player) {
-        return player.canHit() && readContinuation(player).isContinue();
-    }
-
-    private Continuation readContinuation(Player player) {
-        String inputCommand = InputView.readMoreCard(player);
-        return Continuation.from(inputCommand);
-    }
+    private void processPlayerTurn(Player player) {
+        if (player.isBlackjack()) {
+            return;
+        }
 
-    private void chooseHitOrStand(Player player) {
-        boolean printed = false;
-        while (canHitMore(player)) {
-            blackjackService.drawOneCard(player);
+        boolean hasDrawn = hitUntilStand(player);
+        if (!hasDrawn) {
             OutputView.printCardByPlayer(player);
-            printed = true;
         }
+    }
 
-        if (!printed) {
+    private boolean hitUntilStand(Player player) {
+        boolean hasDrawn = false;
+        while (canHitMore(player)) {
+            blackjackGame.drawOneCard(player);
             OutputView.printCardByPlayer(player);
+            hasDrawn = true;
         }
+        return hasDrawn;
     }
 
-    private void printFinalCards(Dealer dealer, Players players) {
-        OutputView.printBlank();
-        OutputView.printCardByPlayerWithScore(dealer);
-        players.forEach(OutputView::printCardByPlayerWithScore);
+    private boolean canHitMore(Player player) {
+        return player.canHit() && readContinuation(player).isContinue();
     }
 
-    private void judgeGame(Dealer dealer, Players players) {
-        PlayerResult playerResult = Judgement.judgeByPlayer(dealer, players);
-        DealerResult dealerResult = Judgement.judgeByDealer(playerResult);
+    private Continuation readContinuation(Player player) {
+        String inputCommand = InputView.readMoreCard(player);
+        return Continuation.from(inputCommand);
+    }
 
-        OutputView.printFinalResultHeader();
-        OutputView.printResultByDealer(dealerResult);
-        OutputView.printResultByPlayers(playerResult);
+    private void finishGame(Dealer dealer, Players<T> players) {
+        OutputView.printFinalCards(dealer, players.players());
+        PlayerResult<T> playerResult = Judgement.judgeByPlayer(dealer, players);
+        gameMode.reportResult(playerResult);
     }
 }

src/main/java/controller/GameMode.java

@@ -0,0 +1,39 @@
+package controller;
+
+import controller.input.BettingPlayerReader;
+import controller.input.NonBettingPlayerReader;
+import controller.input.PlayerReader;
+import controller.result.BettingResultReporter;
+import controller.result.NonBettingResultReporter;
+import controller.result.ResultReporter;
+import model.judgement.PlayerResult;
+import model.paticipant.BettingPlayer;
+import model.paticipant.Player;
+import model.paticipant.Players;
+
+public class GameMode<T extends Player> {
+
+    private final PlayerReader<T> playerReader;
+    private final ResultReporter<T> resultReporter;
+
+    private GameMode(PlayerReader<T> playerReader, ResultReporter<T> resultReporter) {
+        this.playerReader = playerReader;
+        this.resultReporter = resultReporter;
+    }
+
+    public static GameMode<BettingPlayer> toBettingMode() {
+        return new GameMode<>(new BettingPlayerReader(), new BettingResultReporter());
+    }
+
+    public static GameMode<Player> toNonBettingMode() {
+        return new GameMode<>(new NonBettingPlayerReader(), new NonBettingResultReporter());
+    }
+
+    public Players<T> createPlayers() {
+        return playerReader.readPlayers();
+    }
+
+    public void reportResult(PlayerResult<T> playerResult) {
+        resultReporter.report(playerResult);
+    }
+}

src/main/java/controller/input/BettingPlayerReader.java

@@ -0,0 +1,21 @@
+package controller.input;
+
+import java.util.ArrayList;
+import java.util.List;
+import model.paticipant.BettingPlayer;
+import model.paticipant.Players;
+import view.InputView;
+
+public class BettingPlayerReader implements PlayerReader<BettingPlayer> {
+
+    @Override
+    public Players<BettingPlayer> readPlayers() {
+        List<String> names = InputView.readPlayerNames();
+        List<BettingPlayer> players = new ArrayList<>();
+        for (String name : names) {
+            int betAmount = InputView.readBetAmount(name);
+            players.add(new BettingPlayer(name, betAmount));
+        }
+        return new Players<>(players);
+    }
+}

src/main/java/controller/input/NonBettingPlayerReader.java

@@ -0,0 +1,19 @@
+package controller.input;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import model.paticipant.Player;
+import model.paticipant.Players;
+import view.InputView;
+
+public class NonBettingPlayerReader implements PlayerReader<Player> {
+
+    @Override
+    public Players<Player> readPlayers() {
+        List<String> names = InputView.readPlayerNames();
+        List<Player> players = names.stream()
+                .map(Player::new)
+                .collect(Collectors.toList());
+        return new Players<>(players);
+    }
+}

src/main/java/controller/input/PlayerReader.java

@@ -0,0 +1,10 @@
+package controller.input;
+
+import model.paticipant.Player;
+import model.paticipant.Players;
+
+public interface PlayerReader<T extends Player> {
+
+    Players<T> readPlayers();
+
+}

src/main/java/controller/result/BettingResultReporter.java

@@ -0,0 +1,23 @@
+package controller.result;
+
+import java.util.Map;
+import model.judgement.BettingCalculator;
+import model.judgement.PlayerResult;
+import model.judgement.Profit;
+import model.paticipant.BettingPlayer;
+import view.ProfitReportView;
+
+public class BettingResultReporter implements ResultReporter<BettingPlayer> {
+
+    private final BettingCalculator calculator = new BettingCalculator();
+
+    @Override
+    public void report(PlayerResult<BettingPlayer> playerResult) {
+        Map<BettingPlayer, Profit> profits = calculator.calculateProfits(playerResult);
+        Profit dealerProfit = calculator.calculateDealerProfit(profits);
+
+        ProfitReportView.printFinalProfitHeader();
+        ProfitReportView.printProfitByDealer(dealerProfit);
+        ProfitReportView.printProfitByPlayers(profits);
+    }
+}

src/main/java/controller/result/NonBettingResultReporter.java

@@ -0,0 +1,18 @@
+package controller.result;
+
+import model.judgement.DealerResult;
+import model.judgement.PlayerResult;
+import model.paticipant.Player;
+import view.WinLossReportView;
+
+public class NonBettingResultReporter implements ResultReporter<Player> {
+
+    @Override
+    public void report(PlayerResult<Player> playerResult) {
+        DealerResult dealerResult = playerResult.calculateDealerResult();
+
+        WinLossReportView.printFinalResultHeader();
+        WinLossReportView.printResultByDealer(dealerResult);
+        WinLossReportView.printResultByPlayers(playerResult);
+    }
+}

src/main/java/controller/result/ResultReporter.java

@@ -0,0 +1,9 @@
+package controller.result;
+
+import model.judgement.PlayerResult;
+import model.paticipant.Player;
+
+public interface ResultReporter<T extends Player> {
+
+    void report(PlayerResult<T> playerResult);
+}