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

README.md

@@ -18,76 +18,70 @@
 - [x] 4
 - [ ] 5 (완벽하게 충족)
 
-### 선택한 점수의 이유를 적어주세요.
-처음으로 TDD를 적용하여 진행해봤습니다. 전체적인 설계 없이 일단 돌아가는 기능을 만들고 테스트를 한다는 개념이 많이 생소했던 것 같습니다.
-그로인해 부분적으로 indent나 문자열 포장이 완벽하게 적용되지 못했던 것 같습니다.
-<!-- 이유 작성 -->
 
 
 ## 어떤 부분에 집중하여 리뷰해야 할까요?
 
 ---
-### 주제1 - TDD 관련
-미션 초기, 전체적인 설계가 머릿속에 완벽히 그려지지 않은 상태에서 TDD를 시작하려니 상당한 막막함을 느꼈습니다. 동작을 기준으로 테스트를 작성하며 상향식으로 접근하려 했으나, 여러 객체나 메서드가 복잡하게 상호작용해야 하는 상황에서는 그 동작의 단위 자체가 모호하게 다가왔습니다.
+현재 구조는 Player → CardBundle → Card처럼 객체가 서로를 참조하고 있는데, 일부 로직에서 이미 Player 객체를 전달받고 있음에도 불구하고 CardBundle에 직접 접근해 점수를 계산하는 코드가 있었습니다.
+이 경우 특정 클래스가 여러 도메인의 내부 구조를 알고 있어야 한다는 점이 걸렸습니다.
+그래서 외부에서 CardBundle에 직접 접근하는 대신, Player에게 점수를 요청하고 Player가 내부적으로 CardBundle에 위임하는 구조로 변경했습니다. 이렇게 하면 외부에서는 Player의 내부 구조를 알 필요가 없어지고, 나중에 카드 관리 방식이나 점수 계산 로직이 바뀌더라도 다른 도메인이나 레이어의 변경을 줄일 수 있지 않을까 생각했습니다.
+구현을 진행하면서 이런 방식이 위임 메서드라는 개념과도 연결된다는 것을 알게 되었습니다.
+사이클1 리뷰에서 지식을 받아가는 취지보다 제 생각이 상대를 설득할 수 있을지에 초점을 맞춰보라는 말씀을 해주셨는데, 이번에는 그 조언을 떠올리며 제 나름의 기준으로 구조를 선택해 보았습니다.
+제가 이런 방향으로 접근한 것이 어느 정도 타당한 방향인지, 또 이런 상황에서 추가로 고려해 볼 만한 부분이 있는지도 의견을 듣고 싶습니다.
+
+판정과 수익 계산 책임 분배에서 겪은 어려움도 있었습니다.
+베팅 기능을 구현하면서 판정 결과와 베팅 금액을 이용해 수익을 계산하는 책임을 어디에 두어야 할지 고민이 많았습니다.
+처음에는 관련 책임을 Bet 도메인에 모으려고 생각했습니다. 하지만 구현을 진행하면서 판정 로직, 플레이어 상태, 베팅 금액 등 여러 도메인이 함께 관여하게 되었고, 어느 객체에 책임을 두는 것이 자연스러운지 판단하기가 쉽지 않았습니다.
+그래서 여러 방향으로 구조를 바꿔 보면서 계속 수정을 진행했던 것 같습니다. 그 과정에서 특정 객체가 너무 많은 정보를 알게 되는 구조가 되기도 했고, 반대로 책임이 지나치게 분산되는 느낌도 있었습니다.
+여러 시도를 거친 끝에 현재 구조를 선택하게 되었지만, 이 선택이 최선인지에 대해서는 아직 확신이 서지는 않습니다.
+아루가 보시기에는 이 문제를 고민하는 과정에서 제가 놓치고 있는 부분이 있는지, 혹은 이런 상황에서 책임의 위치를 판단할 때 어떤 기준으로 접근하시는지 궁금합니다.
 
-처음에는 프로그램의 흐름에 따라 큰 단위에서 작은 단위로 기능을 정의하며 내려왔는데, 이 과정이 다소 추상적이라는 생각이 들었습니다. 현업에서는 설계가 불확실한 상황에서 어떤 지점을 시작점으로 잡고 설계를 구체화해 나가는지, 그리고 객체 간의 협력이 필수적인 상황에서 TDD의 리듬을 어떻게 유지하시는지 궁금합니다.
-
-### 주제2 - 테스트를 위한 코드
-테스트 가독성과 검증을 위해 프로덕션 코드를 어디까지 수정해야 하는지에 대해서도 깊이 고민했습니다. 예를 들어, 카드 덱에서 카드가 제대로 뽑혔는지 확인하기 위해 실제 로직에서는 쓰이지 않는 deck.size()와 같은 메서드를 추가하는 상황이 있었습니다.
-
-이를 해결하기 위해 1) 무식하게 52번의 draw()를 호출하여 예외를 확인하는 방식, 2) 내부 상태를 우회하여 검증하는 방식, 3) 임시로 메서드를 만들고 추후 삭제하는 방식 등을 고려해 보았습니다. 저는 현재 테스트의 명확성을 위해 메서드를 유지하는 쪽을 택했지만, 이것이 적절한 방향이 맞을지 우려되기도 합니다. 테스트 가능성을 높이기 위해 프로덕션 코드를 변경하는 것에 대해 리뷰어님은 어떤 기준을 가지고 계신가요?
-
-### 주제3 - 도메인에 따른 아키텍처
-마지막으로 블랙잭처럼 도메인 로직이 명확하고 규모가 작은 경우, 서비스 레이어의 도입이 반드시 필요한지 의문이 생겼습니다. 현재 구조에서는 컨트롤러와 도메인 모델만으로도 충분히 실행 흐름을 제어할 수 있다고 느꼈고, 단순히 계층 구조를 맞추기 위해 서비스 레이어를 두는 것은 불필요한 위임 코드만 양산한다고 판단했습니다.
-
-하지만 프로젝트가 커질 상황을 대비해야 하는 관점에서는 레이어를 나누는 것이 맞을지도 모른다는 갈등이 있었습니다. 도메인이 작은 프로젝트에서 아키텍처의 복잡도를 결정하는 리뷰어님만의 트레이드 오프 기준이 있다면 배우고 싶습니다.
-### 주제4 - 향후 학습 방향성 및 마인드 셋
-이번 페어 프로그래밍을 진행하며 제 스스로의 부족함을 많이 통감했습니다. 다른 팀들은 디자인 패턴을 적극적으로 도입하고 논의하는데, 저는 그 대화에 온전히 참여하지 못하거나 패턴을 코드에 녹여내는 데 어려움을 겪었습니다. 심지어는 비즈니스 로직에 집중하다 보니 가끔 가장 기본적인 언어 문법조차 헷갈려 당황스러운 순간들도 있었습니다.
-
-객체지향적인 설계는커녕 지식의 파편화로 인해 곳곳에 빈틈이 있다는 느낌을 많이 받았습니다. 리뷰어님이 보시기에 현재 제 수준에서 어떤 부분을 가장 우선순위에 두고 학습해야 할까요? 단순히 패턴을 외우는 것보다, 제가 놓치고 있는 기본기가 무엇인지 리뷰어님의 시선에서 냉철하게 짚어주시고 앞으로의 공부 방향을 제시해 주실 수 있다면 정말 감사하겠습니다.
-## ✅ 게임 기능 TO-DO
-
-### 게임에 참여할 사람의 이름 입력
+---
 
-- [x] 쉼표 기준으로 분리
-- [x] 정상적인 이름 앞뒤의 공백 제거
-- [x] `ㅁㅁ, ,ㅇㅇ` → 빈 문자열은 예외처리
+## 베팅 기능 TO-DO
 
-### 각 플레이어, 딜러에게 카드를 랜덤으로 2장 배분하는 기능
+### 베팅 금액 입력
 
-- [x] 딜러는 2번째 카드는 출력하지 않음
-- [x] 이미 정해진 덱에서 랜덤 분배
+- [x] 각 플레이어의 베팅 금액을 입력받는 기능
+- [x] 베팅 금액 검증 (양수만 허용)
+- [x] `BettingMoney` 값 객체 생성
 
-### 플레이어에게 카드를 더 받을지 묻는 기능
+### 블랙잭 판별
 
-- [x] 이미 뽑힌 카드는 다시 나오지 않게 처리
-- [x] 한 플레이어가 n을 입력하면 해당 플레이어 종료
+- [x] `CardBundle`에 `isBlackjack()` 추가 (카드 2장 && 점수 21)
+- [x] `CardBundle`에 `isBust()` 추가 (점수 > 21)
+- [x] `Participant`에 위임 메서드 추가
 
-### 딜러가 카드를 더 받는지 출력
+### 승패 판정 개선
 
-- [x] 16 이하라 한 장 받을 때마다 문장 출력
-- [x] 여러 장 받을 경우 한 장씩 문장 반복 출력
-- [x] 처음부터 17 이상이면 카드 추가 없이 안내 문장 출력 여부 결정
+- [x] `Outcome`에 `BLACKJACK_WIN` 추가 및 배율(profitRate) 필드 도입
+- [x] `BlackjackRule` 블랙잭 판정 로직 추가
+  - [x] 플레이어 블랙잭 + 딜러 블랙잭 → 무승부
+  - [x] 플레이어 블랙잭 + 딜러 일반 → 블랙잭 승리 (1.5배)
+  - [x] 딜러만 블랙잭 → 플레이어 패배
+  - [x] 딜러 버스트 → 남아있는 플레이어 승리
 
-### 카드 객체 설계
+### 수익 계산
 
-- [x] 전체 카드 덱을 미리 생성
-- [x] deck을 랜덤 추출 기능으로 구현
-- [x] suit, rank를 각각 Enum으로 관리
-- [x] 카드 문양, 표기 점수 관리 방식 결정
+- [x] `BettingMoney`에 `calculateProfit(Outcome)` 구현 (금액 × 배율)
+- [x] 딜러 수익 계산 (플레이어 수익 합산의 부호 반전) — `ProfitResult`
 
-### 카드 점수 합 계산 기능
+### Player에 베팅 연결
 
-- [x] rank 값만 추출하여 합산
-- [x] 총합 계산 로직 구현
+- [x] `Player`에 `BettingMoney` 필드 추가
+- [x] `Players` 생성 방식 변경 (이름 + 금액)
 
-### 결과 출력
+### 입출력 수정
 
-- [x] 딜러가 가진 카드 목록 출력
-- [x] 딜러 카드 점수 합 출력
-- [x] 플레이어가 가진 카드 목록 출력
-- [x] 플레이어 카드 점수 합 출력
+- [x] `InputView`에 베팅 금액 입력 메서드 추가
+- [x] `OutputView` 최종 결과를 금액으로 출력하도록 변경
+- [x] `BlackjackController`에 베팅 입력 단계 및 수익 출력 단계 추가
 
-### 승패 출력
+### 테스트
 
-- [x] 계산된 합에 따라 승패 판별
+- [x] `BettingMoney` 검증 테스트 (양수, 0, 음수)
+- [x] `CardBundle` 블랙잭/버스트 판별 테스트
+- [x] `BlackjackRule` 블랙잭 케이스 판정 테스트 (8개 케이스)
+- [x] 수익 계산 테스트 (블랙잭 승리, 일반 승리, 무승부, 패배)
+- [x] `ProfitResult` 딜러 수익 집계 테스트

src/main/java/controller/BlackjackController.java

@@ -1,11 +1,12 @@
 package controller;
 
-import domain.Dealer;
-import domain.Deck;
-import domain.Player;
-import domain.Players;
-import domain.Referee;
-import domain.Result;
+import domain.participant.Dealer;
+import domain.card.Deck;
+import domain.participant.Player;
+import domain.participant.Players;
+import domain.game.BlackjackRule;
+import domain.game.Outcome;
+import domain.game.ProfitResult;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
@@ -24,28 +25,32 @@ public BlackjackController(InputView inputView, OutputView outputView) {
 
     public void run() {
         List<String> names = inputView.inputPlayers();
-        Players players = new Players(names);
+        Players players = new Players(inputBets(names));
         Dealer dealer = new Dealer("딜러");
         Deck deck = new Deck();
-        dealInitialCards(dealer, players, deck);
-        dealInitialCards(dealer, players, deck);
+        dealInitialTwoCards(dealer, players, deck);
         printInitialState(dealer, players, names);
         playAllPlayerTurns(players, deck);
         playDealerTurn(dealer, deck);
-        printFinalState(dealer, players);
+        printFinalCards(dealer, players);
+        printProfitResult(dealer, players);
     }
 
-    private void playAllPlayerTurns(Players players, Deck deck) {
-        for (Player player : players.getGamePlayers()) {
-            playPlayerTurn(player, deck);
+    private Map<String, Integer> inputBets(List<String> names) {
+        Map<String, Integer> nameToBet = new LinkedHashMap<>();
+        for (String name : names) {
+            nameToBet.put(name, inputView.inputBettingAmount(name));
         }
+        return nameToBet;
     }
 
-    private void dealInitialCards(Dealer dealer, Players players, Deck deck) {
-        for (Player player : players.getGamePlayers()) {
-            player.addCard(deck.draw());
+    private void dealInitialTwoCards(Dealer dealer, Players players, Deck deck) {
+        for (int i = 0; i < 2; i++) {
+            for (Player player : players.getGamePlayers()) {
+                player.addCard(deck.draw());
+            }
+            dealer.addCard(deck.draw());
         }
-        dealer.addCard(deck.draw());
     }
 
     private void printInitialState(Dealer dealer, Players players, List<String> names) {
@@ -54,7 +59,13 @@ private void printInitialState(Dealer dealer, Players players, List<String> name
         for (Player player : players.getGamePlayers()) {
             outputView.printPlayerCards(player);
         }
-        System.out.println();
+        outputView.printNewLine();
+    }
+
+    private void playAllPlayerTurns(Players players, Deck deck) {
+        for (Player player : players.getGamePlayers()) {
+            playPlayerTurn(player, deck);
+        }
     }
 
     private void playPlayerTurn(Player player, Deck deck) {
@@ -71,17 +82,26 @@ private void playDealerTurn(Dealer dealer, Deck deck) {
         }
     }
 
-    private void printFinalState(Dealer dealer, Players players) {
-        System.out.println();
+    private void printFinalCards(Dealer dealer, Players players) {
+        outputView.printNewLine();
         outputView.printFinalCards(dealer);
         for (Player player : players.getGamePlayers()) {
             outputView.printFinalCards(player);
         }
-        Referee referee = new Referee();
-        Map<Player, Result> results = new LinkedHashMap<>();
+    }
+
+    private ProfitResult calculateProfits(Dealer dealer, Players players) {
+        BlackjackRule rule = new BlackjackRule();
+        Map<Player, Integer> playerProfits = new LinkedHashMap<>();
         for (Player player : players.getGamePlayers()) {
-            results.put(player, referee.judge(player.getScore(), dealer.getScore()));
+            Outcome outcome = rule.judge(player, dealer);
+            playerProfits.put(player, player.calculateProfit(outcome));
         }
-        outputView.printFinalResult(dealer, results);
+        return new ProfitResult(playerProfits);
+    }
+
+    private void printProfitResult(Dealer dealer, Players players) {
+        ProfitResult profitResult = calculateProfits(dealer, players);
+        outputView.printProfitResult(dealer.getName(), profitResult);
     }
 }

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

@@ -1,4 +1,4 @@
-package domain;
+package domain.card;
 
 import java.util.Objects;
 

src/main/java/domain/CardBundle.java → src/main/java/domain/card/CardBundle.java

@@ -1,4 +1,4 @@
-package domain;
+package domain.card;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -13,21 +13,32 @@ public CardBundle() {
     }
 
     public int calculateScore() {
-        int score = 0;
-        boolean hasAce = false;
+        int basicScore = calculateBasicScore();
+        boolean hasAce = hasAce();
+
+        return applyAceBonus(basicScore, hasAce);
+    }
 
+    private int calculateBasicScore() {
+        int score = 0;
         for (Card card : cards) {
             score += card.getScore();
+        }
+        return score;
+    }
+
+    private boolean hasAce() {
+        for (Card card : cards) {
             if (card.isAce()) {
-                hasAce = true;
+                return true;
             }
         }
-        return applyAceBonus(score, hasAce);
+        return false;
     }
 
     private int applyAceBonus(int score, boolean hasAce) {
         if (isSoftHand(score, hasAce)) {
-            return score + 10;
+            return score + ACE_BONUS;
         }
         return score;
     }
@@ -40,7 +51,15 @@ public void addCard(Card card) {
         cards.add(card);
     }
 
+    public boolean isBlackjack() {
+        return cards.size() == 2 && calculateScore() == BUST_THRESHOLD;
+    }
+
+    public boolean isBust() {
+        return calculateScore() > BUST_THRESHOLD;
+    }
+
     public List<Card> getCards() {
-        return cards;
+        return List.copyOf(cards);
     }
 }