From 7f286323080ebf92c17a8e228ce2cd2759755270 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EB=A6=AC=EB=B9=84?= Date: Mon, 11 Mar 2024 22:24:50 +0900 Subject: [PATCH 01/91] =?UTF-8?q?[1=EB=8B=A8=EA=B3=84=20-=20=EB=B8=94?= =?UTF-8?q?=EB=9E=99=EC=9E=AD=20=EA=B2=8C=EC=9E=84=20=EC=8B=A4=ED=96=89]?= =?UTF-8?q?=20=EB=A6=AC=EB=B9=84(=EC=9D=B4=EA=B7=BC=ED=9D=AC)=20=EB=AF=B8?= =?UTF-8?q?=EC=85=98=20=EC=A0=9C=EC=B6=9C=ED=95=A9=EB=8B=88=EB=8B=A4.=20(#?= =?UTF-8?q?634)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * docs: 프로젝트 소개글 및 구현 기능 목록 작성 * feat: 카드의 모양 및 점수 이넘 생성 * feat: 소유한 카드 합 계산 구현 * feat: 카드를 추가하는 기능 구현 * feat: Card 동등성 비교 및 해싱 함수 재정의 * feat: CardDeck 카드를 뽑을 수 있는 기능 구현 * test: 특정 카드 추가 테스트 의미 개선 * feat: 카드의 수가 충분하지 않은 경우 pop메서드의 예외처리 구현 * feat: 플레이어 이름 구현 * feat: 플레이어 구현 * test: 테스트 도메인 설명 작성 * test: 테스트 편의 픽스처 구현 * feat: Player 도메인 동등성 비교 기능 구현 * feat: Player의 일급 컬렉션 도메인 Players 구현 * feat: Player 관련 도메인 Getter 프로퍼티 추가 * feat: Player가 가지고 있는 핸드 Getter 프로퍼티 추가 * feat: Card 게터 프로퍼티 추가 * feat: Player가 자신이 가지고 있는 카드의 합계를 반환할 수 있는 기능 추가 * feat: InputView 구현 * feat: 출력 메시지 리졸버 구현 * feat: OutputView 구현 * docs: 기능 구현 목록 정리 및 최신화 * feat: DrawDecision 구현 * feat: 이름만 받아서 빈핸드를 가진 참가자들을 생성하는 정적 팩토리메서드 구현 * feat: InputMapper 구현 * feat: 정해진 카드 구성으로 덱을 만드는 Creator 구현 * feat: 카드 숫자가 에이스에 해당하는 숫자인지 확인하는 기능 추가 * feat: 카드가 에이스인지 확인하는 기능 추가 * test: 카드 숫자가 에이스에 해당하는 숫자인지 검증하는 기능 테스트 추가 * fix: 딜러 핸드 합계 구하는 메서드 수정 * feat: 핸드에서 에이스 카드가 몇개인지 세는 기능 구현 * feat: Judge가 핸드로부터 21에 가장 가까운 값을 구하는 기능 구현 * feat: Hand가 버스트 되었는지 판별하는 기능 구현 * feat: 딜러 Hit 동작 구현 * feat: 딜러 핸드 게터 구현 * refactor: 딜러 관련 로직 파라미터 개선 * feat: 플레이어의 승패 결정 로직 구현 * feat: 딜러 게임 결과 데이터 클래스 작성 * feat: Players 플레이어 수 반환하는 기능 구현 * feat: Judge 딜러의 승패를 결정하는 로직 구현 * feat: 최종 승패 출력 로직 구현 * feat: CardNumber 열거형 필드 추가 * feat: Card의 숫자 이름을 반환하는 기능 구현 * fix: 카드의 숫자가 아닌 카드 이름을 사용하도록 뷰로직 변경 * fix: 완성된 카드 결과 출력시 플레이어의 이름과 함께 출력하도록 뷰로직 수정 * refactor: 플레이어들의 점수 출력시 점수를 계산하지 않고 전달받도록 개선 * feat: 컨트롤러 구현 * feat: 어플리케이션 진입점과 컨트롤러 연결 * refactor: Player에서 사용되지 않는 메서드 제거 개선 * refactor: 패키지 구조 세분화 개선 * feat: Score 클래스 구현 * feat: ScoreCalculator 구현 * style: ScoreCalculator -> ScoreCalculateStrategy 클래스 이름 수정 * refactor: Player가 전략을 전달받아 점수를 계산하는 기능 구현 * refactor: 포장한 Score를 전달받아 뷰를 생성하도록 파라미터 개선 * refactor: 메서드 분리 개선 및 점수 계산 책임을 Judge에서 이전 * test: 테스트 이전으로 인한 삭제 * refactor: 히트 가능 책임을 Judge에서 이전 * test: 책임 분리로 인해 유의미하지 않은 테스트 제거 * refactor: 히트 할 수 있는지 여부를 결정하는 전략 Judge로부터 분리 * feat: 점수가 파라미터보다 높은지 확인하는 기능 구현 * feat: 점수간 비교 기능 구현 * refactor: 점수 비교 승패 판정 로직 도메인에게 물어보도록 개선 * fix: 승패 판정, 카드 분배 문제 해결 * refactor: Judge 메서드들 책임 분리 개선 * fix: 딜러 초기 핸드를 한장만 노출하도록 뷰로직 수정 * refactor: 누락된 딜러 전체 카드 출력 메세지 구현 * refactor: 사용하지 않는 클래스 제거 개선 * fix: 공백 뷰로직 수정 * docs: 체크리스트 최신화 * test: 반복되는 테스트 데이터 생성 fixture이용하도록 개선 * refactor: 메서드 순서 배치 개선 * feat: Deck에서 Hand를 생성하는 HandCreator 구현 * fix: CardDeck에서 카드를 뽑을 때 불변리스트를 반환하지 않도록 수정 * feat: 게임 규칙에 맞게 플레이어를 생성하는 기능 구현 * refactor: PlayerCreator로 부터 플레이어와 딜러를 초기화하도록 개선 * feat: Players 클래스에 특정 점수 이하인 플레이어를 세는 기능 구현 * refactor: 구현한 기능을 이용하도록 책임 이전 개선 * refactor: 사용하지 않는 파라미터 제거 개선 * refactor: 책임 이전으로 사용하지 않는 메서드 제거 개선 * feat: Hand가 자신의 채점 기준을 속성으로 가지도록 구현 * feat: Hand가 자신을 채점하는 기능 구현 * refactor: 책임 이전 개선 적용 * refactor: 점수를 플레이어를 통해 계산하도록 개선 * refactor: Hand가 Hit전략을 속성으로 가지도록 개선 * refactor: Player에게 히트할 수 있는지 직접 물어보도록 개선 * refactor: 람다 개선 * refactor: inline개선 * test: 수정된 도메인에 따라 fixture 변경 * style: 우테코 스타일 포매팅 적용 * docs: 카드합 및 점수 관련 기능 구현 목록 추가 * refactor: 컨트롤러 레이어 삭제 및 관련 클래스 이름 변경 개선 * refactor: 불필요한 클래스 참조 제거 개선 * refactor: 에러메시지 구체화 개선 * refactor: 도메인 내에 뷰로직 제거 개선 * fix: 에러메시지 변경에 의한 테스트 코드 수정 * refactor: 덱에서 카드를 뽑을 때 마지막 카드를 뽑도록 개선 * refactor: 팩토리 클래스에서 정적 팩토리 메서드로 로직 응집 개선 * style: 메서드명 구체화 개선 * refactor: 생성 검증 불필요한 통합 제거 개선 * test: 메서드 소스 테스트 CsvSource로 단순화 개선 * style: Player -> Participant 클래스 이름 변경 * refactor: 상속을 위한 속성 접근제어자 수정 개선 * feat: Player 구현 * feat: 딜러 구현 * refactor: 상속 구조에 따른 일급컬렉션 클래스 변경 * feat: 카드덱으로부터 핸드를 생성하는 기능 추가 * refactor: 상속 구조 운용 결정을 통한 PlayerCreator 삭제 개선 * refactor: HitStrategy 로직 딜러와 플레이어에게 이전 * refactor: 추상 클래스 생성자 접근제어자 개선 * refactor: 점수 계산 기능 Hand 도메인으로 책임 이전 * refactor: 사용하지 않는 클래스 제거 개선 * refactor: 점수 계산 로직 Hand 도메인 응집으로 인한 연관 클래스 수정 * refactor: 도메인 내 뷰로직 제거 개선 * refactor: Hand 생성 로직 Hand도메인 안으로 응집 * refactor: 사용하지 않게 된 HandCreator 클래스 제거 개선 * feat: pop한 개수를 계산하는 기능 구현 * refactor: 몇장 더 뽑았는지 딜러에게 물어보도록 개선 * refactor: 딜러 전적 계산 Judge클래스로 책임 이전 * refactor: 사용하지 않는 메서드 제거 개선 * refactor: 상속 구조를 통한 파라미터 타입 개선 * refactor: 사용하지 않는 부분 삭제 개선 * test: TestFixture -> TestDataCreator로 이름 변경을 통한 의미 구체화 * refactor: 정적 팩토리 메서드를 가지는 클래스 생성 로직 퍼지지 않도록 생성자 접근 제어자 개선 --- README.md | 45 +++++++- src/main/java/blackjack/Application.java | 17 +++ src/main/java/blackjack/BlackJackGame.java | 101 ++++++++++++++++++ src/main/java/blackjack/InputMapper.java | 22 ++++ .../blackjack/domain/DealerGameResult.java | 20 ++++ .../java/blackjack/domain/DrawDecision.java | 22 ++++ src/main/java/blackjack/domain/card/Card.java | 43 ++++++++ .../java/blackjack/domain/card/CardDeck.java | 38 +++++++ .../blackjack/domain/card/CardNumber.java | 33 ++++++ .../java/blackjack/domain/card/CardShape.java | 9 ++ .../java/blackjack/domain/player/Dealer.java | 16 +++ .../java/blackjack/domain/player/Hand.java | 59 ++++++++++ .../blackjack/domain/player/Participant.java | 55 ++++++++++ .../java/blackjack/domain/player/Player.java | 15 +++ .../blackjack/domain/player/PlayerName.java | 40 +++++++ .../java/blackjack/domain/player/Players.java | 61 +++++++++++ .../java/blackjack/domain/rule/Judge.java | 31 ++++++ .../java/blackjack/domain/rule/Score.java | 18 ++++ .../java/blackjack/view/CardDescription.java | 45 ++++++++ src/main/java/blackjack/view/InputView.java | 20 ++++ .../java/blackjack/view/MessageResolver.java | 85 +++++++++++++++ src/main/java/blackjack/view/OutputView.java | 45 ++++++++ .../blackjack/domain/DrawDecisionTest.java | 29 +++++ .../blackjack/domain/card/CardDeckTest.java | 77 +++++++++++++ .../blackjack/domain/card/CardNumberTest.java | 20 ++++ .../domain/card/TestCardCreator.java | 16 +++ .../blackjack/domain/player/DealerTest.java | 27 +++++ .../blackjack/domain/player/HandTest.java | 80 ++++++++++++++ .../domain/player/ParticipantNameTest.java | 18 ++++ .../blackjack/domain/player/PlayerTest.java | 27 +++++ .../blackjack/domain/player/PlayersTest.java | 54 ++++++++++ .../domain/player/TestHandCreator.java | 14 +++ .../domain/player/TestPlayerCreator.java | 8 ++ .../java/blackjack/domain/rule/JudgeTest.java | 46 ++++++++ .../java/blackjack/domain/rule/ScoreTest.java | 29 +++++ 35 files changed, 1281 insertions(+), 4 deletions(-) create mode 100644 src/main/java/blackjack/Application.java create mode 100644 src/main/java/blackjack/BlackJackGame.java create mode 100644 src/main/java/blackjack/InputMapper.java create mode 100644 src/main/java/blackjack/domain/DealerGameResult.java create mode 100644 src/main/java/blackjack/domain/DrawDecision.java create mode 100644 src/main/java/blackjack/domain/card/Card.java create mode 100644 src/main/java/blackjack/domain/card/CardDeck.java create mode 100644 src/main/java/blackjack/domain/card/CardNumber.java create mode 100644 src/main/java/blackjack/domain/card/CardShape.java create mode 100644 src/main/java/blackjack/domain/player/Dealer.java create mode 100644 src/main/java/blackjack/domain/player/Hand.java create mode 100644 src/main/java/blackjack/domain/player/Participant.java create mode 100644 src/main/java/blackjack/domain/player/Player.java create mode 100644 src/main/java/blackjack/domain/player/PlayerName.java create mode 100644 src/main/java/blackjack/domain/player/Players.java create mode 100644 src/main/java/blackjack/domain/rule/Judge.java create mode 100644 src/main/java/blackjack/domain/rule/Score.java create mode 100644 src/main/java/blackjack/view/CardDescription.java create mode 100644 src/main/java/blackjack/view/InputView.java create mode 100644 src/main/java/blackjack/view/MessageResolver.java create mode 100644 src/main/java/blackjack/view/OutputView.java create mode 100644 src/test/java/blackjack/domain/DrawDecisionTest.java create mode 100644 src/test/java/blackjack/domain/card/CardDeckTest.java create mode 100644 src/test/java/blackjack/domain/card/CardNumberTest.java create mode 100644 src/test/java/blackjack/domain/card/TestCardCreator.java create mode 100644 src/test/java/blackjack/domain/player/DealerTest.java create mode 100644 src/test/java/blackjack/domain/player/HandTest.java create mode 100644 src/test/java/blackjack/domain/player/ParticipantNameTest.java create mode 100644 src/test/java/blackjack/domain/player/PlayerTest.java create mode 100644 src/test/java/blackjack/domain/player/PlayersTest.java create mode 100644 src/test/java/blackjack/domain/player/TestHandCreator.java create mode 100644 src/test/java/blackjack/domain/player/TestPlayerCreator.java create mode 100644 src/test/java/blackjack/domain/rule/JudgeTest.java create mode 100644 src/test/java/blackjack/domain/rule/ScoreTest.java diff --git a/README.md b/README.md index 556099c4de3..5a33d0f5e30 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,44 @@ -# 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] 출력 + - [x] 각 참여자의 카드 정보를 출력할 수 있다. + - [x] 각 참여자의 카드 합을 출력할 수 있다. + - [x] 최종 승패를 출력할 수 있다. diff --git a/src/main/java/blackjack/Application.java b/src/main/java/blackjack/Application.java new file mode 100644 index 00000000000..859056e6da5 --- /dev/null +++ b/src/main/java/blackjack/Application.java @@ -0,0 +1,17 @@ +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(); + OutputView outputView = new OutputView(new MessageResolver()); + + BlackJackGame blackJackGame = new BlackJackGame(inputView, outputView); + blackJackGame.run(); + } +} diff --git a/src/main/java/blackjack/BlackJackGame.java b/src/main/java/blackjack/BlackJackGame.java new file mode 100644 index 00000000000..4a8b5ece20f --- /dev/null +++ b/src/main/java/blackjack/BlackJackGame.java @@ -0,0 +1,101 @@ +package blackjack; + +import static blackjack.domain.DrawDecision.YES; + +import blackjack.domain.DrawDecision; +import blackjack.domain.card.Card; +import blackjack.domain.card.CardDeck; +import blackjack.domain.player.Dealer; +import blackjack.domain.player.Hand; +import blackjack.domain.player.Participant; +import blackjack.domain.player.Player; +import blackjack.domain.player.PlayerName; +import blackjack.domain.player.Players; +import blackjack.domain.rule.Judge; +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); + Dealer dealer = new Dealer(Hand.createHandFrom(cardDeck)); + printPlayersInformation(players, dealer); + + completePlayersHand(players, cardDeck); + completeDealerHand(dealer, cardDeck); + outputView.printDealerPopCount(Dealer.HIT_THRESHOLD, dealer.countPop()); + + printParticipantScore(dealer); + printPlayersScore(players); + printDealerGameResult(dealer, players); + printPlayersGameResult(players, dealer); + } + + private Players initPlayers(CardDeck cardDeck) { + InputMapper inputMapper = new InputMapper(); + List playerNames = inputMapper.mapToPlayers(inputView.readNames()); + + return new Players(playerNames.stream() + .map(playerName -> new Player(playerName, Hand.createHandFrom(cardDeck))) + .toList()); + } + + private void printPlayersInformation(Players players, Dealer dealer) { + outputView.printHandOutEvent(players, 2); + outputView.printDealerInitialHand(dealer); + players.getPlayers().forEach(outputView::printPlayerHand); + } + + private void completePlayersHand(Players players, CardDeck cardDeck) { + players.getPlayers().forEach(player -> completePlayerHand(player, cardDeck)); + } + + private void completePlayerHand(Player participant, CardDeck cardDeck) { + while (participant.canHit() && readHitDecision(participant) == YES) { + participant.appendCard(cardDeck.popCard()); + outputView.printPlayerHand(participant); + } + } + + private DrawDecision readHitDecision(Player participant) { + InputMapper inputMapper = new InputMapper(); + return inputMapper.mapToDrawDecision(inputView.readDrawPlan(participant.getName())); + } + + private void completeDealerHand(Dealer dealer, CardDeck cardDeck) { + while (dealer.canHit()) { + Card card = cardDeck.popCard(); + dealer.appendCard(card); + } + } + + private void printPlayersScore(Players players) { + players.getPlayers().forEach(this::printParticipantScore); + } + + private void printParticipantScore(Participant participant) { + outputView.printParticipantScore(participant, participant.calculateHandScore()); + } + + private void printDealerGameResult(Dealer dealer, Players players) { + Judge judge = new Judge(); + outputView.printDealerGameResult(judge.calculateDealerGameResult(dealer, players)); + } + + private void printPlayersGameResult(Players players, Dealer dealer) { + Judge judge = new Judge(); + players.getPlayers() + .forEach(player -> outputView.printPlayerGameResult(player, judge.isPlayerWin(dealer, player))); + } +} diff --git a/src/main/java/blackjack/InputMapper.java b/src/main/java/blackjack/InputMapper.java new file mode 100644 index 00000000000..e6e8feb734b --- /dev/null +++ b/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 mapToPlayers(String target) { + String[] split = target.split(DELIMITER); + return Arrays.stream(split) + .map(PlayerName::new) + .toList(); + } + + public DrawDecision mapToDrawDecision(String target) { + return DrawDecision.from(target); + } +} diff --git a/src/main/java/blackjack/domain/DealerGameResult.java b/src/main/java/blackjack/domain/DealerGameResult.java new file mode 100644 index 00000000000..6e0eae9731e --- /dev/null +++ b/src/main/java/blackjack/domain/DealerGameResult.java @@ -0,0 +1,20 @@ +package blackjack.domain; + +public class DealerGameResult { + + private final int winCount; + private final int loseCount; + + public DealerGameResult(int winCount, int loseCount) { + this.winCount = winCount; + this.loseCount = loseCount; + } + + public int getWinCount() { + return winCount; + } + + public int getLoseCount() { + return loseCount; + } +} diff --git a/src/main/java/blackjack/domain/DrawDecision.java b/src/main/java/blackjack/domain/DrawDecision.java new file mode 100644 index 00000000000..3d9850e0ee9 --- /dev/null +++ b/src/main/java/blackjack/domain/DrawDecision.java @@ -0,0 +1,22 @@ +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 + "로 입력해주세요")); + } +} diff --git a/src/main/java/blackjack/domain/card/Card.java b/src/main/java/blackjack/domain/card/Card.java new file mode 100644 index 00000000000..6b4f0b8cd90 --- /dev/null +++ b/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(); + } + + @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); + } + + public CardNumber getCardNumber() { + return cardNumber; + } + + public CardShape getCardShape() { + return cardShape; + } +} diff --git a/src/main/java/blackjack/domain/card/CardDeck.java b/src/main/java/blackjack/domain/card/CardDeck.java new file mode 100644 index 00000000000..8ad67fa1b08 --- /dev/null +++ b/src/main/java/blackjack/domain/card/CardDeck.java @@ -0,0 +1,38 @@ +package blackjack.domain.card; + +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.IntStream; + +public class CardDeck { + + private final List cards; + + CardDeck(List cards) { + this.cards = cards; + } + + public static CardDeck createShuffledDeck() { + List cards = Arrays.stream(CardShape.values()) + .flatMap(shape -> Arrays.stream(CardNumber.values()) + .map(number -> new Card(shape, number))) + .collect(Collectors.toList()); + Collections.shuffle(cards); + return new CardDeck(cards); + } + + public Card popCard() { + if (cards.isEmpty()) { + throw new IllegalArgumentException("[ERROR] 남아있는 카드가 부족하여 카드를 뽑을 수 없습니다"); + } + return cards.remove(cards.size() - 1); + } + + public List popCards(int count) { + return IntStream.range(0, count) + .mapToObj(i -> popCard()) + .collect(Collectors.toList()); + } +} diff --git a/src/main/java/blackjack/domain/card/CardNumber.java b/src/main/java/blackjack/domain/card/CardNumber.java new file mode 100644 index 00000000000..e93fae8cc77 --- /dev/null +++ b/src/main/java/blackjack/domain/card/CardNumber.java @@ -0,0 +1,33 @@ +package blackjack.domain.card; + +public enum CardNumber { + + ACE(1), + TWO(2), + THREE(3), + FOUR(4), + FIVE(5), + SIX(6), + SEVEN(7), + EIGHT(8), + NINE(9), + TEN(10), + JACK(10), + QUEEN(10), + KING(10); + + private final int value; + + CardNumber(int value) { + this.value = value; + } + + public boolean isAce() { + return this == ACE; + } + + public int getValue() { + return value; + } +} + diff --git a/src/main/java/blackjack/domain/card/CardShape.java b/src/main/java/blackjack/domain/card/CardShape.java new file mode 100644 index 00000000000..24735fa598a --- /dev/null +++ b/src/main/java/blackjack/domain/card/CardShape.java @@ -0,0 +1,9 @@ +package blackjack.domain.card; + +public enum CardShape { + + HEART, + DIAMOND, + CLUB, + SPADE; +} diff --git a/src/main/java/blackjack/domain/player/Dealer.java b/src/main/java/blackjack/domain/player/Dealer.java new file mode 100644 index 00000000000..56a536ead0e --- /dev/null +++ b/src/main/java/blackjack/domain/player/Dealer.java @@ -0,0 +1,16 @@ +package blackjack.domain.player; + +public class Dealer extends Participant { + + private static final String DEALER_NAME = "딜러"; + public static final int HIT_THRESHOLD = 16; + + public Dealer(Hand hand) { + super(new PlayerName(DEALER_NAME), hand); + } + + @Override + public boolean canHit() { + return hand.calculateCardSummation() <= HIT_THRESHOLD; + } +} diff --git a/src/main/java/blackjack/domain/player/Hand.java b/src/main/java/blackjack/domain/player/Hand.java new file mode 100644 index 00000000000..6e99b759d2a --- /dev/null +++ b/src/main/java/blackjack/domain/player/Hand.java @@ -0,0 +1,59 @@ +package blackjack.domain.player; + +import blackjack.domain.card.Card; +import blackjack.domain.card.CardDeck; +import blackjack.domain.card.CardNumber; +import blackjack.domain.rule.Score; +import java.util.List; + +public class Hand { + + private static final int INITIAL_HAND_SIZE = 2; + private static final int BLACK_JACK = 21; + private static final int ACE_WEIGHT = 10; + + private final List cards; + + Hand(List cards) { + this.cards = cards; + } + + public static Hand createHandFrom(CardDeck cardDeck) { + return new Hand(cardDeck.popCards(INITIAL_HAND_SIZE)); + } + + public int calculateCardSummation() { + return cards.stream() + .map(Card::getCardNumber) + .mapToInt(CardNumber::getValue) + .sum(); + } + + public void appendCard(Card card) { + cards.add(card); + } + + public int countAce() { + return (int) cards.stream() + .filter(Card::isAce) + .count(); + } + + public int countPop() { + return cards.size() - INITIAL_HAND_SIZE; + } + + public Score calculateScore() { + int aceCount = countAce(); + int sum = calculateCardSummation(); + while (aceCount > 0 && (sum + ACE_WEIGHT) <= BLACK_JACK) { + sum += ACE_WEIGHT; + aceCount--; + } + return new Score(sum); + } + + public List getCards() { + return List.copyOf(cards); + } +} diff --git a/src/main/java/blackjack/domain/player/Participant.java b/src/main/java/blackjack/domain/player/Participant.java new file mode 100644 index 00000000000..6a3d875fc1a --- /dev/null +++ b/src/main/java/blackjack/domain/player/Participant.java @@ -0,0 +1,55 @@ +package blackjack.domain.player; + +import blackjack.domain.card.Card; +import blackjack.domain.rule.Score; +import java.util.Objects; + +public abstract class Participant { + + protected final PlayerName name; + protected final Hand hand; + + protected Participant(PlayerName name, Hand hand) { + this.name = name; + this.hand = hand; + } + + public void appendCard(Card card) { + hand.appendCard(card); + } + + public Score calculateHandScore() { + return hand.calculateScore(); + } + + public int countPop() { + return hand.countPop(); + } + + public abstract boolean canHit(); + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + Participant participant = (Participant) o; + return Objects.equals(name, participant.name); + } + + @Override + public int hashCode() { + return Objects.hash(name); + } + + public String getName() { + return name.getValue(); + } + + public Hand getHand() { + return hand; + } +} diff --git a/src/main/java/blackjack/domain/player/Player.java b/src/main/java/blackjack/domain/player/Player.java new file mode 100644 index 00000000000..be9461db70e --- /dev/null +++ b/src/main/java/blackjack/domain/player/Player.java @@ -0,0 +1,15 @@ +package blackjack.domain.player; + +public class Player extends Participant { + + public static final int HIT_THRESHOLD = 21; + + public Player(PlayerName name, Hand hand) { + super(name, hand); + } + + @Override + public boolean canHit() { + return hand.calculateCardSummation() <= HIT_THRESHOLD; + } +} diff --git a/src/main/java/blackjack/domain/player/PlayerName.java b/src/main/java/blackjack/domain/player/PlayerName.java new file mode 100644 index 00000000000..675d9d6d1bd --- /dev/null +++ b/src/main/java/blackjack/domain/player/PlayerName.java @@ -0,0 +1,40 @@ +package blackjack.domain.player; + +import java.util.Objects; + +public class PlayerName { + + private final String value; + + public PlayerName(String value) { + validateNotEmpty(value); + this.value = value; + } + + private void validateNotEmpty(String value) { + if (value.isEmpty()) { + throw new IllegalArgumentException("[ERROR] 이름이 빈 문자열입니다."); + } + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + PlayerName that = (PlayerName) o; + return Objects.equals(value, that.value); + } + + @Override + public int hashCode() { + return Objects.hash(value); + } + + public String getValue() { + return value; + } +} diff --git a/src/main/java/blackjack/domain/player/Players.java b/src/main/java/blackjack/domain/player/Players.java new file mode 100644 index 00000000000..e0c17514b52 --- /dev/null +++ b/src/main/java/blackjack/domain/player/Players.java @@ -0,0 +1,61 @@ +package blackjack.domain.player; + +import blackjack.domain.rule.Score; +import java.util.List; + +public class Players { + + private static final int MAX_COUNT = 3; + + private final List players; + + public Players(List players) { + validate(players); + this.players = players; + } + + public int countPlayer() { + return players.size(); + } + + public int countPlayerWithScoreAbove(Score target) { + return (int) players.stream() + .map(Participant::calculateHandScore) + .filter(playerScore -> playerScore.isAbove(target)) + .count(); + } + + private void validate(List participants) { + validateEachPlayerNameUnique(participants); + validateEntryNotEmpty(participants); + validatePlayerCountRange(participants); + } + + private void validateEachPlayerNameUnique(List participants) { + if (countUniquePlayer(participants) != participants.size()) { + throw new IllegalArgumentException("[ERROR] 중복되는 플레이어의 이름이 존재합니다"); + } + } + + private int countUniquePlayer(List participants) { + return (int) participants.stream() + .distinct() + .count(); + } + + private void validateEntryNotEmpty(List participants) { + if (participants.isEmpty()) { + throw new IllegalArgumentException("[ERROR] 플레이어가 없습니다"); + } + } + + private void validatePlayerCountRange(List participants) { + if (participants.size() > MAX_COUNT) { + throw new IllegalArgumentException("[ERROR] 플레이어의 수는 " + MAX_COUNT + "이하여야 합니다"); + } + } + + public List getPlayers() { + return players; + } +} diff --git a/src/main/java/blackjack/domain/rule/Judge.java b/src/main/java/blackjack/domain/rule/Judge.java new file mode 100644 index 00000000000..4bcf103ab14 --- /dev/null +++ b/src/main/java/blackjack/domain/rule/Judge.java @@ -0,0 +1,31 @@ +package blackjack.domain.rule; + +import blackjack.domain.DealerGameResult; +import blackjack.domain.player.Dealer; +import blackjack.domain.player.Player; +import blackjack.domain.player.Players; + +public class Judge { + + private static final Score BLACK_JACK = new Score(21); + + public DealerGameResult calculateDealerGameResult(Dealer dealer, Players players) { + int playerWinCount = (int) players.getPlayers().stream() + .filter(player -> isPlayerWin(dealer, player)) + .count(); + int dealerWinCount = players.countPlayer() - playerWinCount; + return new DealerGameResult(dealerWinCount, playerWinCount); + } + + public boolean isPlayerWin(Dealer dealer, Player player) { + Score dealerScore = dealer.calculateHandScore(); + Score playerScore = player.calculateHandScore(); + if (playerScore.isAbove(BLACK_JACK)) { + return false; + } + if (dealerScore.isAbove(BLACK_JACK)) { + return true; + } + return playerScore.isAbove(dealerScore); + } +} diff --git a/src/main/java/blackjack/domain/rule/Score.java b/src/main/java/blackjack/domain/rule/Score.java new file mode 100644 index 00000000000..53ec0d43f21 --- /dev/null +++ b/src/main/java/blackjack/domain/rule/Score.java @@ -0,0 +1,18 @@ +package blackjack.domain.rule; + +public class Score { + + private final int value; + + public Score(int value) { + this.value = value; + } + + public boolean isAbove(Score target) { + return this.value > target.value; + } + + public int getValue() { + return value; + } +} diff --git a/src/main/java/blackjack/view/CardDescription.java b/src/main/java/blackjack/view/CardDescription.java new file mode 100644 index 00000000000..0527ff8ee64 --- /dev/null +++ b/src/main/java/blackjack/view/CardDescription.java @@ -0,0 +1,45 @@ +package blackjack.view; + +import static blackjack.domain.card.CardNumber.ACE; +import static blackjack.domain.card.CardNumber.EIGHT; +import static blackjack.domain.card.CardNumber.FIVE; +import static blackjack.domain.card.CardNumber.FOUR; +import static blackjack.domain.card.CardNumber.JACK; +import static blackjack.domain.card.CardNumber.KING; +import static blackjack.domain.card.CardNumber.NINE; +import static blackjack.domain.card.CardNumber.QUEEN; +import static blackjack.domain.card.CardNumber.SEVEN; +import static blackjack.domain.card.CardNumber.SIX; +import static blackjack.domain.card.CardNumber.TEN; +import static blackjack.domain.card.CardNumber.THREE; +import static blackjack.domain.card.CardNumber.TWO; +import static blackjack.domain.card.CardShape.CLUB; +import static blackjack.domain.card.CardShape.DIAMOND; +import static blackjack.domain.card.CardShape.HEART; +import static blackjack.domain.card.CardShape.SPADE; + +import blackjack.domain.card.CardNumber; +import blackjack.domain.card.CardShape; +import java.util.Map; + +public class CardDescription { + + private CardDescription() { + } + + public static final Map SHAPE_NAME = Map.of( + HEART, "하트", + SPADE, "스페이드", + DIAMOND, "다이아몬드", + CLUB, "클로버" + ); + public static final Map NUMBER_NAME = Map.ofEntries( + Map.entry(ACE, "A"), Map.entry(TWO, "2"), + Map.entry(THREE, "3"), Map.entry(FOUR, "4"), + Map.entry(FIVE, "5"), Map.entry(SIX, "6"), + Map.entry(SEVEN, "7"), Map.entry(EIGHT, "8"), + Map.entry(NINE, "9"), Map.entry(TEN, "10"), + Map.entry(JACK, "J"), Map.entry(QUEEN, "Q"), + Map.entry(KING, "K") + ); +} diff --git a/src/main/java/blackjack/view/InputView.java b/src/main/java/blackjack/view/InputView.java new file mode 100644 index 00000000000..9025acdc90e --- /dev/null +++ b/src/main/java/blackjack/view/InputView.java @@ -0,0 +1,20 @@ +package blackjack.view; + +import java.util.Scanner; + +public class InputView { + + private static final String LINE_SEPARATOR = System.lineSeparator(); + private final Scanner scanner = new Scanner(System.in); + + public String readNames() { + System.out.println("게임에 참여할 사람의 이름을 입력하세요.(쉼표 기준으로 분리)"); + return scanner.nextLine(); + } + + public String readDrawPlan(String name) { + String message = String.format("%s는 한장의 카드를 더 받겠습니까?(예는 y, 아니오는 n)", name); + System.out.println(String.join("", LINE_SEPARATOR, message)); + return scanner.nextLine(); + } +} diff --git a/src/main/java/blackjack/view/MessageResolver.java b/src/main/java/blackjack/view/MessageResolver.java new file mode 100644 index 00000000000..ed237db8a2c --- /dev/null +++ b/src/main/java/blackjack/view/MessageResolver.java @@ -0,0 +1,85 @@ +package blackjack.view; + +import static blackjack.view.CardDescription.NUMBER_NAME; +import static blackjack.view.CardDescription.SHAPE_NAME; + +import blackjack.domain.DealerGameResult; +import blackjack.domain.card.Card; +import blackjack.domain.card.CardNumber; +import blackjack.domain.card.CardShape; +import blackjack.domain.player.Dealer; +import blackjack.domain.player.Hand; +import blackjack.domain.player.Participant; +import blackjack.domain.player.Player; +import blackjack.domain.player.Players; +import blackjack.domain.rule.Score; +import java.util.stream.Collectors; + +public class MessageResolver { + + private static final String LINE_SEPARATOR = System.lineSeparator(); + private static final String SEPARATOR = ", "; + + public String resolveHandOutEventMessage(Players players, int handOutCount) { + String namesMessage = resolveNamesMessage(players); + String message = String.format("딜러와 %s에게 %d장을 나누었습니다.", namesMessage, handOutCount); + return String.join("", LINE_SEPARATOR, message); + } + + private String resolveNamesMessage(Players players) { + return players.getPlayers().stream() + .map(Player::getName) + .collect(Collectors.joining(SEPARATOR)); + } + + public String resolvePlayerHandMessage(Participant participant) { + return String.format("%s 카드: %s", participant.getName(), resolveHandMessage(participant.getHand())); + } + + private String resolveHandMessage(Hand hand) { + return hand.getCards().stream() + .map(this::resolveCardMessage) + .collect(Collectors.joining(SEPARATOR)); + } + + private String resolveCardMessage(Card card) { + CardNumber cardNumber = card.getCardNumber(); + CardShape cardShape = card.getCardShape(); + return String.format("%s%s", NUMBER_NAME.get(cardNumber), SHAPE_NAME.get(cardShape)); + } + + public String resolveDealerHandMessage(Dealer dealer) { + Card card = dealer.getHand().getCards().get(0); + return String.format("%s: %s", dealer.getName(), resolveCardMessage(card)); + } + + public String resolveDealerPopCountMessage(int dealerDrawThreshold, int popCount) { + if (popCount > 0) { + String message = String.format("딜러는 %d이하라 %d장의 카드를 더 받았습니다.", dealerDrawThreshold, popCount); + return String.join("", LINE_SEPARATOR, message, LINE_SEPARATOR); + } + return ""; + } + + public String resolveParticipantScoreMessage(Participant participant, Score score) { + String handMessage = resolvePlayerHandMessage(participant); + return String.format("%s - 결과: %d", handMessage, score.getValue()); + } + + public String resolvePlayerGameResult(Player participant, boolean win) { + return String.format("%s: %s", participant.getName(), resolveGameResultMessage(win)); + } + + private String resolveGameResultMessage(boolean win) { + if (win) { + return "승"; + } + return "패"; + } + + public String resolveDealerGameResult(DealerGameResult dealerGameResult) { + String prefix = String.join("", LINE_SEPARATOR, "## 최종 승패"); + String message = String.format("딜러: %d승 %d패", dealerGameResult.getWinCount(), dealerGameResult.getLoseCount()); + return String.join("", prefix, LINE_SEPARATOR, message); + } +} diff --git a/src/main/java/blackjack/view/OutputView.java b/src/main/java/blackjack/view/OutputView.java new file mode 100644 index 00000000000..0048798f34c --- /dev/null +++ b/src/main/java/blackjack/view/OutputView.java @@ -0,0 +1,45 @@ +package blackjack.view; + +import blackjack.domain.DealerGameResult; +import blackjack.domain.player.Dealer; +import blackjack.domain.player.Participant; +import blackjack.domain.player.Player; +import blackjack.domain.player.Players; +import blackjack.domain.rule.Score; + +public class OutputView { + + private final MessageResolver messageResolver; + + public OutputView(MessageResolver messageResolver) { + this.messageResolver = messageResolver; + } + + public void printHandOutEvent(Players players, int handedCount) { + System.out.println(messageResolver.resolveHandOutEventMessage(players, handedCount)); + } + + public void printPlayerHand(Player participant) { + System.out.println(messageResolver.resolvePlayerHandMessage(participant)); + } + + public void printDealerPopCount(int dealerPopThreshold, int count) { + System.out.println(messageResolver.resolveDealerPopCountMessage(dealerPopThreshold, count)); + } + + public void printParticipantScore(Participant participant, Score score) { + System.out.println(messageResolver.resolveParticipantScoreMessage(participant, score)); + } + + public void printPlayerGameResult(Player participant, boolean win) { + System.out.println(messageResolver.resolvePlayerGameResult(participant, win)); + } + + public void printDealerGameResult(DealerGameResult dealerGameResult) { + System.out.println(messageResolver.resolveDealerGameResult(dealerGameResult)); + } + + public void printDealerInitialHand(Dealer dealer) { + System.out.println(messageResolver.resolveDealerHandMessage(dealer)); + } +} diff --git a/src/test/java/blackjack/domain/DrawDecisionTest.java b/src/test/java/blackjack/domain/DrawDecisionTest.java new file mode 100644 index 00000000000..c5d6dd45761 --- /dev/null +++ b/src/test/java/blackjack/domain/DrawDecisionTest.java @@ -0,0 +1,29 @@ +package blackjack.domain; + +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.assertj.core.api.AssertionsForClassTypes.assertThat; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; +import org.junit.jupiter.params.provider.ValueSource; + +@DisplayName("드로우 결정 도메인 테스트") +class DrawDecisionTest { + + @DisplayName("존재하지 않는 코드명이면 예외가 발생한다") + @ParameterizedTest + @ValueSource(strings = {"1", "libi", "jerry"}) + void testEnumFromInvalidCode(String code) { + assertThatThrownBy(() -> DrawDecision.from(code)) + .isInstanceOf(IllegalArgumentException.class) + .hasMessage("[ERROR] y또는 n로 입력해주세요"); + } + + @DisplayName("존재하는 코드명이면 적절한 상수를 반환받는다") + @ParameterizedTest + @CsvSource(value = {"y, YES", "n, NO",}) + void testEnumFromValidCode(String code, DrawDecision drawDecision) { + assertThat(DrawDecision.from(code)).isEqualTo(drawDecision); + } +} diff --git a/src/test/java/blackjack/domain/card/CardDeckTest.java b/src/test/java/blackjack/domain/card/CardDeckTest.java new file mode 100644 index 00000000000..1c6c858e7f7 --- /dev/null +++ b/src/test/java/blackjack/domain/card/CardDeckTest.java @@ -0,0 +1,77 @@ +package blackjack.domain.card; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +import java.util.ArrayList; +import java.util.List; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +@DisplayName("총 카드 덱 테스트") +class CardDeckTest { + + @DisplayName("덱에서 카드를 뽑을 수 있다") + @Test + void testPopCardFromDeck() { + List cards = new ArrayList<>(); + Card card1 = new Card(CardShape.HEART, CardNumber.TWO); + Card card2 = new Card(CardShape.CLUB, CardNumber.THREE); + Card card3 = new Card(CardShape.DIAMOND, CardNumber.FOUR); + + cards.add(card1); + cards.add(card2); + cards.add(card3); + + CardDeck cardDeck = new CardDeck(cards); + Card popped = cardDeck.popCard(); + assertThat(popped).isEqualTo(card3); + } + + @DisplayName("덱에서 횟수만큼 카드를 뽑을 수 있다") + @Test + void testPopCardsFromDeck() { + List cards = new ArrayList<>(); + Card card1 = new Card(CardShape.HEART, CardNumber.TWO); + Card card2 = new Card(CardShape.CLUB, CardNumber.THREE); + Card card3 = new Card(CardShape.DIAMOND, CardNumber.FOUR); + + cards.add(card1); + cards.add(card2); + cards.add(card3); + + CardDeck cardDeck = new CardDeck(cards); + List popped = cardDeck.popCards(3); + + assertThat(popped).hasSize(3); + } + + @DisplayName("덱에서 카드를 하나 뽑는 경우 카드가 부족하면 예외가 발생한다") + @Test + void testInvalidPopInsufficientDeckCount() { + List cards = new ArrayList<>(); + CardDeck cardDeck = new CardDeck(cards); + + assertThatThrownBy(() -> cardDeck.popCard()) + .isInstanceOf(IllegalArgumentException.class) + .hasMessage("[ERROR] 남아있는 카드가 부족하여 카드를 뽑을 수 없습니다"); + } + + @DisplayName("덱에서 카드를 여러개 뽑는 경우 카드가 부족하면 예외가 발생한다") + @Test + void testInvalidPopCardsInsufficientDeckCount() { + List cards = new ArrayList<>(); + Card card1 = new Card(CardShape.HEART, CardNumber.TWO); + Card card2 = new Card(CardShape.CLUB, CardNumber.THREE); + Card card3 = new Card(CardShape.DIAMOND, CardNumber.FOUR); + + cards.add(card1); + cards.add(card2); + cards.add(card3); + + CardDeck cardDeck = new CardDeck(cards); + assertThatThrownBy(() -> cardDeck.popCards(4)) + .isInstanceOf(IllegalArgumentException.class) + .hasMessage("[ERROR] 남아있는 카드가 부족하여 카드를 뽑을 수 없습니다"); + } +} diff --git a/src/test/java/blackjack/domain/card/CardNumberTest.java b/src/test/java/blackjack/domain/card/CardNumberTest.java new file mode 100644 index 00000000000..0a9493f1bdb --- /dev/null +++ b/src/test/java/blackjack/domain/card/CardNumberTest.java @@ -0,0 +1,20 @@ +package blackjack.domain.card; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertAll; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +@DisplayName("카드 숫자 enum 테스트") +class CardNumberTest { + + @DisplayName("Ace에 해당하는 지 확인할 수 있다") + @Test + void testIsCardNumberAce() { + assertAll( + () -> assertThat(CardNumber.ACE.isAce()).isTrue(), + () -> assertThat(CardNumber.TWO.isAce()).isFalse() + ); + } +} diff --git a/src/test/java/blackjack/domain/card/TestCardCreator.java b/src/test/java/blackjack/domain/card/TestCardCreator.java new file mode 100644 index 00000000000..50541eafffe --- /dev/null +++ b/src/test/java/blackjack/domain/card/TestCardCreator.java @@ -0,0 +1,16 @@ +package blackjack.domain.card; + +import static blackjack.domain.card.CardShape.HEART; + +import java.util.Arrays; + +public class TestCardCreator { + + public static Card from(int number) { + CardNumber cardNumber = Arrays.stream(CardNumber.values()) + .filter(cn -> cn.getValue() == number) + .findFirst() + .orElseThrow(IllegalArgumentException::new); + return new Card(HEART, cardNumber); + } +} diff --git a/src/test/java/blackjack/domain/player/DealerTest.java b/src/test/java/blackjack/domain/player/DealerTest.java new file mode 100644 index 00000000000..c4003d07c05 --- /dev/null +++ b/src/test/java/blackjack/domain/player/DealerTest.java @@ -0,0 +1,27 @@ +package blackjack.domain.player; + +import static org.assertj.core.api.Assertions.assertThat; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; + +@DisplayName("딜러 테스트") +class DealerTest { + + @DisplayName("딜러는 16점 이하이면 카드를 받을 수 있다") + @ParameterizedTest + @CsvSource(value = {"6, 10", "5, 10", "4, 10"}) + void testCannotHit(int card1, int card2) { + Dealer dealer = new Dealer(TestHandCreator.of(card1, card2)); + assertThat(dealer.canHit()).isTrue(); + } + + @DisplayName("딜러는 17점 이상이면 카드를 받을 수 없다") + @ParameterizedTest + @CsvSource(value = {"7, 10", "8, 10", "9, 10"}) + void testCanHit(int card1, int card2) { + Dealer dealer = new Dealer(TestHandCreator.of(card1, card2)); + assertThat(dealer.canHit()).isFalse(); + } +} diff --git a/src/test/java/blackjack/domain/player/HandTest.java b/src/test/java/blackjack/domain/player/HandTest.java new file mode 100644 index 00000000000..6ec98853bbf --- /dev/null +++ b/src/test/java/blackjack/domain/player/HandTest.java @@ -0,0 +1,80 @@ +package blackjack.domain.player; + +import static org.assertj.core.api.Assertions.assertThat; + +import blackjack.domain.card.Card; +import blackjack.domain.card.CardDeck; +import blackjack.domain.card.TestCardCreator; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +@DisplayName("참가자 소유 카드 테스트") +class HandTest { + + @DisplayName("초기 핸드의 사이즈는 2이다") + @Test + void testCreateInitialHandSize() { + Hand hand = Hand.createHandFrom(CardDeck.createShuffledDeck()); + assertThat(hand.getCards().size()).isEqualTo(2); + } + + @DisplayName("카드의 합을 계산할 수 있다.") + @Test + void testHandSummation() { + Hand hand = TestHandCreator.of(2, 2, 2); + assertThat(hand.calculateCardSummation()).isEqualTo(6); + } + + @DisplayName("특정 카드를 핸드에 추가할 수 있다") + @Test + void testAppendCard() { + Card card = TestCardCreator.from(2); + Hand hand = TestHandCreator.of(); + hand.appendCard(card); + assertThat(hand.getCards()).containsExactly(card); + } + + @DisplayName("몇개의 카드를 더 뽑은 상태인지 확인할 수 있다") + @Test + void testCountPop() { + CardDeck cardDeck = CardDeck.createShuffledDeck(); + Hand hand = Hand.createHandFrom(cardDeck); + hand.appendCard(cardDeck.popCard()); + assertThat(hand.countPop()).isEqualTo(1); + } + + @DisplayName("핸드에 에이스 카드가 몇개 있는지 확인할 수 있다") + @Test + void testCountAceInHand() { + Hand hand = TestHandCreator.of(1, 1, 1, 3, 4, 5); + assertThat(hand.countAce()).isEqualTo(3); + } + + @DisplayName("적절한 점수를 계산할 수 있다 - Ace 카드 없음") + @Test + void testCalculateScoreWithNoAce() { + Hand hand = TestHandCreator.of(2, 3, 4, 5); + assertThat(hand.calculateScore().getValue()).isEqualTo(14); + } + + @DisplayName("적절한 점수를 계산할 수 있다 - Ace 카드가 11로 이용됨") + @Test + void testCalculateScoreWithBigAce() { + Hand hand = TestHandCreator.of(1, 10); + assertThat(hand.calculateScore().getValue()).isEqualTo(21); + } + + @DisplayName("적절한 점수를 계산할 수 있다 - Ace 카드가 1로 이용됨") + @Test + void testCalculateScoreWithLowAce() { + Hand hand = TestHandCreator.of(1, 10, 2); + assertThat(hand.calculateScore().getValue()).isEqualTo(13); + } + + @DisplayName("적절한 점수를 계산할 수 있다 - Ace 카드 두개 이상") + @Test + void testCalculateScoreWithMultipleAce() { + Hand hand = TestHandCreator.of(1, 1, 1); + assertThat(hand.calculateScore().getValue()).isEqualTo(13); + } +} diff --git a/src/test/java/blackjack/domain/player/ParticipantNameTest.java b/src/test/java/blackjack/domain/player/ParticipantNameTest.java new file mode 100644 index 00000000000..e2f523e93f6 --- /dev/null +++ b/src/test/java/blackjack/domain/player/ParticipantNameTest.java @@ -0,0 +1,18 @@ +package blackjack.domain.player; + +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +@DisplayName("참가자 이름 테스트") +class ParticipantNameTest { + + @DisplayName("이름은 빈 문자열일 수 없다") + @Test + void testCreatePlayerNameWithEmpty() { + assertThatThrownBy(() -> new PlayerName("")) + .isInstanceOf(IllegalArgumentException.class) + .hasMessage("[ERROR] 이름이 빈 문자열입니다."); + } +} diff --git a/src/test/java/blackjack/domain/player/PlayerTest.java b/src/test/java/blackjack/domain/player/PlayerTest.java new file mode 100644 index 00000000000..ef15046bcd1 --- /dev/null +++ b/src/test/java/blackjack/domain/player/PlayerTest.java @@ -0,0 +1,27 @@ +package blackjack.domain.player; + +import static org.assertj.core.api.Assertions.assertThat; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; + +@DisplayName("블랙잭 플레이어 테스트") +class PlayerTest { + + @DisplayName("플레이어는 21이 넘으면 히트할 수 없다") + @ParameterizedTest + @CsvSource(value = {"2, 10, 10", "3, 10, 10", "4, 10, 10"}) + void testCannotHit(int card1, int card2, int card3) { + Player player = new Player(new PlayerName("썬"), TestHandCreator.of(card1, card2, card3)); + assertThat(player.canHit()).isFalse(); + } + + @DisplayName("플레이어는 21이 넘으면 히트할 수 없다") + @ParameterizedTest + @CsvSource(value = {"1, 10, 10", "2, 8, 10", "2, 7, 10"}) + void testCanHit(int card1, int card2, int card3) { + Player player = new Player(new PlayerName("썬"), TestHandCreator.of(card1, card2, card3)); + assertThat(player.canHit()).isTrue(); + } +} diff --git a/src/test/java/blackjack/domain/player/PlayersTest.java b/src/test/java/blackjack/domain/player/PlayersTest.java new file mode 100644 index 00000000000..c4a6b9f6f0b --- /dev/null +++ b/src/test/java/blackjack/domain/player/PlayersTest.java @@ -0,0 +1,54 @@ +package blackjack.domain.player; + +import static org.assertj.core.api.Assertions.assertThatCode; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +import java.util.List; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +@DisplayName("참가자들 테스트") +class PlayersTest { + + @DisplayName("참가자들 중 이름이 중복되는 경우는 생성 검증에 실패한다") + @Test + void testCreatePlayersWithDuplicateNames() { + Player player1 = TestPlayerCreator.of("리비", 1, 2); + Player player2 = TestPlayerCreator.of("리비", 3, 4); + + assertThatThrownBy(() -> new Players(List.of(player1, player2))) + .isInstanceOf(IllegalArgumentException.class) + .hasMessage("[ERROR] 중복되는 플레이어의 이름이 존재합니다"); + } + + @DisplayName("플레이어가 없으면 생성에 실패한다") + @Test + void testCreatePlayersWithEmptyEntry() { + assertThatThrownBy(() -> new Players(List.of())) + .isInstanceOf(IllegalArgumentException.class) + .hasMessage("[ERROR] 플레이어가 없습니다"); + } + + @DisplayName("딜러를 제외한 게임 참여자가 3명을 넘는 경우는 생성 검증에 실패한다") + @Test + void testCreatePlayersWithInvalidEntryCount() { + Player player1 = TestPlayerCreator.of("리비", 1, 2); + Player player2 = TestPlayerCreator.of("제리", 3, 4); + Player player3 = TestPlayerCreator.of("잉크", 1, 2); + Player player4 = TestPlayerCreator.of("트레", 3, 4); + + assertThatThrownBy(() -> new Players(List.of(player1, player2, player3, player4))) + .isInstanceOf(IllegalArgumentException.class) + .hasMessage("[ERROR] 플레이어의 수는 3이하여야 합니다"); + } + + @DisplayName("생성 검증을 모두 통과하면 생성에 성공한다") + @Test + void testCreateWithValidPlayers() { + Player player1 = TestPlayerCreator.of("리비", 1, 2); + Player player2 = TestPlayerCreator.of("제리", 3, 4); + + assertThatCode(() -> new Players(List.of(player1, player2))) + .doesNotThrowAnyException(); + } +} diff --git a/src/test/java/blackjack/domain/player/TestHandCreator.java b/src/test/java/blackjack/domain/player/TestHandCreator.java new file mode 100644 index 00000000000..8a4aeb229c2 --- /dev/null +++ b/src/test/java/blackjack/domain/player/TestHandCreator.java @@ -0,0 +1,14 @@ +package blackjack.domain.player; + +import blackjack.domain.card.TestCardCreator; +import java.util.Arrays; +import java.util.stream.Collectors; + +public class TestHandCreator { + + public static Hand of(int... numbers) { + return new Hand(Arrays.stream(numbers) + .mapToObj(TestCardCreator::from) + .collect(Collectors.toList())); + } +} diff --git a/src/test/java/blackjack/domain/player/TestPlayerCreator.java b/src/test/java/blackjack/domain/player/TestPlayerCreator.java new file mode 100644 index 00000000000..003bf10f2a3 --- /dev/null +++ b/src/test/java/blackjack/domain/player/TestPlayerCreator.java @@ -0,0 +1,8 @@ +package blackjack.domain.player; + +public class TestPlayerCreator { + + public static Player of(String name, int... hand) { + return new Player(new PlayerName(name), TestHandCreator.of(hand)); + } +} diff --git a/src/test/java/blackjack/domain/rule/JudgeTest.java b/src/test/java/blackjack/domain/rule/JudgeTest.java new file mode 100644 index 00000000000..fdf79a5e2db --- /dev/null +++ b/src/test/java/blackjack/domain/rule/JudgeTest.java @@ -0,0 +1,46 @@ +package blackjack.domain.rule; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertAll; + +import blackjack.domain.DealerGameResult; +import blackjack.domain.player.Dealer; +import blackjack.domain.player.Player; +import blackjack.domain.player.Players; +import blackjack.domain.player.TestHandCreator; +import blackjack.domain.player.TestPlayerCreator; +import java.util.List; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +class JudgeTest { + + private Judge judge; + + @BeforeEach + void setUp() { + judge = new Judge(); + } + + @DisplayName("딜러와 플레이어 중 누가 이겼는지 알 수 있다") + @Test + void testSelectWinner() { + Player player = TestPlayerCreator.of("리비", 2, 3); + Dealer dealer = new Dealer(TestHandCreator.of(3, 4)); + assertThat(judge.isPlayerWin(dealer, player)).isFalse(); + } + + @DisplayName("딜러의 전적을 계산할 수 있다") + @Test + void testCalculateDealerResult() { + Player player = TestPlayerCreator.of("리비", 2, 3); + Dealer dealer = new Dealer(TestHandCreator.of(3, 4)); + Players players = new Players(List.of(player)); + DealerGameResult dealerGameResult = judge.calculateDealerGameResult(dealer, players); + assertAll( + () -> assertThat(dealerGameResult.getWinCount()).isEqualTo(1), + () -> assertThat(dealerGameResult.getLoseCount()).isEqualTo(0) + ); + } +} diff --git a/src/test/java/blackjack/domain/rule/ScoreTest.java b/src/test/java/blackjack/domain/rule/ScoreTest.java new file mode 100644 index 00000000000..25adcc506f3 --- /dev/null +++ b/src/test/java/blackjack/domain/rule/ScoreTest.java @@ -0,0 +1,29 @@ +package blackjack.domain.rule; + +import static org.assertj.core.api.Assertions.assertThat; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +@DisplayName("점수 테스트") +class ScoreTest { + + @DisplayName("더 낮은 점수와 비교할 수 있다") + @ParameterizedTest + @ValueSource(ints = {1, 2, 3, 4, 5}) + void testScoreCompareWithBigger(int value) { + Score score = new Score(0); + Score target = new Score(value); + assertThat(score.isAbove(target)).isFalse(); + } + + @DisplayName("점수가 파라미터를 넘지 않는지 확인할 수 있다") + @ParameterizedTest + @ValueSource(ints = {1, 2, 3, 4, 5}) + void testScoreCompareWithLower(int value) { + Score score = new Score(6); + Score target = new Score(value); + assertThat(score.isAbove(target)).isTrue(); + } +} From dc1784ae3ccccebe538a22ceb15cc0e37d4804d6 Mon Sep 17 00:00:00 2001 From: libienz Date: Tue, 12 Mar 2024 15:24:44 +0900 Subject: [PATCH 02/91] =?UTF-8?q?feat:=20DrawDecision=EC=9D=B4=20YES?= =?UTF-8?q?=EC=9D=B8=EC=A7=80=20=ED=99=95=EC=9D=B8=ED=95=98=EB=8A=94=20?= =?UTF-8?q?=EA=B8=B0=EB=8A=A5=20=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/BlackJackGame.java | 4 +--- .../java/blackjack/domain/DrawDecision.java | 4 ++++ .../blackjack/domain/DrawDecisionTest.java | 18 ++++++++++++++++-- 3 files changed, 21 insertions(+), 5 deletions(-) diff --git a/src/main/java/blackjack/BlackJackGame.java b/src/main/java/blackjack/BlackJackGame.java index 4a8b5ece20f..c39ea293bc9 100644 --- a/src/main/java/blackjack/BlackJackGame.java +++ b/src/main/java/blackjack/BlackJackGame.java @@ -1,7 +1,5 @@ package blackjack; -import static blackjack.domain.DrawDecision.YES; - import blackjack.domain.DrawDecision; import blackjack.domain.card.Card; import blackjack.domain.card.CardDeck; @@ -62,7 +60,7 @@ private void completePlayersHand(Players players, CardDeck cardDeck) { } private void completePlayerHand(Player participant, CardDeck cardDeck) { - while (participant.canHit() && readHitDecision(participant) == YES) { + while (participant.canHit() && readHitDecision(participant).isYes()) { participant.appendCard(cardDeck.popCard()); outputView.printPlayerHand(participant); } diff --git a/src/main/java/blackjack/domain/DrawDecision.java b/src/main/java/blackjack/domain/DrawDecision.java index 3d9850e0ee9..ed5b60b65df 100644 --- a/src/main/java/blackjack/domain/DrawDecision.java +++ b/src/main/java/blackjack/domain/DrawDecision.java @@ -19,4 +19,8 @@ public static DrawDecision from(String code) { .findFirst() .orElseThrow(() -> new IllegalArgumentException("[ERROR] " + YES.code + "또는 " + NO.code + "로 입력해주세요")); } + + public boolean isYes() { + return this == YES; + } } diff --git a/src/test/java/blackjack/domain/DrawDecisionTest.java b/src/test/java/blackjack/domain/DrawDecisionTest.java index c5d6dd45761..2eebb406034 100644 --- a/src/test/java/blackjack/domain/DrawDecisionTest.java +++ b/src/test/java/blackjack/domain/DrawDecisionTest.java @@ -1,9 +1,14 @@ package blackjack.domain; +import static blackjack.domain.DrawDecision.NO; +import static blackjack.domain.DrawDecision.YES; +import static blackjack.domain.DrawDecision.from; import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.assertj.core.api.AssertionsForClassTypes.assertThat; +import static org.junit.jupiter.api.Assertions.assertAll; import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.CsvSource; import org.junit.jupiter.params.provider.ValueSource; @@ -15,7 +20,7 @@ class DrawDecisionTest { @ParameterizedTest @ValueSource(strings = {"1", "libi", "jerry"}) void testEnumFromInvalidCode(String code) { - assertThatThrownBy(() -> DrawDecision.from(code)) + assertThatThrownBy(() -> from(code)) .isInstanceOf(IllegalArgumentException.class) .hasMessage("[ERROR] y또는 n로 입력해주세요"); } @@ -24,6 +29,15 @@ void testEnumFromInvalidCode(String code) { @ParameterizedTest @CsvSource(value = {"y, YES", "n, NO",}) void testEnumFromValidCode(String code, DrawDecision drawDecision) { - assertThat(DrawDecision.from(code)).isEqualTo(drawDecision); + assertThat(from(code)).isEqualTo(drawDecision); + } + + @DisplayName("YES인지 확인할 수 있다") + @Test + void testIsYes() { + assertAll( + () -> assertThat(YES.isYes()).isTrue(), + () -> assertThat(NO.isYes()).isFalse() + ); } } From 00925f72add8db5a4d23a7a2f4b73fa10c3da34a Mon Sep 17 00:00:00 2001 From: libienz Date: Tue, 12 Mar 2024 15:25:42 +0900 Subject: [PATCH 03/91] =?UTF-8?q?style:=20Pop=20->=20Draw=20=EB=A9=94?= =?UTF-8?q?=EC=84=9C=EB=93=9C=20=EB=AA=85=20=EC=9D=98=EB=AF=B8=20=EA=B5=AC?= =?UTF-8?q?=EC=B2=B4=ED=99=94=20=EA=B0=9C=EC=84=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/BlackJackGame.java | 2 +- src/main/java/blackjack/domain/player/Hand.java | 2 +- src/main/java/blackjack/domain/player/Participant.java | 4 ++-- src/test/java/blackjack/domain/player/HandTest.java | 2 +- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/main/java/blackjack/BlackJackGame.java b/src/main/java/blackjack/BlackJackGame.java index c39ea293bc9..bb300d1b199 100644 --- a/src/main/java/blackjack/BlackJackGame.java +++ b/src/main/java/blackjack/BlackJackGame.java @@ -32,7 +32,7 @@ public void run() { completePlayersHand(players, cardDeck); completeDealerHand(dealer, cardDeck); - outputView.printDealerPopCount(Dealer.HIT_THRESHOLD, dealer.countPop()); + outputView.printDealerPopCount(Dealer.HIT_THRESHOLD, dealer.countDraw()); printParticipantScore(dealer); printPlayersScore(players); diff --git a/src/main/java/blackjack/domain/player/Hand.java b/src/main/java/blackjack/domain/player/Hand.java index 6e99b759d2a..6699b07f528 100644 --- a/src/main/java/blackjack/domain/player/Hand.java +++ b/src/main/java/blackjack/domain/player/Hand.java @@ -39,7 +39,7 @@ public int countAce() { .count(); } - public int countPop() { + public int countDraw() { return cards.size() - INITIAL_HAND_SIZE; } diff --git a/src/main/java/blackjack/domain/player/Participant.java b/src/main/java/blackjack/domain/player/Participant.java index 6a3d875fc1a..f823b694201 100644 --- a/src/main/java/blackjack/domain/player/Participant.java +++ b/src/main/java/blackjack/domain/player/Participant.java @@ -22,8 +22,8 @@ public Score calculateHandScore() { return hand.calculateScore(); } - public int countPop() { - return hand.countPop(); + public int countDraw() { + return hand.countDraw(); } public abstract boolean canHit(); diff --git a/src/test/java/blackjack/domain/player/HandTest.java b/src/test/java/blackjack/domain/player/HandTest.java index 6ec98853bbf..37c530eb52d 100644 --- a/src/test/java/blackjack/domain/player/HandTest.java +++ b/src/test/java/blackjack/domain/player/HandTest.java @@ -40,7 +40,7 @@ void testCountPop() { CardDeck cardDeck = CardDeck.createShuffledDeck(); Hand hand = Hand.createHandFrom(cardDeck); hand.appendCard(cardDeck.popCard()); - assertThat(hand.countPop()).isEqualTo(1); + assertThat(hand.countDraw()).isEqualTo(1); } @DisplayName("핸드에 에이스 카드가 몇개 있는지 확인할 수 있다") From aa4034204a17cb410771e191a3adcedf4a800fb6 Mon Sep 17 00:00:00 2001 From: libienz Date: Tue, 12 Mar 2024 15:26:22 +0900 Subject: [PATCH 04/91] =?UTF-8?q?refactor:=20=EB=A9=94=EC=84=9C=EB=93=9C?= =?UTF-8?q?=20=EB=B0=B0=EC=B9=98=20=EC=88=9C=EC=84=9C=20=EA=B0=9C=EC=84=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/player/Participant.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/blackjack/domain/player/Participant.java b/src/main/java/blackjack/domain/player/Participant.java index f823b694201..61c1d32dd36 100644 --- a/src/main/java/blackjack/domain/player/Participant.java +++ b/src/main/java/blackjack/domain/player/Participant.java @@ -14,6 +14,8 @@ protected Participant(PlayerName name, Hand hand) { this.hand = hand; } + public abstract boolean canHit(); + public void appendCard(Card card) { hand.appendCard(card); } @@ -26,8 +28,6 @@ public int countDraw() { return hand.countDraw(); } - public abstract boolean canHit(); - @Override public boolean equals(Object o) { if (this == o) { From 0fee0a872ce22e401667fbb0716c63fde38dfee4 Mon Sep 17 00:00:00 2001 From: libienz Date: Tue, 12 Mar 2024 15:31:00 +0900 Subject: [PATCH 05/91] =?UTF-8?q?refactor:=20InputView=EA=B0=80=20?= =?UTF-8?q?=EB=8F=84=EB=A9=94=EC=9D=B8=EC=9D=84=20=EB=A7=A4=ED=95=91?= =?UTF-8?q?=ED=95=B4=EC=84=9C=20=EC=A0=84=EB=8B=AC=ED=95=98=EB=8F=84?= =?UTF-8?q?=EB=A1=9D=20=EA=B0=9C=EC=84=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/Application.java | 3 +-- src/main/java/blackjack/BlackJackGame.java | 12 ++---------- src/main/java/blackjack/InputMapper.java | 2 +- src/main/java/blackjack/view/InputView.java | 18 ++++++++++++++---- 4 files changed, 18 insertions(+), 17 deletions(-) diff --git a/src/main/java/blackjack/Application.java b/src/main/java/blackjack/Application.java index 859056e6da5..47214ff1a6f 100644 --- a/src/main/java/blackjack/Application.java +++ b/src/main/java/blackjack/Application.java @@ -7,8 +7,7 @@ public class Application { public static void main(String[] args) { - - InputView inputView = new InputView(); + InputView inputView = new InputView(new InputMapper()); OutputView outputView = new OutputView(new MessageResolver()); BlackJackGame blackJackGame = new BlackJackGame(inputView, outputView); diff --git a/src/main/java/blackjack/BlackJackGame.java b/src/main/java/blackjack/BlackJackGame.java index bb300d1b199..1bd78ab8b19 100644 --- a/src/main/java/blackjack/BlackJackGame.java +++ b/src/main/java/blackjack/BlackJackGame.java @@ -1,6 +1,5 @@ package blackjack; -import blackjack.domain.DrawDecision; import blackjack.domain.card.Card; import blackjack.domain.card.CardDeck; import blackjack.domain.player.Dealer; @@ -41,9 +40,7 @@ public void run() { } private Players initPlayers(CardDeck cardDeck) { - InputMapper inputMapper = new InputMapper(); - List playerNames = inputMapper.mapToPlayers(inputView.readNames()); - + List playerNames = inputView.readNames(); return new Players(playerNames.stream() .map(playerName -> new Player(playerName, Hand.createHandFrom(cardDeck))) .toList()); @@ -60,17 +57,12 @@ private void completePlayersHand(Players players, CardDeck cardDeck) { } private void completePlayerHand(Player participant, CardDeck cardDeck) { - while (participant.canHit() && readHitDecision(participant).isYes()) { + while (participant.canHit() && inputView.readDrawDecision(participant.getName()).isYes()) { participant.appendCard(cardDeck.popCard()); outputView.printPlayerHand(participant); } } - private DrawDecision readHitDecision(Player participant) { - InputMapper inputMapper = new InputMapper(); - return inputMapper.mapToDrawDecision(inputView.readDrawPlan(participant.getName())); - } - private void completeDealerHand(Dealer dealer, CardDeck cardDeck) { while (dealer.canHit()) { Card card = cardDeck.popCard(); diff --git a/src/main/java/blackjack/InputMapper.java b/src/main/java/blackjack/InputMapper.java index e6e8feb734b..f108f887aae 100644 --- a/src/main/java/blackjack/InputMapper.java +++ b/src/main/java/blackjack/InputMapper.java @@ -9,7 +9,7 @@ public class InputMapper { private static final String DELIMITER = ","; - public List mapToPlayers(String target) { + public List mapToPlayerNames(String target) { String[] split = target.split(DELIMITER); return Arrays.stream(split) .map(PlayerName::new) diff --git a/src/main/java/blackjack/view/InputView.java b/src/main/java/blackjack/view/InputView.java index 9025acdc90e..e4114141b81 100644 --- a/src/main/java/blackjack/view/InputView.java +++ b/src/main/java/blackjack/view/InputView.java @@ -1,20 +1,30 @@ package blackjack.view; +import blackjack.InputMapper; +import blackjack.domain.DrawDecision; +import blackjack.domain.player.PlayerName; +import java.util.List; import java.util.Scanner; public class InputView { private static final String LINE_SEPARATOR = System.lineSeparator(); + + private final InputMapper inputMapper; private final Scanner scanner = new Scanner(System.in); - public String readNames() { + public InputView(InputMapper inputMapper) { + this.inputMapper = inputMapper; + } + + public List readNames() { System.out.println("게임에 참여할 사람의 이름을 입력하세요.(쉼표 기준으로 분리)"); - return scanner.nextLine(); + return inputMapper.mapToPlayerNames(scanner.nextLine()); } - public String readDrawPlan(String name) { + public DrawDecision readDrawDecision(String name) { String message = String.format("%s는 한장의 카드를 더 받겠습니까?(예는 y, 아니오는 n)", name); System.out.println(String.join("", LINE_SEPARATOR, message)); - return scanner.nextLine(); + return inputMapper.mapToDrawDecision(scanner.nextLine()); } } From a4ac7f3f6e380100b923094dfebf69de034d0858 Mon Sep 17 00:00:00 2001 From: libienz Date: Tue, 12 Mar 2024 15:52:31 +0900 Subject: [PATCH 06/91] =?UTF-8?q?test:=20=ED=85=8C=EC=8A=A4=ED=8A=B8=20?= =?UTF-8?q?=EC=B9=B4=EB=93=9C=EB=8D=B1=20=EC=83=9D=EC=84=B1=20=ED=81=B4?= =?UTF-8?q?=EB=9E=98=EC=8A=A4=20=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../domain/card/TestCardDeckCreator.java | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 src/test/java/blackjack/domain/card/TestCardDeckCreator.java diff --git a/src/test/java/blackjack/domain/card/TestCardDeckCreator.java b/src/test/java/blackjack/domain/card/TestCardDeckCreator.java new file mode 100644 index 00000000000..bf66e1fd35c --- /dev/null +++ b/src/test/java/blackjack/domain/card/TestCardDeckCreator.java @@ -0,0 +1,16 @@ +package blackjack.domain.card; + +import java.util.Arrays; +import java.util.stream.Collectors; + +public class TestCardDeckCreator { + + private TestCardDeckCreator() { + } + + public static CardDeck createFrom(int... cards) { + return new CardDeck(Arrays.stream(cards) + .mapToObj(TestCardCreator::from) + .collect(Collectors.toList())); + } +} From 29e2ed41870594f14770e4aad51c30006c24a50f Mon Sep 17 00:00:00 2001 From: libienz Date: Tue, 12 Mar 2024 15:53:57 +0900 Subject: [PATCH 07/91] =?UTF-8?q?test:=20=ED=85=8C=EC=8A=A4=ED=8A=B8=20?= =?UTF-8?q?=EB=8D=B0=EC=9D=B4=ED=84=B0=20=ED=81=AC=EB=A6=AC=EC=97=90?= =?UTF-8?q?=EC=9D=B4=ED=84=B0=20=EC=83=9D=EC=84=B1=EC=9E=90=EB=A5=BC=20?= =?UTF-8?q?=EC=9D=B4=EC=9A=A9=ED=95=98=EC=A7=80=20=EB=AA=BB=ED=95=98?= =?UTF-8?q?=EB=8F=84=EB=A1=9D=20=EA=B0=9C=EC=84=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/test/java/blackjack/domain/card/TestCardCreator.java | 3 +++ src/test/java/blackjack/domain/player/TestHandCreator.java | 3 +++ src/test/java/blackjack/domain/player/TestPlayerCreator.java | 3 +++ 3 files changed, 9 insertions(+) diff --git a/src/test/java/blackjack/domain/card/TestCardCreator.java b/src/test/java/blackjack/domain/card/TestCardCreator.java index 50541eafffe..677f45952fb 100644 --- a/src/test/java/blackjack/domain/card/TestCardCreator.java +++ b/src/test/java/blackjack/domain/card/TestCardCreator.java @@ -6,6 +6,9 @@ public class TestCardCreator { + private TestCardCreator() { + } + public static Card from(int number) { CardNumber cardNumber = Arrays.stream(CardNumber.values()) .filter(cn -> cn.getValue() == number) diff --git a/src/test/java/blackjack/domain/player/TestHandCreator.java b/src/test/java/blackjack/domain/player/TestHandCreator.java index 8a4aeb229c2..147d30dfdad 100644 --- a/src/test/java/blackjack/domain/player/TestHandCreator.java +++ b/src/test/java/blackjack/domain/player/TestHandCreator.java @@ -6,6 +6,9 @@ public class TestHandCreator { + private TestHandCreator() { + } + public static Hand of(int... numbers) { return new Hand(Arrays.stream(numbers) .mapToObj(TestCardCreator::from) diff --git a/src/test/java/blackjack/domain/player/TestPlayerCreator.java b/src/test/java/blackjack/domain/player/TestPlayerCreator.java index 003bf10f2a3..48aa07f97ae 100644 --- a/src/test/java/blackjack/domain/player/TestPlayerCreator.java +++ b/src/test/java/blackjack/domain/player/TestPlayerCreator.java @@ -2,6 +2,9 @@ public class TestPlayerCreator { + private TestPlayerCreator() { + } + public static Player of(String name, int... hand) { return new Player(new PlayerName(name), TestHandCreator.of(hand)); } From 89a3f9720b3e27c07aa5c40e6ad1e1482d36766e Mon Sep 17 00:00:00 2001 From: libienz Date: Tue, 12 Mar 2024 15:56:27 +0900 Subject: [PATCH 08/91] =?UTF-8?q?feat:=20=EB=94=9C=EB=9F=AC=EC=9D=98=20?= =?UTF-8?q?=ED=8C=A8=EB=A5=BC=20=EC=99=84=EC=84=B1=EC=8B=9C=ED=82=A4?= =?UTF-8?q?=EB=8A=94=20=EA=B8=B0=EB=8A=A5=20Dealer=EB=8F=84=EB=A9=94?= =?UTF-8?q?=EC=9D=B8=EC=9C=BC=EB=A1=9C=20=EC=9D=B4=EC=A0=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/player/Dealer.java | 8 ++++++++ .../java/blackjack/domain/player/DealerTest.java | 12 ++++++++++++ 2 files changed, 20 insertions(+) diff --git a/src/main/java/blackjack/domain/player/Dealer.java b/src/main/java/blackjack/domain/player/Dealer.java index 56a536ead0e..72aca0fbce0 100644 --- a/src/main/java/blackjack/domain/player/Dealer.java +++ b/src/main/java/blackjack/domain/player/Dealer.java @@ -1,5 +1,7 @@ package blackjack.domain.player; +import blackjack.domain.card.CardDeck; + public class Dealer extends Participant { private static final String DEALER_NAME = "딜러"; @@ -13,4 +15,10 @@ public Dealer(Hand hand) { public boolean canHit() { return hand.calculateCardSummation() <= HIT_THRESHOLD; } + + public void completeHand(CardDeck cardDeck) { + while (canHit()) { + appendCard(cardDeck.popCard()); + } + } } diff --git a/src/test/java/blackjack/domain/player/DealerTest.java b/src/test/java/blackjack/domain/player/DealerTest.java index c4003d07c05..542521cb959 100644 --- a/src/test/java/blackjack/domain/player/DealerTest.java +++ b/src/test/java/blackjack/domain/player/DealerTest.java @@ -2,7 +2,10 @@ import static org.assertj.core.api.Assertions.assertThat; +import blackjack.domain.card.CardDeck; +import blackjack.domain.card.TestCardDeckCreator; import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.CsvSource; @@ -24,4 +27,13 @@ void testCanHit(int card1, int card2) { Dealer dealer = new Dealer(TestHandCreator.of(card1, card2)); assertThat(dealer.canHit()).isFalse(); } + + @DisplayName("히트 규칙을 기반으로 덱을 완성할 수 있다") + @Test + void testCompleteDealerHand() { + Dealer dealer = new Dealer(TestHandCreator.of(4, 3)); + CardDeck deck = TestCardDeckCreator.createFrom(9, 10, 5, 4, 3); + dealer.completeHand(deck); + assertThat(dealer.calculateHandScore().getValue()).isEqualTo(19); + } } From 816ac3730608ca76f0a9dcffd9bee37d0f58e424 Mon Sep 17 00:00:00 2001 From: libienz Date: Tue, 12 Mar 2024 16:16:14 +0900 Subject: [PATCH 09/91] =?UTF-8?q?refactor:=20=EB=A7=A4=EC=A7=81=EB=84=98?= =?UTF-8?q?=EB=B2=84=20=EA=B0=9C=EC=84=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/BlackJackGame.java | 2 +- src/main/java/blackjack/domain/player/Hand.java | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/blackjack/BlackJackGame.java b/src/main/java/blackjack/BlackJackGame.java index 1bd78ab8b19..5b912d68fb1 100644 --- a/src/main/java/blackjack/BlackJackGame.java +++ b/src/main/java/blackjack/BlackJackGame.java @@ -47,7 +47,7 @@ private Players initPlayers(CardDeck cardDeck) { } private void printPlayersInformation(Players players, Dealer dealer) { - outputView.printHandOutEvent(players, 2); + outputView.printHandOutEvent(players, Hand.INITIAL_HAND_SIZE); outputView.printDealerInitialHand(dealer); players.getPlayers().forEach(outputView::printPlayerHand); } diff --git a/src/main/java/blackjack/domain/player/Hand.java b/src/main/java/blackjack/domain/player/Hand.java index 6699b07f528..10cf71b44c7 100644 --- a/src/main/java/blackjack/domain/player/Hand.java +++ b/src/main/java/blackjack/domain/player/Hand.java @@ -8,7 +8,7 @@ public class Hand { - private static final int INITIAL_HAND_SIZE = 2; + public static final int INITIAL_HAND_SIZE = 2; private static final int BLACK_JACK = 21; private static final int ACE_WEIGHT = 10; From 40032f9e1bc6dbdd22c5b364d2b01f30ec7c8076 Mon Sep 17 00:00:00 2001 From: libienz Date: Tue, 12 Mar 2024 16:16:58 +0900 Subject: [PATCH 10/91] =?UTF-8?q?refactor:=20=EC=9D=B8=EB=9D=BC=EC=9D=B8?= =?UTF-8?q?=20=EA=B0=9C=EC=84=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/BlackJackGame.java | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/src/main/java/blackjack/BlackJackGame.java b/src/main/java/blackjack/BlackJackGame.java index 5b912d68fb1..f11254d978e 100644 --- a/src/main/java/blackjack/BlackJackGame.java +++ b/src/main/java/blackjack/BlackJackGame.java @@ -1,6 +1,5 @@ package blackjack; -import blackjack.domain.card.Card; import blackjack.domain.card.CardDeck; import blackjack.domain.player.Dealer; import blackjack.domain.player.Hand; @@ -65,8 +64,7 @@ private void completePlayerHand(Player participant, CardDeck cardDeck) { private void completeDealerHand(Dealer dealer, CardDeck cardDeck) { while (dealer.canHit()) { - Card card = cardDeck.popCard(); - dealer.appendCard(card); + dealer.appendCard(cardDeck.popCard()); } } From c897464f54ae946999d3e2b201bb0beaf8dc4ba5 Mon Sep 17 00:00:00 2001 From: libienz Date: Tue, 12 Mar 2024 16:24:01 +0900 Subject: [PATCH 11/91] =?UTF-8?q?refactor:=20=EB=8F=84=EB=A9=94=EC=9D=B8?= =?UTF-8?q?=EC=97=90=EA=B2=8C=20=EB=AC=BC=EC=96=B4=EB=B3=B4=EB=8F=84?= =?UTF-8?q?=EB=A1=9D=20=EA=B0=9C=EC=84=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/BlackJackGame.java | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/src/main/java/blackjack/BlackJackGame.java b/src/main/java/blackjack/BlackJackGame.java index f11254d978e..760a48e6196 100644 --- a/src/main/java/blackjack/BlackJackGame.java +++ b/src/main/java/blackjack/BlackJackGame.java @@ -29,7 +29,7 @@ public void run() { printPlayersInformation(players, dealer); completePlayersHand(players, cardDeck); - completeDealerHand(dealer, cardDeck); + dealer.completeHand(cardDeck); outputView.printDealerPopCount(Dealer.HIT_THRESHOLD, dealer.countDraw()); printParticipantScore(dealer); @@ -62,12 +62,6 @@ private void completePlayerHand(Player participant, CardDeck cardDeck) { } } - private void completeDealerHand(Dealer dealer, CardDeck cardDeck) { - while (dealer.canHit()) { - dealer.appendCard(cardDeck.popCard()); - } - } - private void printPlayersScore(Players players) { players.getPlayers().forEach(this::printParticipantScore); } From db48a375fb696704fb8f3a7f4137bffbd8a66dc7 Mon Sep 17 00:00:00 2001 From: libienz Date: Tue, 12 Mar 2024 16:38:16 +0900 Subject: [PATCH 12/91] =?UTF-8?q?docs:=20Step2=20=EA=B8=B0=EB=8A=A5=20?= =?UTF-8?q?=EA=B5=AC=ED=98=84=20=EB=AA=A9=EB=A1=9D=20=EC=9E=91=EC=84=B1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/README.md b/README.md index 5a33d0f5e30..7dc84119355 100644 --- a/README.md +++ b/README.md @@ -38,6 +38,11 @@ - [x] 카드덱에서 카드를 한 장 뽑아서 건네줄 수 있다. - [x] 카드덱에서 보유한 카드 개수보다 많이 뽑으면 예외가 발생한다. - [x] 참여자의 핸드에 초기 카드를 분배할 수 있다. + - [ ] 플레이어는 만원에서 30만원 사이의 금액을 베팅할 수 있다. + - [ ] 플레이어는 핸드를 완성시키는 단계에서 버스트 하면 금액을 모두 잃는다. + - [ ] 처음 두 장의 카드 합이 21이 되는 블랙잭일 경우 베팅 금액의 1.5배를 돌려받는다. + - [ ] 플레이어가 블랙잭이고 딜러도 블랙잭이면 플레이어는 베팅 금액을 그대로 돌려받는다. + - [ ] 플레이어가 딜러에게 승리하면 베팅 금액을 그대로 돌려받는다. - [x] 출력 - [x] 각 참여자의 카드 정보를 출력할 수 있다. - [x] 각 참여자의 카드 합을 출력할 수 있다. From dca030e25acf4aafb5a9ba6d28f4069bf8f61d2f Mon Sep 17 00:00:00 2001 From: libienz Date: Tue, 12 Mar 2024 16:41:07 +0900 Subject: [PATCH 13/91] =?UTF-8?q?style:=20Hand=20=EB=8F=84=EB=A9=94?= =?UTF-8?q?=EC=9D=B8=20=ED=8C=A8=ED=82=A4=EC=A7=80=20=EC=9D=B4=EB=8F=99?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/BlackJackGame.java | 2 +- src/main/java/blackjack/domain/{player => card}/Hand.java | 5 +---- src/main/java/blackjack/domain/player/Dealer.java | 1 + src/main/java/blackjack/domain/player/Participant.java | 1 + src/main/java/blackjack/domain/player/Player.java | 2 ++ src/main/java/blackjack/view/MessageResolver.java | 2 +- .../java/blackjack/domain/{player => card}/HandTest.java | 5 +---- .../blackjack/domain/{player => card}/TestHandCreator.java | 3 +-- src/test/java/blackjack/domain/player/DealerTest.java | 1 + src/test/java/blackjack/domain/player/PlayerTest.java | 1 + src/test/java/blackjack/domain/player/TestPlayerCreator.java | 2 ++ src/test/java/blackjack/domain/rule/JudgeTest.java | 2 +- 12 files changed, 14 insertions(+), 13 deletions(-) rename src/main/java/blackjack/domain/{player => card}/Hand.java (89%) rename src/test/java/blackjack/domain/{player => card}/HandTest.java (94%) rename src/test/java/blackjack/domain/{player => card}/TestHandCreator.java (80%) diff --git a/src/main/java/blackjack/BlackJackGame.java b/src/main/java/blackjack/BlackJackGame.java index 760a48e6196..757e387d626 100644 --- a/src/main/java/blackjack/BlackJackGame.java +++ b/src/main/java/blackjack/BlackJackGame.java @@ -1,8 +1,8 @@ package blackjack; import blackjack.domain.card.CardDeck; +import blackjack.domain.card.Hand; import blackjack.domain.player.Dealer; -import blackjack.domain.player.Hand; import blackjack.domain.player.Participant; import blackjack.domain.player.Player; import blackjack.domain.player.PlayerName; diff --git a/src/main/java/blackjack/domain/player/Hand.java b/src/main/java/blackjack/domain/card/Hand.java similarity index 89% rename from src/main/java/blackjack/domain/player/Hand.java rename to src/main/java/blackjack/domain/card/Hand.java index 10cf71b44c7..fa44a822e63 100644 --- a/src/main/java/blackjack/domain/player/Hand.java +++ b/src/main/java/blackjack/domain/card/Hand.java @@ -1,8 +1,5 @@ -package blackjack.domain.player; +package blackjack.domain.card; -import blackjack.domain.card.Card; -import blackjack.domain.card.CardDeck; -import blackjack.domain.card.CardNumber; import blackjack.domain.rule.Score; import java.util.List; diff --git a/src/main/java/blackjack/domain/player/Dealer.java b/src/main/java/blackjack/domain/player/Dealer.java index 72aca0fbce0..b8292a8dc4a 100644 --- a/src/main/java/blackjack/domain/player/Dealer.java +++ b/src/main/java/blackjack/domain/player/Dealer.java @@ -1,6 +1,7 @@ package blackjack.domain.player; import blackjack.domain.card.CardDeck; +import blackjack.domain.card.Hand; public class Dealer extends Participant { diff --git a/src/main/java/blackjack/domain/player/Participant.java b/src/main/java/blackjack/domain/player/Participant.java index 61c1d32dd36..4921279ef76 100644 --- a/src/main/java/blackjack/domain/player/Participant.java +++ b/src/main/java/blackjack/domain/player/Participant.java @@ -1,6 +1,7 @@ package blackjack.domain.player; import blackjack.domain.card.Card; +import blackjack.domain.card.Hand; import blackjack.domain.rule.Score; import java.util.Objects; diff --git a/src/main/java/blackjack/domain/player/Player.java b/src/main/java/blackjack/domain/player/Player.java index be9461db70e..9711b317b28 100644 --- a/src/main/java/blackjack/domain/player/Player.java +++ b/src/main/java/blackjack/domain/player/Player.java @@ -1,5 +1,7 @@ package blackjack.domain.player; +import blackjack.domain.card.Hand; + public class Player extends Participant { public static final int HIT_THRESHOLD = 21; diff --git a/src/main/java/blackjack/view/MessageResolver.java b/src/main/java/blackjack/view/MessageResolver.java index ed237db8a2c..3716c7ac3fd 100644 --- a/src/main/java/blackjack/view/MessageResolver.java +++ b/src/main/java/blackjack/view/MessageResolver.java @@ -7,8 +7,8 @@ import blackjack.domain.card.Card; import blackjack.domain.card.CardNumber; import blackjack.domain.card.CardShape; +import blackjack.domain.card.Hand; import blackjack.domain.player.Dealer; -import blackjack.domain.player.Hand; import blackjack.domain.player.Participant; import blackjack.domain.player.Player; import blackjack.domain.player.Players; diff --git a/src/test/java/blackjack/domain/player/HandTest.java b/src/test/java/blackjack/domain/card/HandTest.java similarity index 94% rename from src/test/java/blackjack/domain/player/HandTest.java rename to src/test/java/blackjack/domain/card/HandTest.java index 37c530eb52d..0c91e496e4e 100644 --- a/src/test/java/blackjack/domain/player/HandTest.java +++ b/src/test/java/blackjack/domain/card/HandTest.java @@ -1,10 +1,7 @@ -package blackjack.domain.player; +package blackjack.domain.card; import static org.assertj.core.api.Assertions.assertThat; -import blackjack.domain.card.Card; -import blackjack.domain.card.CardDeck; -import blackjack.domain.card.TestCardCreator; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; diff --git a/src/test/java/blackjack/domain/player/TestHandCreator.java b/src/test/java/blackjack/domain/card/TestHandCreator.java similarity index 80% rename from src/test/java/blackjack/domain/player/TestHandCreator.java rename to src/test/java/blackjack/domain/card/TestHandCreator.java index 147d30dfdad..ff070e6e694 100644 --- a/src/test/java/blackjack/domain/player/TestHandCreator.java +++ b/src/test/java/blackjack/domain/card/TestHandCreator.java @@ -1,6 +1,5 @@ -package blackjack.domain.player; +package blackjack.domain.card; -import blackjack.domain.card.TestCardCreator; import java.util.Arrays; import java.util.stream.Collectors; diff --git a/src/test/java/blackjack/domain/player/DealerTest.java b/src/test/java/blackjack/domain/player/DealerTest.java index 542521cb959..bd0d894087e 100644 --- a/src/test/java/blackjack/domain/player/DealerTest.java +++ b/src/test/java/blackjack/domain/player/DealerTest.java @@ -4,6 +4,7 @@ import blackjack.domain.card.CardDeck; import blackjack.domain.card.TestCardDeckCreator; +import blackjack.domain.card.TestHandCreator; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; diff --git a/src/test/java/blackjack/domain/player/PlayerTest.java b/src/test/java/blackjack/domain/player/PlayerTest.java index ef15046bcd1..0f4aba76fa9 100644 --- a/src/test/java/blackjack/domain/player/PlayerTest.java +++ b/src/test/java/blackjack/domain/player/PlayerTest.java @@ -2,6 +2,7 @@ import static org.assertj.core.api.Assertions.assertThat; +import blackjack.domain.card.TestHandCreator; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.CsvSource; diff --git a/src/test/java/blackjack/domain/player/TestPlayerCreator.java b/src/test/java/blackjack/domain/player/TestPlayerCreator.java index 48aa07f97ae..130762332e0 100644 --- a/src/test/java/blackjack/domain/player/TestPlayerCreator.java +++ b/src/test/java/blackjack/domain/player/TestPlayerCreator.java @@ -1,5 +1,7 @@ package blackjack.domain.player; +import blackjack.domain.card.TestHandCreator; + public class TestPlayerCreator { private TestPlayerCreator() { diff --git a/src/test/java/blackjack/domain/rule/JudgeTest.java b/src/test/java/blackjack/domain/rule/JudgeTest.java index fdf79a5e2db..88100a45f6e 100644 --- a/src/test/java/blackjack/domain/rule/JudgeTest.java +++ b/src/test/java/blackjack/domain/rule/JudgeTest.java @@ -4,10 +4,10 @@ import static org.junit.jupiter.api.Assertions.assertAll; import blackjack.domain.DealerGameResult; +import blackjack.domain.card.TestHandCreator; import blackjack.domain.player.Dealer; import blackjack.domain.player.Player; import blackjack.domain.player.Players; -import blackjack.domain.player.TestHandCreator; import blackjack.domain.player.TestPlayerCreator; import java.util.List; import org.junit.jupiter.api.BeforeEach; From 1f9bf86316d22a6f5786e5829fcafe5525e2b082 Mon Sep 17 00:00:00 2001 From: libienz Date: Tue, 12 Mar 2024 17:35:52 +0900 Subject: [PATCH 14/91] =?UTF-8?q?feat:=20=EC=B5=9C=EA=B3=A0=20=EC=A0=90?= =?UTF-8?q?=EC=88=98=EC=9D=B8=EC=A7=80=20=ED=99=95=EC=9D=B8=ED=95=98?= =?UTF-8?q?=EB=8A=94=20=EA=B8=B0=EB=8A=A5=20=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/rule/Score.java | 6 ++++++ src/test/java/blackjack/domain/rule/ScoreTest.java | 8 ++++++++ 2 files changed, 14 insertions(+) diff --git a/src/main/java/blackjack/domain/rule/Score.java b/src/main/java/blackjack/domain/rule/Score.java index 53ec0d43f21..63ecf2d28d3 100644 --- a/src/main/java/blackjack/domain/rule/Score.java +++ b/src/main/java/blackjack/domain/rule/Score.java @@ -2,6 +2,8 @@ public class Score { + private static final int MAX_SCORE = 21; + private final int value; public Score(int value) { @@ -12,6 +14,10 @@ public boolean isAbove(Score target) { return this.value > target.value; } + public boolean isMaxScore() { + return value == MAX_SCORE; + } + public int getValue() { return value; } diff --git a/src/test/java/blackjack/domain/rule/ScoreTest.java b/src/test/java/blackjack/domain/rule/ScoreTest.java index 25adcc506f3..5131ac61bab 100644 --- a/src/test/java/blackjack/domain/rule/ScoreTest.java +++ b/src/test/java/blackjack/domain/rule/ScoreTest.java @@ -3,6 +3,7 @@ import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.ValueSource; @@ -26,4 +27,11 @@ void testScoreCompareWithLower(int value) { Score target = new Score(value); assertThat(score.isAbove(target)).isTrue(); } + + @DisplayName("최고 점수(21)인지 확인할 수 있다") + @Test + void testIsMaxScore() { + Score score = new Score(21); + assertThat(score.isMaxScore()).isTrue(); + } } From 1c8c377b18c87a5a7e375989fe91d5c9dc543911 Mon Sep 17 00:00:00 2001 From: libienz Date: Tue, 12 Mar 2024 17:36:40 +0900 Subject: [PATCH 15/91] =?UTF-8?q?feat:=20=EC=86=90=ED=8C=A8=EA=B0=80=20?= =?UTF-8?q?=EB=B8=94=EB=9E=99=EC=9E=AD=EC=9D=B8=EC=A7=80=20=ED=99=95?= =?UTF-8?q?=EC=9D=B8=ED=95=98=EB=8A=94=20=EA=B8=B0=EB=8A=A5=20=EA=B5=AC?= =?UTF-8?q?=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/card/Hand.java | 12 ++++++++---- src/test/java/blackjack/domain/card/HandTest.java | 14 ++++++++++++++ 2 files changed, 22 insertions(+), 4 deletions(-) diff --git a/src/main/java/blackjack/domain/card/Hand.java b/src/main/java/blackjack/domain/card/Hand.java index fa44a822e63..2500f414126 100644 --- a/src/main/java/blackjack/domain/card/Hand.java +++ b/src/main/java/blackjack/domain/card/Hand.java @@ -6,7 +6,7 @@ public class Hand { public static final int INITIAL_HAND_SIZE = 2; - private static final int BLACK_JACK = 21; + private static final int BUST_THRESHOLD = 21; private static final int ACE_WEIGHT = 10; private final List cards; @@ -36,20 +36,24 @@ public int countAce() { .count(); } - public int countDraw() { - return cards.size() - INITIAL_HAND_SIZE; + public boolean isBlackJack() { + return calculateScore().isMaxScore() && cards.size() == INITIAL_HAND_SIZE; } public Score calculateScore() { int aceCount = countAce(); int sum = calculateCardSummation(); - while (aceCount > 0 && (sum + ACE_WEIGHT) <= BLACK_JACK) { + while (aceCount > 0 && (sum + ACE_WEIGHT) <= BUST_THRESHOLD) { sum += ACE_WEIGHT; aceCount--; } return new Score(sum); } + public int countDraw() { + return cards.size() - INITIAL_HAND_SIZE; + } + public List getCards() { return List.copyOf(cards); } diff --git a/src/test/java/blackjack/domain/card/HandTest.java b/src/test/java/blackjack/domain/card/HandTest.java index 0c91e496e4e..314a2f1d5f0 100644 --- a/src/test/java/blackjack/domain/card/HandTest.java +++ b/src/test/java/blackjack/domain/card/HandTest.java @@ -74,4 +74,18 @@ void testCalculateScoreWithMultipleAce() { Hand hand = TestHandCreator.of(1, 1, 1); assertThat(hand.calculateScore().getValue()).isEqualTo(13); } + + @DisplayName("손패가 블랙잭인지 알 수 있다") + @Test + void testIsBlackJack() { + Hand hand = TestHandCreator.of(1, 10); + assertThat(hand.isBlackJack()).isTrue(); + } + + @DisplayName("손패의 점수가 21이더라도 드로우 한 이력이 있으면 블랙잭이 아니다") + @Test + void testIsNotBlackJack() { + Hand hand = TestHandCreator.of(2, 9, 10); + assertThat(hand.isBlackJack()).isFalse(); + } } From a76e3db8d79bd0919854315529fbb33c0cf77160 Mon Sep 17 00:00:00 2001 From: libienz Date: Tue, 12 Mar 2024 17:37:32 +0900 Subject: [PATCH 16/91] =?UTF-8?q?feat:=20=EA=B2=8C=EC=9E=84=20=EC=B0=B8?= =?UTF-8?q?=EA=B0=80=EC=9E=90=EC=97=90=EA=B2=8C=20=EB=B8=94=EB=9E=99?= =?UTF-8?q?=EC=9E=AD=EC=9D=B8=EC=A7=80=20=ED=99=95=EC=9D=B8=ED=95=A0=20?= =?UTF-8?q?=EC=88=98=20=EC=9E=88=EB=8F=84=EB=A1=9D=20=EA=B8=B0=EB=8A=A5=20?= =?UTF-8?q?=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/player/Participant.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/main/java/blackjack/domain/player/Participant.java b/src/main/java/blackjack/domain/player/Participant.java index 4921279ef76..27df196f3c7 100644 --- a/src/main/java/blackjack/domain/player/Participant.java +++ b/src/main/java/blackjack/domain/player/Participant.java @@ -29,6 +29,10 @@ public int countDraw() { return hand.countDraw(); } + public boolean hasBlackJackHand() { + return hand.isBlackJack(); + } + @Override public boolean equals(Object o) { if (this == o) { From dd7530f709a075c0f8c6872742d849f35e5fb400 Mon Sep 17 00:00:00 2001 From: libienz Date: Tue, 12 Mar 2024 18:30:56 +0900 Subject: [PATCH 17/91] =?UTF-8?q?feat:=20Money=20=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 6 +-- src/main/java/blackjack/domain/bet/Money.java | 28 +++++++++++++ .../java/blackjack/domain/bet/MoneyTest.java | 39 +++++++++++++++++++ 3 files changed, 70 insertions(+), 3 deletions(-) create mode 100644 src/main/java/blackjack/domain/bet/Money.java create mode 100644 src/test/java/blackjack/domain/bet/MoneyTest.java diff --git a/README.md b/README.md index 7dc84119355..f37fb35c0e0 100644 --- a/README.md +++ b/README.md @@ -38,11 +38,11 @@ - [x] 카드덱에서 카드를 한 장 뽑아서 건네줄 수 있다. - [x] 카드덱에서 보유한 카드 개수보다 많이 뽑으면 예외가 발생한다. - [x] 참여자의 핸드에 초기 카드를 분배할 수 있다. - - [ ] 플레이어는 만원에서 30만원 사이의 금액을 베팅할 수 있다. + - [ ] 플레이어는 10억까지 베팅할 수 있다. - [ ] 플레이어는 핸드를 완성시키는 단계에서 버스트 하면 금액을 모두 잃는다. - - [ ] 처음 두 장의 카드 합이 21이 되는 블랙잭일 경우 베팅 금액의 1.5배를 돌려받는다. + - [ ] 처음 두 장의 카드 합이 21이 되는 블랙잭일 경우 베팅 금액의 1.5배를 추가로 얻는다. (소숫점 제거) - [ ] 플레이어가 블랙잭이고 딜러도 블랙잭이면 플레이어는 베팅 금액을 그대로 돌려받는다. - - [ ] 플레이어가 딜러에게 승리하면 베팅 금액을 그대로 돌려받는다. + - [ ] 플레이어가 딜러에게 승리하면 베팅 금액만큼을 추가로 얻는다. - [x] 출력 - [x] 각 참여자의 카드 정보를 출력할 수 있다. - [x] 각 참여자의 카드 합을 출력할 수 있다. diff --git a/src/main/java/blackjack/domain/bet/Money.java b/src/main/java/blackjack/domain/bet/Money.java new file mode 100644 index 00000000000..626a7967dbb --- /dev/null +++ b/src/main/java/blackjack/domain/bet/Money.java @@ -0,0 +1,28 @@ +package blackjack.domain.bet; + +public class Money { + + private static final int MAX = 1_000_000_000; + private static final int MIN = 0; + + private final int amount; + + public Money(int amount) { + validateRange(amount); + this.amount = amount; + } + + public void validateRange(int amount) { + if (amount < MIN || MAX < amount) { + throw new IllegalArgumentException("[ERROR] 금액은 " + MIN + "부터 " + MAX + "이하까지 가능합니다."); + } + } + + public Money multiply(double scope) { + return new Money((int) (amount * scope)); + } + + public int getAmount() { + return amount; + } +} diff --git a/src/test/java/blackjack/domain/bet/MoneyTest.java b/src/test/java/blackjack/domain/bet/MoneyTest.java new file mode 100644 index 00000000000..6940fc33fd4 --- /dev/null +++ b/src/test/java/blackjack/domain/bet/MoneyTest.java @@ -0,0 +1,39 @@ +package blackjack.domain.bet; + +import static org.assertj.core.api.Assertions.assertThatCode; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.assertj.core.api.AssertionsForClassTypes.assertThat; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +@DisplayName("돈 테스트") +class MoneyTest { + + @DisplayName("생성 시 범위를 지키지 못하면 생성 검증에 실패한다") + @ParameterizedTest + @ValueSource(ints = {-2, -1, 1_000_000_001}) + void testCreateMoneyWithInvalidRange(int amount) { + assertThatThrownBy(() -> new Money(amount)) + .isInstanceOf(IllegalArgumentException.class) + .hasMessage("[ERROR] 금액은 0부터 1000000000이하까지 가능합니다."); + } + + + @DisplayName("생성 검증을 통과하면 생성에 성공한다") + @ParameterizedTest + @ValueSource(ints = {0, 1000, 2000, 30000}) + void testCreateMoneyWithValidData(int amount) { + assertThatCode(() -> new Money(amount)) + .doesNotThrowAnyException(); + } + + @DisplayName("돈에 특정 배율을 적용한 결과를 알 수 있다") + @Test + void testMultiply() { + Money money = new Money(1000); + assertThat(money.multiply(1.5).getAmount()).isEqualTo(1500); + } +} From 5cbd135306536e724c581fb6b70c96318be209b4 Mon Sep 17 00:00:00 2001 From: libienz Date: Tue, 12 Mar 2024 18:37:45 +0900 Subject: [PATCH 18/91] =?UTF-8?q?feat:=20=EB=B2=A0=ED=8C=85=EC=A0=95?= =?UTF-8?q?=EB=B3=B4=20=EB=8F=84=EB=A9=94=EC=9D=B8=20=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/bet/Bet.java | 22 +++++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 src/main/java/blackjack/domain/bet/Bet.java diff --git a/src/main/java/blackjack/domain/bet/Bet.java b/src/main/java/blackjack/domain/bet/Bet.java new file mode 100644 index 00000000000..675dd3908fe --- /dev/null +++ b/src/main/java/blackjack/domain/bet/Bet.java @@ -0,0 +1,22 @@ +package blackjack.domain.bet; + +import blackjack.domain.player.PlayerName; + +public class Bet { + + private final PlayerName playerName; + private final Money betAmount; + + public Bet(PlayerName playerName, Money betAmount) { + this.playerName = playerName; + this.betAmount = betAmount; + } + + public PlayerName getPlayerName() { + return playerName; + } + + public Money getBetAmount() { + return betAmount; + } +} From 72e2d5c27b415f2f42997b842c2905ef4dc2a0ff Mon Sep 17 00:00:00 2001 From: libienz Date: Tue, 12 Mar 2024 18:59:11 +0900 Subject: [PATCH 19/91] =?UTF-8?q?refactor:=20=EB=A9=94=EC=84=9C=EB=93=9C?= =?UTF-8?q?=20=EB=B0=B0=EC=B9=98=20=EA=B0=9C=EC=84=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/bet/Money.java | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/main/java/blackjack/domain/bet/Money.java b/src/main/java/blackjack/domain/bet/Money.java index 626a7967dbb..56bf95aad4c 100644 --- a/src/main/java/blackjack/domain/bet/Money.java +++ b/src/main/java/blackjack/domain/bet/Money.java @@ -12,12 +12,6 @@ public Money(int amount) { this.amount = amount; } - public void validateRange(int amount) { - if (amount < MIN || MAX < amount) { - throw new IllegalArgumentException("[ERROR] 금액은 " + MIN + "부터 " + MAX + "이하까지 가능합니다."); - } - } - public Money multiply(double scope) { return new Money((int) (amount * scope)); } @@ -25,4 +19,10 @@ public Money multiply(double scope) { public int getAmount() { return amount; } + + public void validateRange(int amount) { + if (amount < MIN || MAX < amount) { + throw new IllegalArgumentException("[ERROR] 금액은 " + MIN + "부터 " + MAX + "이하까지 가능합니다."); + } + } } From 16eb547ac7f9f70a21ee358396fa44081728e28a Mon Sep 17 00:00:00 2001 From: libienz Date: Tue, 12 Mar 2024 20:00:26 +0900 Subject: [PATCH 20/91] =?UTF-8?q?feat:=20=EB=B2=A0=ED=8C=85=EA=B8=88?= =?UTF-8?q?=EC=97=90=20=EB=B0=B0=EC=9C=A8=20=EC=A0=81=EC=9A=A9=ED=95=98?= =?UTF-8?q?=EB=8A=94=20=EA=B8=B0=EB=8A=A5=20Bet=EC=97=90=20=EA=B5=AC?= =?UTF-8?q?=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/bet/Bet.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/main/java/blackjack/domain/bet/Bet.java b/src/main/java/blackjack/domain/bet/Bet.java index 675dd3908fe..ea14838e72f 100644 --- a/src/main/java/blackjack/domain/bet/Bet.java +++ b/src/main/java/blackjack/domain/bet/Bet.java @@ -12,6 +12,10 @@ public Bet(PlayerName playerName, Money betAmount) { this.betAmount = betAmount; } + public Money calculateMultipleMoneyOfBet(double scope) { + return betAmount.multiply(scope); + } + public PlayerName getPlayerName() { return playerName; } From f9ee5d36bf57ed73cffc00b4af9212d0e604dc2a Mon Sep 17 00:00:00 2001 From: libienz Date: Tue, 12 Mar 2024 20:01:46 +0900 Subject: [PATCH 21/91] =?UTF-8?q?feat:=20Bets=20=EC=86=8D=EC=84=B1=20?= =?UTF-8?q?=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/bet/Bets.java | 12 ++++++++++++ 1 file changed, 12 insertions(+) create mode 100644 src/main/java/blackjack/domain/bet/Bets.java diff --git a/src/main/java/blackjack/domain/bet/Bets.java b/src/main/java/blackjack/domain/bet/Bets.java new file mode 100644 index 00000000000..34d4b5394cd --- /dev/null +++ b/src/main/java/blackjack/domain/bet/Bets.java @@ -0,0 +1,12 @@ +package blackjack.domain.bet; + +import java.util.List; + +public class Bets { + + private final List bets; + + public Bets(List bets) { + this.bets = bets; + } +} From 700e6576cd2db196caf703da7dc6bdd7ddd191f8 Mon Sep 17 00:00:00 2001 From: libienz Date: Tue, 12 Mar 2024 20:10:30 +0900 Subject: [PATCH 22/91] =?UTF-8?q?feat:=20=EC=9E=85=EB=A0=A5=20=EC=A0=95?= =?UTF-8?q?=EB=B3=B4=EB=A1=9C=20Bet=20=EB=8F=84=EB=A9=94=EC=9D=B8=EC=9D=84?= =?UTF-8?q?=20=EB=A7=A4=ED=95=91=ED=95=B4=EC=A3=BC=EB=8A=94=20=EA=B8=B0?= =?UTF-8?q?=EB=8A=A5=20=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/InputMapper.java | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/main/java/blackjack/InputMapper.java b/src/main/java/blackjack/InputMapper.java index f108f887aae..d55bf075014 100644 --- a/src/main/java/blackjack/InputMapper.java +++ b/src/main/java/blackjack/InputMapper.java @@ -1,6 +1,8 @@ package blackjack; import blackjack.domain.DrawDecision; +import blackjack.domain.bet.Bet; +import blackjack.domain.bet.Money; import blackjack.domain.player.PlayerName; import java.util.Arrays; import java.util.List; @@ -19,4 +21,8 @@ public List mapToPlayerNames(String target) { public DrawDecision mapToDrawDecision(String target) { return DrawDecision.from(target); } + + public Bet mapToBet(String name, int betAmount) { + return new Bet(new PlayerName(name), new Money(betAmount)); + } } From a3b79222e6b4c52cd3b0cc2adf52ff7717dd485b Mon Sep 17 00:00:00 2001 From: libienz Date: Tue, 12 Mar 2024 20:10:49 +0900 Subject: [PATCH 23/91] =?UTF-8?q?feat:=20Bet=EB=8F=84=EB=A9=94=EC=9D=B8=20?= =?UTF-8?q?InputView=20=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/view/InputView.java | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/src/main/java/blackjack/view/InputView.java b/src/main/java/blackjack/view/InputView.java index e4114141b81..7b6029335cf 100644 --- a/src/main/java/blackjack/view/InputView.java +++ b/src/main/java/blackjack/view/InputView.java @@ -2,7 +2,11 @@ import blackjack.InputMapper; import blackjack.domain.DrawDecision; +import blackjack.domain.bet.Bet; +import blackjack.domain.bet.Bets; +import blackjack.domain.player.Player; import blackjack.domain.player.PlayerName; +import blackjack.domain.player.Players; import java.util.List; import java.util.Scanner; @@ -27,4 +31,16 @@ public DrawDecision readDrawDecision(String name) { System.out.println(String.join("", LINE_SEPARATOR, message)); return inputMapper.mapToDrawDecision(scanner.nextLine()); } + + public Bets readBets(Players players) { + return new Bets(players.getPlayers().stream() + .map(Player::getName) + .map(this::readBet) + .toList()); + } + + public Bet readBet(String playerName) { + System.out.println(String.format("%s의 배팅 금액은?", playerName)); + return inputMapper.mapToBet(playerName, scanner.nextInt()); + } } From 8cf986de37795848b527769c228e47d0ed858e4a Mon Sep 17 00:00:00 2001 From: libienz Date: Tue, 12 Mar 2024 20:27:27 +0900 Subject: [PATCH 24/91] =?UTF-8?q?feat:=20GameResult=20=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../blackjack/domain/rule/GameResult.java | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 src/main/java/blackjack/domain/rule/GameResult.java diff --git a/src/main/java/blackjack/domain/rule/GameResult.java b/src/main/java/blackjack/domain/rule/GameResult.java new file mode 100644 index 00000000000..ef182915059 --- /dev/null +++ b/src/main/java/blackjack/domain/rule/GameResult.java @@ -0,0 +1,19 @@ +package blackjack.domain.rule; + +public enum GameResult { + + BLACKJACK_WIN(1.5), + PLAYER_WIN(1.0), + PLAYER_LOSE(-1.0), + PUSH(0.0); + + private final double leverage; + + GameResult(double leverage) { + this.leverage = leverage; + } + + public double getLeverage() { + return leverage; + } +} From eb34b9402ed0b95c6ca295da0d306488e97161a2 Mon Sep 17 00:00:00 2001 From: libienz Date: Tue, 12 Mar 2024 20:47:25 +0900 Subject: [PATCH 25/91] =?UTF-8?q?feat:=20=EB=B2=A0=ED=8C=85=20=EC=A0=95?= =?UTF-8?q?=EB=B3=B4=20=EC=A1=B0=ED=9A=8C=EA=B8=B0=EB=8A=A5=20=EA=B5=AC?= =?UTF-8?q?=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/bet/Bet.java | 4 +-- src/main/java/blackjack/domain/bet/Bets.java | 7 ++++ .../java/blackjack/domain/bet/BetsTest.java | 36 +++++++++++++++++++ 3 files changed, 45 insertions(+), 2 deletions(-) create mode 100644 src/test/java/blackjack/domain/bet/BetsTest.java diff --git a/src/main/java/blackjack/domain/bet/Bet.java b/src/main/java/blackjack/domain/bet/Bet.java index ea14838e72f..c85963dab5d 100644 --- a/src/main/java/blackjack/domain/bet/Bet.java +++ b/src/main/java/blackjack/domain/bet/Bet.java @@ -16,8 +16,8 @@ public Money calculateMultipleMoneyOfBet(double scope) { return betAmount.multiply(scope); } - public PlayerName getPlayerName() { - return playerName; + public String getPlayerName() { + return playerName.getValue(); } public Money getBetAmount() { diff --git a/src/main/java/blackjack/domain/bet/Bets.java b/src/main/java/blackjack/domain/bet/Bets.java index 34d4b5394cd..2cf71aedb4e 100644 --- a/src/main/java/blackjack/domain/bet/Bets.java +++ b/src/main/java/blackjack/domain/bet/Bets.java @@ -9,4 +9,11 @@ public class Bets { public Bets(List bets) { this.bets = bets; } + + public Bet getBetByPlayerName(String playerName) { + return bets.stream() + .filter(bet -> bet.getPlayerName().equals(playerName)) + .findFirst() + .orElseThrow(() -> new IllegalArgumentException("[INTERNAL_ERROR] 해당 이름으로 등록된 베팅 정보를 찾을 수 없습니다")); + } } diff --git a/src/test/java/blackjack/domain/bet/BetsTest.java b/src/test/java/blackjack/domain/bet/BetsTest.java new file mode 100644 index 00000000000..970c809a0fb --- /dev/null +++ b/src/test/java/blackjack/domain/bet/BetsTest.java @@ -0,0 +1,36 @@ +package blackjack.domain.bet; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +import blackjack.domain.player.PlayerName; +import java.util.List; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +@DisplayName("베팅 정보들 도메인 테스트") +class BetsTest { + + @DisplayName("플레이어 이름으로 등록된 베팅정보를 찾아올 수 있다") + @Test + void testGetBetByPlayerName() { + Bet bet1 = new Bet(new PlayerName("리비"), new Money(1_000)); + Bet bet2 = new Bet(new PlayerName("썬"), new Money(1_000_000)); + Bets bets = new Bets(List.of(bet1, bet2)); + + Bet found = bets.getBetByPlayerName("리비"); + assertThat(found.getBetAmount().getAmount()).isEqualTo(1_000); + } + + @DisplayName("플레이어 이름으로 등록된 베팅정보를 찾을 수 없을 경우 예외를 발생시킨다") + @Test + void testFindBetWithInvalidPlayerName() { + Bet bet1 = new Bet(new PlayerName("리비"), new Money(1_000)); + Bet bet2 = new Bet(new PlayerName("썬"), new Money(1_000_000)); + Bets bets = new Bets(List.of(bet1, bet2)); + + assertThatThrownBy(() -> bets.getBetByPlayerName("제리")) + .isInstanceOf(IllegalArgumentException.class) + .hasMessage("[INTERNAL_ERROR] 해당 이름으로 등록된 베팅 정보를 찾을 수 없습니다"); + } +} From 830e8321d09e8f882600c70ff1a95f7b6c723d56 Mon Sep 17 00:00:00 2001 From: libienz Date: Wed, 13 Mar 2024 11:51:15 +0900 Subject: [PATCH 26/91] =?UTF-8?q?feat:=20Player=20=EA=B2=B0=EA=B3=BC=20?= =?UTF-8?q?=EB=8F=84=EB=A9=94=EC=9D=B8=20=EC=86=8D=EC=84=B1=20=EC=A0=95?= =?UTF-8?q?=EC=9D=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../blackjack/domain/rule/PlayerResult.java | 22 +++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 src/main/java/blackjack/domain/rule/PlayerResult.java diff --git a/src/main/java/blackjack/domain/rule/PlayerResult.java b/src/main/java/blackjack/domain/rule/PlayerResult.java new file mode 100644 index 00000000000..549cade04c8 --- /dev/null +++ b/src/main/java/blackjack/domain/rule/PlayerResult.java @@ -0,0 +1,22 @@ +package blackjack.domain.rule; + +import blackjack.domain.player.PlayerName; + +public class PlayerResult { + + private final PlayerName playerName; + private final GameResult gameResult; + + public PlayerResult(PlayerName playerName, GameResult gameResult) { + this.playerName = playerName; + this.gameResult = gameResult; + } + + public PlayerName getPlayerName() { + return playerName; + } + + public GameResult getGameResult() { + return gameResult; + } +} From a13b60e7ce52c596b4565a9c9c791875906a94d9 Mon Sep 17 00:00:00 2001 From: libienz Date: Wed, 13 Mar 2024 11:53:25 +0900 Subject: [PATCH 27/91] =?UTF-8?q?feat:=20PlayerResults=20=EC=86=8D?= =?UTF-8?q?=EC=84=B1=20=EC=A0=95=EC=9D=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../blackjack/domain/rule/PlayerResults.java | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 src/main/java/blackjack/domain/rule/PlayerResults.java diff --git a/src/main/java/blackjack/domain/rule/PlayerResults.java b/src/main/java/blackjack/domain/rule/PlayerResults.java new file mode 100644 index 00000000000..a6eeb28375d --- /dev/null +++ b/src/main/java/blackjack/domain/rule/PlayerResults.java @@ -0,0 +1,16 @@ +package blackjack.domain.rule; + +import java.util.List; + +public class PlayerResults { + + private final List results; + + public PlayerResults(List results) { + this.results = results; + } + + public List getResults() { + return results; + } +} From fd7732d8e9afb0a7a70464d6335eb7587962d6ef Mon Sep 17 00:00:00 2001 From: libienz Date: Wed, 13 Mar 2024 12:02:57 +0900 Subject: [PATCH 28/91] =?UTF-8?q?feat:=20=EC=A0=90=EC=88=98=EC=97=90?= =?UTF-8?q?=EA=B2=8C=20bust=20=EC=97=AC=EB=B6=80=20=EB=AC=BC=EC=96=B4?= =?UTF-8?q?=EB=B3=B4=EB=8A=94=20=EA=B8=B0=EB=8A=A5=20=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/rule/Score.java | 4 ++++ src/test/java/blackjack/domain/rule/ScoreTest.java | 8 ++++++++ 2 files changed, 12 insertions(+) diff --git a/src/main/java/blackjack/domain/rule/Score.java b/src/main/java/blackjack/domain/rule/Score.java index 63ecf2d28d3..b663ec3726b 100644 --- a/src/main/java/blackjack/domain/rule/Score.java +++ b/src/main/java/blackjack/domain/rule/Score.java @@ -18,6 +18,10 @@ public boolean isMaxScore() { return value == MAX_SCORE; } + public boolean isBustScore() { + return value > MAX_SCORE; + } + public int getValue() { return value; } diff --git a/src/test/java/blackjack/domain/rule/ScoreTest.java b/src/test/java/blackjack/domain/rule/ScoreTest.java index 5131ac61bab..1c2cad433f2 100644 --- a/src/test/java/blackjack/domain/rule/ScoreTest.java +++ b/src/test/java/blackjack/domain/rule/ScoreTest.java @@ -34,4 +34,12 @@ void testIsMaxScore() { Score score = new Score(21); assertThat(score.isMaxScore()).isTrue(); } + + @DisplayName("버스트 된 점수인지 확인할 수 있다") + @ParameterizedTest + @ValueSource(ints = {22, 23, 24, 25}) + void testIsBust(int scoreValue) { + Score score = new Score(scoreValue); + assertThat(score.isBustScore()).isTrue(); + } } From 6d4f7a14752e009133f39a8dcd3da98c195e756d Mon Sep 17 00:00:00 2001 From: libienz Date: Wed, 13 Mar 2024 12:04:35 +0900 Subject: [PATCH 29/91] =?UTF-8?q?feat:=20Bust=EB=90=98=EC=97=88=EB=8A=94?= =?UTF-8?q?=EC=A7=80=20=EC=B0=B8=EC=97=AC=EC=9E=90=20=EB=8F=84=EB=A9=94?= =?UTF-8?q?=EC=9D=B8=EC=97=90=20=EB=AC=BC=EC=96=B4=EB=B3=BC=20=EC=88=98=20?= =?UTF-8?q?=EC=9E=88=EB=8F=84=EB=A1=9D=20=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/player/Participant.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/main/java/blackjack/domain/player/Participant.java b/src/main/java/blackjack/domain/player/Participant.java index 27df196f3c7..09920b70493 100644 --- a/src/main/java/blackjack/domain/player/Participant.java +++ b/src/main/java/blackjack/domain/player/Participant.java @@ -29,6 +29,10 @@ public int countDraw() { return hand.countDraw(); } + public boolean isBusted() { + return hand.calculateScore().isBustScore(); + } + public boolean hasBlackJackHand() { return hand.isBlackJack(); } From 195e7d8c6e81bccfba2bfb0d0555e2e761dc0ed3 Mon Sep 17 00:00:00 2001 From: libienz Date: Wed, 13 Mar 2024 13:46:50 +0900 Subject: [PATCH 30/91] =?UTF-8?q?feat:=20Score=EB=8F=84=EB=A9=94=EC=9D=B8?= =?UTF-8?q?=20Equals,=20Hash=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/blackjack/domain/rule/Score.java | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/src/main/java/blackjack/domain/rule/Score.java b/src/main/java/blackjack/domain/rule/Score.java index b663ec3726b..c471570bdce 100644 --- a/src/main/java/blackjack/domain/rule/Score.java +++ b/src/main/java/blackjack/domain/rule/Score.java @@ -1,5 +1,7 @@ package blackjack.domain.rule; +import java.util.Objects; + public class Score { private static final int MAX_SCORE = 21; @@ -22,6 +24,23 @@ public boolean isBustScore() { return value > MAX_SCORE; } + @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); + } + public int getValue() { return value; } From 2a5b203c09bfa50af4a27867c800ba7684f3b662 Mon Sep 17 00:00:00 2001 From: libienz Date: Wed, 13 Mar 2024 14:06:01 +0900 Subject: [PATCH 31/91] =?UTF-8?q?refactor:=20PlayerResult=20=ED=95=84?= =?UTF-8?q?=EB=93=9C=20=ED=83=80=EC=9E=85=20=EA=B0=9C=EC=84=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/rule/PlayerResult.java | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/src/main/java/blackjack/domain/rule/PlayerResult.java b/src/main/java/blackjack/domain/rule/PlayerResult.java index 549cade04c8..8523a0a5caf 100644 --- a/src/main/java/blackjack/domain/rule/PlayerResult.java +++ b/src/main/java/blackjack/domain/rule/PlayerResult.java @@ -1,18 +1,16 @@ package blackjack.domain.rule; -import blackjack.domain.player.PlayerName; - public class PlayerResult { - private final PlayerName playerName; + private final String playerName; private final GameResult gameResult; - public PlayerResult(PlayerName playerName, GameResult gameResult) { + public PlayerResult(String playerName, GameResult gameResult) { this.playerName = playerName; this.gameResult = gameResult; } - public PlayerName getPlayerName() { + public String getPlayerName() { return playerName; } From 3fbb924fa48e573061026b28dbc3754ab99a89e7 Mon Sep 17 00:00:00 2001 From: libienz Date: Thu, 14 Mar 2024 10:34:41 +0900 Subject: [PATCH 32/91] =?UTF-8?q?feat:=20=ED=91=B8=EC=89=AC,=20=EB=B8=94?= =?UTF-8?q?=EB=9E=99=EC=9E=AD=20=EC=8A=B9=EB=A6=AC=20=EB=93=B1=20=EC=83=88?= =?UTF-8?q?=EB=A1=9C=EC=9A=B4=20=ED=8C=90=EC=A0=95=20=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/blackjack/domain/rule/Judge.java | 30 +++++++++++++ .../java/blackjack/domain/rule/JudgeTest.java | 44 +++++++++++++++++++ 2 files changed, 74 insertions(+) diff --git a/src/main/java/blackjack/domain/rule/Judge.java b/src/main/java/blackjack/domain/rule/Judge.java index 4bcf103ab14..c0b903bf398 100644 --- a/src/main/java/blackjack/domain/rule/Judge.java +++ b/src/main/java/blackjack/domain/rule/Judge.java @@ -1,5 +1,10 @@ package blackjack.domain.rule; +import static blackjack.domain.rule.GameResult.BLACKJACK_WIN; +import static blackjack.domain.rule.GameResult.PLAYER_LOSE; +import static blackjack.domain.rule.GameResult.PLAYER_WIN; +import static blackjack.domain.rule.GameResult.PUSH; + import blackjack.domain.DealerGameResult; import blackjack.domain.player.Dealer; import blackjack.domain.player.Player; @@ -28,4 +33,29 @@ public boolean isPlayerWin(Dealer dealer, Player player) { } return playerScore.isAbove(dealerScore); } + + public PlayerResults calculatePlayerResults(Dealer dealer, Players players) { + return new PlayerResults(players.getPlayers().stream() + .map(player -> new PlayerResult(player.getName(), calculatePlayerResult(dealer, player))) + .toList()); + } + + public GameResult calculatePlayerResult(Dealer dealer, Player player) { + Score playerScore = player.calculateHandScore(); + Score dealerScore = dealer.calculateHandScore(); + + if (player.hasBlackJackHand() && !dealer.hasBlackJackHand()) { + return BLACKJACK_WIN; + } + if (player.isBusted()) { + return PLAYER_LOSE; + } + if (dealer.isBusted() || playerScore.isAbove(dealerScore)) { + return PLAYER_WIN; + } + if (playerScore.equals(dealerScore)) { + return PUSH; + } + return PLAYER_LOSE; + } } diff --git a/src/test/java/blackjack/domain/rule/JudgeTest.java b/src/test/java/blackjack/domain/rule/JudgeTest.java index 88100a45f6e..493c4bc4698 100644 --- a/src/test/java/blackjack/domain/rule/JudgeTest.java +++ b/src/test/java/blackjack/domain/rule/JudgeTest.java @@ -1,5 +1,9 @@ package blackjack.domain.rule; +import static blackjack.domain.rule.GameResult.BLACKJACK_WIN; +import static blackjack.domain.rule.GameResult.PLAYER_LOSE; +import static blackjack.domain.rule.GameResult.PLAYER_WIN; +import static blackjack.domain.rule.GameResult.PUSH; import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.assertAll; @@ -31,6 +35,46 @@ void testSelectWinner() { assertThat(judge.isPlayerWin(dealer, player)).isFalse(); } + @DisplayName("플레이어 블랙잭이고 딜러가 블랙잭이 아니면 플레이어가 블랙잭 승리를 한다.") + @Test + void testPlayerBlackJackWin() { + Player player = TestPlayerCreator.of("리비", 1, 10); + Dealer dealer = new Dealer(TestHandCreator.of(3, 4)); + assertThat(judge.calculatePlayerResult(dealer, player)).isEqualTo(BLACKJACK_WIN); + } + + @DisplayName("딜러와 플레이어 모두 21점이더라도 블랙잭 핸드가 있다면 블랙잭쪽이 이긴다.") + @Test + void testPlayerBlackJackWinMaxScore() { + Player player = TestPlayerCreator.of("리비", 1, 10); + Dealer dealer = new Dealer(TestHandCreator.of(9, 2, 10)); + assertThat(judge.calculatePlayerResult(dealer, player)).isEqualTo(BLACKJACK_WIN); + } + + @DisplayName("딜러와 플레이어 모두 블랙잭인 경우 결과는 PUSH이다.") + @Test + void testPlayerAndDealerBlackJack() { + Player player = TestPlayerCreator.of("리비", 1, 10); + Dealer dealer = new Dealer(TestHandCreator.of(1, 10)); + assertThat(judge.calculatePlayerResult(dealer, player)).isEqualTo(PUSH); + } + + @DisplayName("딜러가 버스트 되고 플레이어가 살아있다면 플레이어가 승리한다") + @Test + void testPlayerWin() { + Player player = TestPlayerCreator.of("리비", 10, 10); + Dealer dealer = new Dealer(TestHandCreator.of(2, 10)); + assertThat(judge.calculatePlayerResult(dealer, player)).isEqualTo(PLAYER_WIN); + } + + @DisplayName("딜러 플레이어 모두 버스트 되지 않은 경우 딜러의 점수보다 플레이어의 점수가 낮다면 플레이어가 패한다") + @Test + void testPlayerLose() { + Player player = TestPlayerCreator.of("리비", 2, 10); + Dealer dealer = new Dealer(TestHandCreator.of(10, 10)); + assertThat(judge.calculatePlayerResult(dealer, player)).isEqualTo(PLAYER_LOSE); + } + @DisplayName("딜러의 전적을 계산할 수 있다") @Test void testCalculateDealerResult() { From 930b671a9bee88acdff2e2ea03f6c408a7c2bb5d Mon Sep 17 00:00:00 2001 From: libienz Date: Thu, 14 Mar 2024 10:45:38 +0900 Subject: [PATCH 33/91] =?UTF-8?q?feat:=20=EC=9D=B4=EB=A6=84=EC=9C=BC?= =?UTF-8?q?=EB=A1=9C=20=EA=B2=B0=EA=B3=BC=20=EC=A1=B0=ED=9A=8C=ED=95=98?= =?UTF-8?q?=EB=8A=94=20=EA=B8=B0=EB=8A=A5=20=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../blackjack/domain/rule/PlayerResults.java | 8 +++++++ .../domain/rule/PlayerResultsTest.java | 23 +++++++++++++++++++ 2 files changed, 31 insertions(+) create mode 100644 src/test/java/blackjack/domain/rule/PlayerResultsTest.java diff --git a/src/main/java/blackjack/domain/rule/PlayerResults.java b/src/main/java/blackjack/domain/rule/PlayerResults.java index a6eeb28375d..76ae943545d 100644 --- a/src/main/java/blackjack/domain/rule/PlayerResults.java +++ b/src/main/java/blackjack/domain/rule/PlayerResults.java @@ -10,6 +10,14 @@ public PlayerResults(List results) { this.results = results; } + public GameResult findResultByName(String name) { + return results.stream() + .filter(result -> result.getPlayerName().equals(name)) + .findFirst() + .map(PlayerResult::getGameResult) + .orElseThrow(() -> new IllegalArgumentException("[INTERNAL ERROR] 이름으로 결과를 조회하는데에 실패했습니다")); + } + public List getResults() { return results; } diff --git a/src/test/java/blackjack/domain/rule/PlayerResultsTest.java b/src/test/java/blackjack/domain/rule/PlayerResultsTest.java new file mode 100644 index 00000000000..169fff77f5e --- /dev/null +++ b/src/test/java/blackjack/domain/rule/PlayerResultsTest.java @@ -0,0 +1,23 @@ +package blackjack.domain.rule; + +import static blackjack.domain.rule.GameResult.PLAYER_LOSE; +import static blackjack.domain.rule.GameResult.PLAYER_WIN; +import static org.assertj.core.api.Assertions.assertThat; + +import java.util.List; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +@DisplayName("플레이어 결과 도메인 테스트") +class PlayerResultsTest { + + @DisplayName("이름으로 결과를 조회할 수 있다") + @Test + void testFindGameResultByName() { + PlayerResult playerResult1 = new PlayerResult("리비", PLAYER_WIN); + PlayerResult playerResult2 = new PlayerResult("리비", PLAYER_LOSE); + PlayerResults playerResults = new PlayerResults(List.of(playerResult1, playerResult2)); + + assertThat(playerResults.findResultByName("리비")).isEqualTo(PLAYER_WIN); + } +} From 45ad9d93c8f6b7f56faf8f917045168723a37897 Mon Sep 17 00:00:00 2001 From: libienz Date: Thu, 14 Mar 2024 10:59:09 +0900 Subject: [PATCH 34/91] =?UTF-8?q?feat:=20=EC=B0=B8=EC=97=AC=EC=9E=90=20?= =?UTF-8?q?=EC=9D=B4=EB=A6=84=20=EB=AA=A9=EB=A1=9D=20=EB=B0=98=ED=99=98?= =?UTF-8?q?=ED=95=98=EB=8A=94=20=EA=B8=B0=EB=8A=A5=20=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/player/Players.java | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/main/java/blackjack/domain/player/Players.java b/src/main/java/blackjack/domain/player/Players.java index e0c17514b52..e567e5da88f 100644 --- a/src/main/java/blackjack/domain/player/Players.java +++ b/src/main/java/blackjack/domain/player/Players.java @@ -25,6 +25,12 @@ public int countPlayerWithScoreAbove(Score target) { .count(); } + public List getPlayerNames() { + return players.stream() + .map(Player::getName) + .toList(); + } + private void validate(List participants) { validateEachPlayerNameUnique(participants); validateEntryNotEmpty(participants); From 9aa848566a6ec7cae0ab1a89ff9c3c9c1f3cc621 Mon Sep 17 00:00:00 2001 From: libienz Date: Thu, 14 Mar 2024 11:31:28 +0900 Subject: [PATCH 35/91] =?UTF-8?q?feat:=20=EB=B2=A0=ED=8C=85=20=EA=B2=B0?= =?UTF-8?q?=EA=B3=BC=20=EB=B7=B0=EB=A1=9C=EC=A7=81=20=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/view/InputView.java | 2 +- src/main/java/blackjack/view/MessageResolver.java | 6 ++++++ src/main/java/blackjack/view/OutputView.java | 5 +++++ 3 files changed, 12 insertions(+), 1 deletion(-) diff --git a/src/main/java/blackjack/view/InputView.java b/src/main/java/blackjack/view/InputView.java index 7b6029335cf..35507742ba7 100644 --- a/src/main/java/blackjack/view/InputView.java +++ b/src/main/java/blackjack/view/InputView.java @@ -41,6 +41,6 @@ public Bets readBets(Players players) { public Bet readBet(String playerName) { System.out.println(String.format("%s의 배팅 금액은?", playerName)); - return inputMapper.mapToBet(playerName, scanner.nextInt()); + return inputMapper.mapToBet(playerName, Integer.parseInt(scanner.nextLine())); } } diff --git a/src/main/java/blackjack/view/MessageResolver.java b/src/main/java/blackjack/view/MessageResolver.java index 3716c7ac3fd..aa495945ef5 100644 --- a/src/main/java/blackjack/view/MessageResolver.java +++ b/src/main/java/blackjack/view/MessageResolver.java @@ -12,6 +12,7 @@ import blackjack.domain.player.Participant; import blackjack.domain.player.Player; import blackjack.domain.player.Players; +import blackjack.domain.rule.BetResult; import blackjack.domain.rule.Score; import java.util.stream.Collectors; @@ -82,4 +83,9 @@ public String resolveDealerGameResult(DealerGameResult dealerGameResult) { String message = String.format("딜러: %d승 %d패", dealerGameResult.getWinCount(), dealerGameResult.getLoseCount()); return String.join("", prefix, LINE_SEPARATOR, message); } + + public String resolveBetResultMessage(BetResult betResult) { + return String.format("%s: %d", betResult.getName(), betResult.getEarned()); + } + } diff --git a/src/main/java/blackjack/view/OutputView.java b/src/main/java/blackjack/view/OutputView.java index 0048798f34c..d0737b9f502 100644 --- a/src/main/java/blackjack/view/OutputView.java +++ b/src/main/java/blackjack/view/OutputView.java @@ -5,6 +5,7 @@ import blackjack.domain.player.Participant; import blackjack.domain.player.Player; import blackjack.domain.player.Players; +import blackjack.domain.rule.BetResult; import blackjack.domain.rule.Score; public class OutputView { @@ -42,4 +43,8 @@ public void printDealerGameResult(DealerGameResult dealerGameResult) { public void printDealerInitialHand(Dealer dealer) { System.out.println(messageResolver.resolveDealerHandMessage(dealer)); } + + public void printBetResult(BetResult betResult) { + System.out.println(messageResolver.resolveBetResultMessage(betResult)); + } } From ac045c63215e0dfcd9f51812647304d6e53f92c4 Mon Sep 17 00:00:00 2001 From: libienz Date: Thu, 14 Mar 2024 11:32:15 +0900 Subject: [PATCH 36/91] =?UTF-8?q?feat:=20=EB=B2=A0=ED=8C=85=20=EA=B2=B0?= =?UTF-8?q?=EA=B3=BC=20=EA=B3=84=EC=82=B0=20=EA=B8=B0=EB=8A=A5=20=EA=B5=AC?= =?UTF-8?q?=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../blackjack/domain/bet/BettingBank.java | 12 ++++++++++ .../java/blackjack/domain/rule/BetResult.java | 22 +++++++++++++++++++ 2 files changed, 34 insertions(+) create mode 100644 src/main/java/blackjack/domain/bet/BettingBank.java create mode 100644 src/main/java/blackjack/domain/rule/BetResult.java diff --git a/src/main/java/blackjack/domain/bet/BettingBank.java b/src/main/java/blackjack/domain/bet/BettingBank.java new file mode 100644 index 00000000000..10489572c75 --- /dev/null +++ b/src/main/java/blackjack/domain/bet/BettingBank.java @@ -0,0 +1,12 @@ +package blackjack.domain.bet; + +import blackjack.domain.rule.BetResult; +import blackjack.domain.rule.GameResult; + +public class BettingBank { + + public BetResult calculateBetResult(Bet bet, GameResult gameResult) { + Money earned = bet.getBetAmount().multiply(gameResult.getLeverage()); + return new BetResult(bet.getPlayerName(), earned); + } +} diff --git a/src/main/java/blackjack/domain/rule/BetResult.java b/src/main/java/blackjack/domain/rule/BetResult.java new file mode 100644 index 00000000000..862fa5c2b4c --- /dev/null +++ b/src/main/java/blackjack/domain/rule/BetResult.java @@ -0,0 +1,22 @@ +package blackjack.domain.rule; + +import blackjack.domain.bet.Money; + +public class BetResult { + + private final String name; + private final Money earned; + + public BetResult(String name, Money earned) { + this.name = name; + this.earned = earned; + } + + public String getName() { + return name; + } + + public int getEarned() { + return earned.getAmount(); + } +} From c07d431987922f7a66e956003c25bb177f282fbc Mon Sep 17 00:00:00 2001 From: libienz Date: Thu, 14 Mar 2024 11:35:17 +0900 Subject: [PATCH 37/91] =?UTF-8?q?feat:=20Money=20=EB=8F=84=EB=A9=94?= =?UTF-8?q?=EC=9D=B8=20=ED=95=98=ED=95=9C=EA=B0=92=20=EC=9E=AC=EC=84=A4?= =?UTF-8?q?=EC=A0=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/bet/Money.java | 2 +- src/test/java/blackjack/domain/bet/MoneyTest.java | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/main/java/blackjack/domain/bet/Money.java b/src/main/java/blackjack/domain/bet/Money.java index 56bf95aad4c..76c65ce36ca 100644 --- a/src/main/java/blackjack/domain/bet/Money.java +++ b/src/main/java/blackjack/domain/bet/Money.java @@ -3,7 +3,7 @@ public class Money { private static final int MAX = 1_000_000_000; - private static final int MIN = 0; + private static final int MIN = -1_000_000_000; private final int amount; diff --git a/src/test/java/blackjack/domain/bet/MoneyTest.java b/src/test/java/blackjack/domain/bet/MoneyTest.java index 6940fc33fd4..3d6143b04e4 100644 --- a/src/test/java/blackjack/domain/bet/MoneyTest.java +++ b/src/test/java/blackjack/domain/bet/MoneyTest.java @@ -14,11 +14,11 @@ class MoneyTest { @DisplayName("생성 시 범위를 지키지 못하면 생성 검증에 실패한다") @ParameterizedTest - @ValueSource(ints = {-2, -1, 1_000_000_001}) + @ValueSource(ints = {-1_000_000_001, 1_000_000_001}) void testCreateMoneyWithInvalidRange(int amount) { assertThatThrownBy(() -> new Money(amount)) .isInstanceOf(IllegalArgumentException.class) - .hasMessage("[ERROR] 금액은 0부터 1000000000이하까지 가능합니다."); + .hasMessage("[ERROR] 금액은 -1000000000부터 1000000000이하까지 가능합니다."); } From 758dff6d9125e7242c2fcf980f1fc2610707474a Mon Sep 17 00:00:00 2001 From: libienz Date: Thu, 14 Mar 2024 11:35:55 +0900 Subject: [PATCH 38/91] =?UTF-8?q?feat:=20=EB=B8=94=EB=9E=99=EC=9E=AD=20?= =?UTF-8?q?=EA=B2=8C=EC=9E=84=EC=97=90=20=EB=B2=A0=ED=8C=85=20=EA=B8=88?= =?UTF-8?q?=EC=95=A1=20=EA=B4=80=EB=A0=A8=20=EC=9A=94=EA=B5=AC=EC=82=AC?= =?UTF-8?q?=ED=95=AD=20=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/BlackJackGame.java | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/src/main/java/blackjack/BlackJackGame.java b/src/main/java/blackjack/BlackJackGame.java index 757e387d626..98789223822 100644 --- a/src/main/java/blackjack/BlackJackGame.java +++ b/src/main/java/blackjack/BlackJackGame.java @@ -1,5 +1,8 @@ package blackjack; +import blackjack.domain.bet.Bet; +import blackjack.domain.bet.Bets; +import blackjack.domain.bet.BettingBank; import blackjack.domain.card.CardDeck; import blackjack.domain.card.Hand; import blackjack.domain.player.Dealer; @@ -7,7 +10,10 @@ import blackjack.domain.player.Player; import blackjack.domain.player.PlayerName; import blackjack.domain.player.Players; +import blackjack.domain.rule.BetResult; +import blackjack.domain.rule.GameResult; import blackjack.domain.rule.Judge; +import blackjack.domain.rule.PlayerResults; import blackjack.view.InputView; import blackjack.view.OutputView; import java.util.List; @@ -25,7 +31,9 @@ public BlackJackGame(InputView inputView, OutputView outputView) { public void run() { CardDeck cardDeck = CardDeck.createShuffledDeck(); Players players = initPlayers(cardDeck); + Bets bets = inputView.readBets(players); Dealer dealer = new Dealer(Hand.createHandFrom(cardDeck)); + Judge judge = new Judge(); printPlayersInformation(players, dealer); completePlayersHand(players, cardDeck); @@ -34,6 +42,18 @@ public void run() { printParticipantScore(dealer); printPlayersScore(players); + + PlayerResults playerResults = judge.calculatePlayerResults(dealer, players); + List playerNames = players.getPlayerNames(); + BettingBank bettingBank = new BettingBank(); + + for (String playerName : playerNames) { + Bet bet = bets.getBetByPlayerName(playerName); + GameResult gameResult = playerResults.findResultByName(playerName); + BetResult betResult = bettingBank.calculateBetResult(bet, gameResult); + outputView.printBetResult(betResult); + } + printDealerGameResult(dealer, players); printPlayersGameResult(players, dealer); } From fe10aa381bb3bafaed4abd7e47479142834d43c0 Mon Sep 17 00:00:00 2001 From: libienz Date: Thu, 14 Mar 2024 11:45:27 +0900 Subject: [PATCH 39/91] =?UTF-8?q?feat:=20=EB=8F=88=EC=97=90=20=EB=8F=88?= =?UTF-8?q?=EC=9D=84=20=EB=8D=94=ED=95=98=EB=8A=94=20=EA=B8=B0=EB=8A=A5=20?= =?UTF-8?q?=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/bet/Money.java | 4 ++++ src/test/java/blackjack/domain/bet/MoneyTest.java | 8 ++++++++ 2 files changed, 12 insertions(+) diff --git a/src/main/java/blackjack/domain/bet/Money.java b/src/main/java/blackjack/domain/bet/Money.java index 76c65ce36ca..5fc1577dac6 100644 --- a/src/main/java/blackjack/domain/bet/Money.java +++ b/src/main/java/blackjack/domain/bet/Money.java @@ -16,6 +16,10 @@ public Money multiply(double scope) { return new Money((int) (amount * scope)); } + public Money add(Money other) { + return new Money(amount + other.amount); + } + public int getAmount() { return amount; } diff --git a/src/test/java/blackjack/domain/bet/MoneyTest.java b/src/test/java/blackjack/domain/bet/MoneyTest.java index 3d6143b04e4..2ee1cbc12a4 100644 --- a/src/test/java/blackjack/domain/bet/MoneyTest.java +++ b/src/test/java/blackjack/domain/bet/MoneyTest.java @@ -36,4 +36,12 @@ void testMultiply() { Money money = new Money(1000); assertThat(money.multiply(1.5).getAmount()).isEqualTo(1500); } + + @DisplayName("돈에 돈을 더할 수 있다") + @Test + void testAddMoney() { + Money money = new Money(1000); + Money added = money.add(new Money(1000)); + assertThat(added.getAmount()).isEqualTo(2000); + } } From 5cb43317e94a53efcba6475c2c9ceeddd6974c47 Mon Sep 17 00:00:00 2001 From: libienz Date: Thu, 14 Mar 2024 11:58:55 +0900 Subject: [PATCH 40/91] =?UTF-8?q?feat:=20=EB=B2=A0=ED=8C=85=20=EA=B2=B0?= =?UTF-8?q?=EA=B3=BC=EB=A5=BC=20=EB=AA=A8=EC=95=84=EB=86=93=EC=9D=80=20?= =?UTF-8?q?=EB=8F=84=EB=A9=94=EC=9D=B8=20=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../blackjack/domain/rule/BetResults.java | 19 ++++++++++++++++ .../blackjack/domain/rule/BetResultsTest.java | 22 +++++++++++++++++++ 2 files changed, 41 insertions(+) create mode 100644 src/main/java/blackjack/domain/rule/BetResults.java create mode 100644 src/test/java/blackjack/domain/rule/BetResultsTest.java diff --git a/src/main/java/blackjack/domain/rule/BetResults.java b/src/main/java/blackjack/domain/rule/BetResults.java new file mode 100644 index 00000000000..daf3f650e66 --- /dev/null +++ b/src/main/java/blackjack/domain/rule/BetResults.java @@ -0,0 +1,19 @@ +package blackjack.domain.rule; + +import blackjack.domain.bet.Money; +import java.util.List; + +public class BetResults { + + private final List betResults; + + public BetResults(List betResults) { + this.betResults = betResults; + } + + public Money calculatePlayersEarned() { + return new Money(betResults.stream() + .map(BetResult::getEarned) + .reduce(0, Integer::sum)); + } +} diff --git a/src/test/java/blackjack/domain/rule/BetResultsTest.java b/src/test/java/blackjack/domain/rule/BetResultsTest.java new file mode 100644 index 00000000000..036a6132a6c --- /dev/null +++ b/src/test/java/blackjack/domain/rule/BetResultsTest.java @@ -0,0 +1,22 @@ +package blackjack.domain.rule; + +import static org.assertj.core.api.Assertions.assertThat; + +import blackjack.domain.bet.Money; +import java.util.List; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +@DisplayName("베팅 결과들 도메인 테스트") +class BetResultsTest { + + @DisplayName("플레이어 전체가 얼마의 수익을 냈는지 계산할 수 있다") + @Test + void testCalculatePalyersProfit() { + BetResult betResult1 = new BetResult("리비", new Money(10000)); + BetResult betResult2 = new BetResult("썬", new Money(20000)); + BetResults betResults = new BetResults(List.of(betResult1, betResult2)); + + assertThat(betResults.calculatePlayersEarned().getAmount()).isEqualTo(30000); + } +} From 8456dd769979fcbcb0748352baaffe97e64e12fb Mon Sep 17 00:00:00 2001 From: libienz Date: Thu, 14 Mar 2024 13:26:06 +0900 Subject: [PATCH 41/91] =?UTF-8?q?feat:=20BetResults=20=EA=B2=8C=ED=84=B0?= =?UTF-8?q?=20=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/rule/BetResults.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/main/java/blackjack/domain/rule/BetResults.java b/src/main/java/blackjack/domain/rule/BetResults.java index daf3f650e66..7a4d39a7735 100644 --- a/src/main/java/blackjack/domain/rule/BetResults.java +++ b/src/main/java/blackjack/domain/rule/BetResults.java @@ -16,4 +16,8 @@ public Money calculatePlayersEarned() { .map(BetResult::getEarned) .reduce(0, Integer::sum)); } + + public List getBetResults() { + return betResults; + } } From 638e4eb796c9b348f99ec951f7b96c6abb4523cc Mon Sep 17 00:00:00 2001 From: libienz Date: Thu, 14 Mar 2024 13:38:17 +0900 Subject: [PATCH 42/91] =?UTF-8?q?feat:=20Money=20=EB=B6=80=ED=98=B8=20?= =?UTF-8?q?=EB=B0=98=EC=A0=84=20=EC=97=B0=EC=82=B0=20=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/bet/Money.java | 4 ++++ src/test/java/blackjack/domain/bet/MoneyTest.java | 7 +++++++ 2 files changed, 11 insertions(+) diff --git a/src/main/java/blackjack/domain/bet/Money.java b/src/main/java/blackjack/domain/bet/Money.java index 5fc1577dac6..d71f0931275 100644 --- a/src/main/java/blackjack/domain/bet/Money.java +++ b/src/main/java/blackjack/domain/bet/Money.java @@ -20,6 +20,10 @@ public Money add(Money other) { return new Money(amount + other.amount); } + public Money inverse() { + return new Money(-1 * amount); + } + public int getAmount() { return amount; } diff --git a/src/test/java/blackjack/domain/bet/MoneyTest.java b/src/test/java/blackjack/domain/bet/MoneyTest.java index 2ee1cbc12a4..8036baaa182 100644 --- a/src/test/java/blackjack/domain/bet/MoneyTest.java +++ b/src/test/java/blackjack/domain/bet/MoneyTest.java @@ -44,4 +44,11 @@ void testAddMoney() { Money added = money.add(new Money(1000)); assertThat(added.getAmount()).isEqualTo(2000); } + + @DisplayName("부호를 반전한 돈을 계산할 수 있다") + @Test + void testInverseMoney() { + Money money = new Money(1000); + assertThat(money.inverse().getAmount()).isEqualTo(-1000); + } } From 89212efbf86c849b48eacb0163bfe0b144658e3c Mon Sep 17 00:00:00 2001 From: libienz Date: Thu, 14 Mar 2024 13:43:50 +0900 Subject: [PATCH 43/91] =?UTF-8?q?refactor:=20=EB=94=9C=EB=9F=AC=EA=B0=80?= =?UTF-8?q?=20=EC=96=BC=EB=A7=88=EC=9D=98=20=EC=88=98=EC=9D=B5=EC=9D=84=20?= =?UTF-8?q?=EB=83=88=EB=8A=94=EC=A7=80=20=EC=A7=81=EC=A0=91=20=EB=AC=BC?= =?UTF-8?q?=EC=96=B4=EB=B3=B4=EB=8F=84=EB=A1=9D=20=EC=88=98=EC=A0=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/rule/BetResults.java | 5 +++-- src/test/java/blackjack/domain/rule/BetResultsTest.java | 4 ++-- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/src/main/java/blackjack/domain/rule/BetResults.java b/src/main/java/blackjack/domain/rule/BetResults.java index 7a4d39a7735..3bb8530ee7f 100644 --- a/src/main/java/blackjack/domain/rule/BetResults.java +++ b/src/main/java/blackjack/domain/rule/BetResults.java @@ -11,10 +11,11 @@ public BetResults(List betResults) { this.betResults = betResults; } - public Money calculatePlayersEarned() { + public Money calculateDealerProfit() { return new Money(betResults.stream() .map(BetResult::getEarned) - .reduce(0, Integer::sum)); + .reduce(0, Integer::sum)) + .inverse(); } public List getBetResults() { diff --git a/src/test/java/blackjack/domain/rule/BetResultsTest.java b/src/test/java/blackjack/domain/rule/BetResultsTest.java index 036a6132a6c..3ddaa68249b 100644 --- a/src/test/java/blackjack/domain/rule/BetResultsTest.java +++ b/src/test/java/blackjack/domain/rule/BetResultsTest.java @@ -10,13 +10,13 @@ @DisplayName("베팅 결과들 도메인 테스트") class BetResultsTest { - @DisplayName("플레이어 전체가 얼마의 수익을 냈는지 계산할 수 있다") + @DisplayName("딜러가 얼마의 수익을 냈는지 계산할 수 있다") @Test void testCalculatePalyersProfit() { BetResult betResult1 = new BetResult("리비", new Money(10000)); BetResult betResult2 = new BetResult("썬", new Money(20000)); BetResults betResults = new BetResults(List.of(betResult1, betResult2)); - assertThat(betResults.calculatePlayersEarned().getAmount()).isEqualTo(30000); + assertThat(betResults.calculateDealerProfit().getAmount()).isEqualTo(-30000); } } From ae37ad21aaaa972824552d7df8c922bc9abfa007 Mon Sep 17 00:00:00 2001 From: libienz Date: Thu, 14 Mar 2024 13:44:07 +0900 Subject: [PATCH 44/91] =?UTF-8?q?feat:=20=EB=B2=A0=ED=8C=85=20=EA=B4=80?= =?UTF-8?q?=EB=A0=A8=20=EB=B7=B0=EB=A1=9C=EC=A7=81=20=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/view/MessageResolver.java | 12 ++++++++++++ src/main/java/blackjack/view/OutputView.java | 6 ++++++ 2 files changed, 18 insertions(+) diff --git a/src/main/java/blackjack/view/MessageResolver.java b/src/main/java/blackjack/view/MessageResolver.java index aa495945ef5..cb697659e3c 100644 --- a/src/main/java/blackjack/view/MessageResolver.java +++ b/src/main/java/blackjack/view/MessageResolver.java @@ -13,6 +13,7 @@ import blackjack.domain.player.Player; import blackjack.domain.player.Players; import blackjack.domain.rule.BetResult; +import blackjack.domain.rule.BetResults; import blackjack.domain.rule.Score; import java.util.stream.Collectors; @@ -87,5 +88,16 @@ public String resolveDealerGameResult(DealerGameResult dealerGameResult) { public String resolveBetResultMessage(BetResult betResult) { return String.format("%s: %d", betResult.getName(), betResult.getEarned()); } + + public String resolveBetResultsMessage(int dealerEarned, BetResults betResults) { + return new StringBuilder(resolveDealerProfitMessage(dealerEarned)) + .append(LINE_SEPARATOR) + .append(betResults.getBetResults().stream() + .map(this::resolveBetResultMessage) + .collect(Collectors.joining(LINE_SEPARATOR))).toString(); + } + public String resolveDealerProfitMessage(int dealerEarned) { + return String.format("딜러: %d", dealerEarned); + } } diff --git a/src/main/java/blackjack/view/OutputView.java b/src/main/java/blackjack/view/OutputView.java index d0737b9f502..9a3a6e06096 100644 --- a/src/main/java/blackjack/view/OutputView.java +++ b/src/main/java/blackjack/view/OutputView.java @@ -6,6 +6,7 @@ import blackjack.domain.player.Player; import blackjack.domain.player.Players; import blackjack.domain.rule.BetResult; +import blackjack.domain.rule.BetResults; import blackjack.domain.rule.Score; public class OutputView { @@ -44,7 +45,12 @@ public void printDealerInitialHand(Dealer dealer) { System.out.println(messageResolver.resolveDealerHandMessage(dealer)); } + public void printBetResults(int dealerEarned, BetResults betResults) { + System.out.println(messageResolver.resolveBetResultsMessage(dealerEarned, betResults)); + } + public void printBetResult(BetResult betResult) { System.out.println(messageResolver.resolveBetResultMessage(betResult)); } + } From 17149f14473f6c38217731eb3cf4183039051083 Mon Sep 17 00:00:00 2001 From: libienz Date: Thu, 14 Mar 2024 13:44:56 +0900 Subject: [PATCH 45/91] =?UTF-8?q?feat:=20=EB=B2=A0=ED=8C=85=20=EA=B2=B0?= =?UTF-8?q?=EA=B3=BC=EB=A5=BC=20=EB=B3=B4=EC=97=AC=EC=A3=BC=EB=8F=84?= =?UTF-8?q?=EB=A1=9D=20=EC=88=98=EC=A0=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 10 +++++----- src/main/java/blackjack/BlackJackGame.java | 19 +++++++++---------- 2 files changed, 14 insertions(+), 15 deletions(-) diff --git a/README.md b/README.md index f37fb35c0e0..09f7c164631 100644 --- a/README.md +++ b/README.md @@ -38,11 +38,11 @@ - [x] 카드덱에서 카드를 한 장 뽑아서 건네줄 수 있다. - [x] 카드덱에서 보유한 카드 개수보다 많이 뽑으면 예외가 발생한다. - [x] 참여자의 핸드에 초기 카드를 분배할 수 있다. - - [ ] 플레이어는 10억까지 베팅할 수 있다. - - [ ] 플레이어는 핸드를 완성시키는 단계에서 버스트 하면 금액을 모두 잃는다. - - [ ] 처음 두 장의 카드 합이 21이 되는 블랙잭일 경우 베팅 금액의 1.5배를 추가로 얻는다. (소숫점 제거) - - [ ] 플레이어가 블랙잭이고 딜러도 블랙잭이면 플레이어는 베팅 금액을 그대로 돌려받는다. - - [ ] 플레이어가 딜러에게 승리하면 베팅 금액만큼을 추가로 얻는다. + - [x] 플레이어는 10억까지 베팅할 수 있다. + - [x] 플레이어는 핸드를 완성시키는 단계에서 버스트 하면 금액을 모두 잃는다. + - [x] 처음 두 장의 카드 합이 21이 되는 블랙잭일 경우 베팅 금액의 1.5배를 추가로 얻는다. (소숫점 제거) + - [x] 플레이어가 블랙잭이고 딜러도 블랙잭이면 플레이어는 베팅 금액을 그대로 돌려받는다. + - [x] 플레이어가 딜러에게 승리하면 베팅 금액만큼을 추가로 얻는다. - [x] 출력 - [x] 각 참여자의 카드 정보를 출력할 수 있다. - [x] 각 참여자의 카드 합을 출력할 수 있다. diff --git a/src/main/java/blackjack/BlackJackGame.java b/src/main/java/blackjack/BlackJackGame.java index 98789223822..a9691d83813 100644 --- a/src/main/java/blackjack/BlackJackGame.java +++ b/src/main/java/blackjack/BlackJackGame.java @@ -1,6 +1,5 @@ package blackjack; -import blackjack.domain.bet.Bet; import blackjack.domain.bet.Bets; import blackjack.domain.bet.BettingBank; import blackjack.domain.card.CardDeck; @@ -10,8 +9,7 @@ import blackjack.domain.player.Player; import blackjack.domain.player.PlayerName; import blackjack.domain.player.Players; -import blackjack.domain.rule.BetResult; -import blackjack.domain.rule.GameResult; +import blackjack.domain.rule.BetResults; import blackjack.domain.rule.Judge; import blackjack.domain.rule.PlayerResults; import blackjack.view.InputView; @@ -47,15 +45,16 @@ public void run() { List playerNames = players.getPlayerNames(); BettingBank bettingBank = new BettingBank(); - for (String playerName : playerNames) { - Bet bet = bets.getBetByPlayerName(playerName); - GameResult gameResult = playerResults.findResultByName(playerName); - BetResult betResult = bettingBank.calculateBetResult(bet, gameResult); - outputView.printBetResult(betResult); - } - + BetResults betResults = new BetResults(playerNames.stream() + .map(playerName -> bettingBank.calculateBetResult( + bets.getBetByPlayerName(playerName), + playerResults.findResultByName(playerName))) + .toList()); printDealerGameResult(dealer, players); printPlayersGameResult(players, dealer); + + outputView.printBetResults(betResults.calculateDealerProfit().getAmount(), betResults); + } private Players initPlayers(CardDeck cardDeck) { From acc80aa161e5174f82df56dc5635f8eee2aa29dc Mon Sep 17 00:00:00 2001 From: libienz Date: Thu, 14 Mar 2024 15:15:23 +0900 Subject: [PATCH 46/91] =?UTF-8?q?refactor:=20=EC=82=AC=EC=9A=A9=ED=95=98?= =?UTF-8?q?=EC=A7=80=20=EC=95=8A=EB=8A=94=20=EB=A9=94=EC=84=9C=EB=93=9C=20?= =?UTF-8?q?=EC=A0=9C=EA=B1=B0=20=EA=B0=9C=EC=84=A0=20=EB=B0=8F=20=EB=B3=80?= =?UTF-8?q?=EC=88=98=EB=AA=85=20=EC=88=98=EC=A0=95=20=EA=B0=9C=EC=84=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/BlackJackGame.java | 17 +------------ src/main/java/blackjack/domain/bet/Bet.java | 4 --- src/main/java/blackjack/domain/bet/Bets.java | 2 +- .../java/blackjack/domain/rule/BetResult.java | 10 ++++---- .../blackjack/domain/rule/BetResults.java | 2 +- .../blackjack/domain/rule/PlayerResults.java | 4 --- .../java/blackjack/view/MessageResolver.java | 25 +++---------------- src/main/java/blackjack/view/OutputView.java | 9 ------- .../java/blackjack/domain/bet/BetsTest.java | 4 +-- 9 files changed, 14 insertions(+), 63 deletions(-) diff --git a/src/main/java/blackjack/BlackJackGame.java b/src/main/java/blackjack/BlackJackGame.java index a9691d83813..d82929d4200 100644 --- a/src/main/java/blackjack/BlackJackGame.java +++ b/src/main/java/blackjack/BlackJackGame.java @@ -47,14 +47,10 @@ public void run() { BetResults betResults = new BetResults(playerNames.stream() .map(playerName -> bettingBank.calculateBetResult( - bets.getBetByPlayerName(playerName), + bets.findBetByPlayerName(playerName), playerResults.findResultByName(playerName))) .toList()); - printDealerGameResult(dealer, players); - printPlayersGameResult(players, dealer); - outputView.printBetResults(betResults.calculateDealerProfit().getAmount(), betResults); - } private Players initPlayers(CardDeck cardDeck) { @@ -88,15 +84,4 @@ private void printPlayersScore(Players players) { private void printParticipantScore(Participant participant) { outputView.printParticipantScore(participant, participant.calculateHandScore()); } - - private void printDealerGameResult(Dealer dealer, Players players) { - Judge judge = new Judge(); - outputView.printDealerGameResult(judge.calculateDealerGameResult(dealer, players)); - } - - private void printPlayersGameResult(Players players, Dealer dealer) { - Judge judge = new Judge(); - players.getPlayers() - .forEach(player -> outputView.printPlayerGameResult(player, judge.isPlayerWin(dealer, player))); - } } diff --git a/src/main/java/blackjack/domain/bet/Bet.java b/src/main/java/blackjack/domain/bet/Bet.java index c85963dab5d..eaed3f54361 100644 --- a/src/main/java/blackjack/domain/bet/Bet.java +++ b/src/main/java/blackjack/domain/bet/Bet.java @@ -12,10 +12,6 @@ public Bet(PlayerName playerName, Money betAmount) { this.betAmount = betAmount; } - public Money calculateMultipleMoneyOfBet(double scope) { - return betAmount.multiply(scope); - } - public String getPlayerName() { return playerName.getValue(); } diff --git a/src/main/java/blackjack/domain/bet/Bets.java b/src/main/java/blackjack/domain/bet/Bets.java index 2cf71aedb4e..07f4ef81315 100644 --- a/src/main/java/blackjack/domain/bet/Bets.java +++ b/src/main/java/blackjack/domain/bet/Bets.java @@ -10,7 +10,7 @@ public Bets(List bets) { this.bets = bets; } - public Bet getBetByPlayerName(String playerName) { + public Bet findBetByPlayerName(String playerName) { return bets.stream() .filter(bet -> bet.getPlayerName().equals(playerName)) .findFirst() diff --git a/src/main/java/blackjack/domain/rule/BetResult.java b/src/main/java/blackjack/domain/rule/BetResult.java index 862fa5c2b4c..ad6a609787e 100644 --- a/src/main/java/blackjack/domain/rule/BetResult.java +++ b/src/main/java/blackjack/domain/rule/BetResult.java @@ -5,18 +5,18 @@ public class BetResult { private final String name; - private final Money earned; + private final Money profit; - public BetResult(String name, Money earned) { + public BetResult(String name, Money profit) { this.name = name; - this.earned = earned; + this.profit = profit; } public String getName() { return name; } - public int getEarned() { - return earned.getAmount(); + public int getProfit() { + return profit.getAmount(); } } diff --git a/src/main/java/blackjack/domain/rule/BetResults.java b/src/main/java/blackjack/domain/rule/BetResults.java index 3bb8530ee7f..fecd7b0834f 100644 --- a/src/main/java/blackjack/domain/rule/BetResults.java +++ b/src/main/java/blackjack/domain/rule/BetResults.java @@ -13,7 +13,7 @@ public BetResults(List betResults) { public Money calculateDealerProfit() { return new Money(betResults.stream() - .map(BetResult::getEarned) + .map(BetResult::getProfit) .reduce(0, Integer::sum)) .inverse(); } diff --git a/src/main/java/blackjack/domain/rule/PlayerResults.java b/src/main/java/blackjack/domain/rule/PlayerResults.java index 76ae943545d..d192a35facd 100644 --- a/src/main/java/blackjack/domain/rule/PlayerResults.java +++ b/src/main/java/blackjack/domain/rule/PlayerResults.java @@ -17,8 +17,4 @@ public GameResult findResultByName(String name) { .map(PlayerResult::getGameResult) .orElseThrow(() -> new IllegalArgumentException("[INTERNAL ERROR] 이름으로 결과를 조회하는데에 실패했습니다")); } - - public List getResults() { - return results; - } } diff --git a/src/main/java/blackjack/view/MessageResolver.java b/src/main/java/blackjack/view/MessageResolver.java index cb697659e3c..d8f9b3f499a 100644 --- a/src/main/java/blackjack/view/MessageResolver.java +++ b/src/main/java/blackjack/view/MessageResolver.java @@ -3,7 +3,6 @@ import static blackjack.view.CardDescription.NUMBER_NAME; import static blackjack.view.CardDescription.SHAPE_NAME; -import blackjack.domain.DealerGameResult; import blackjack.domain.card.Card; import blackjack.domain.card.CardNumber; import blackjack.domain.card.CardShape; @@ -68,35 +67,19 @@ public String resolveParticipantScoreMessage(Participant participant, Score scor return String.format("%s - 결과: %d", handMessage, score.getValue()); } - public String resolvePlayerGameResult(Player participant, boolean win) { - return String.format("%s: %s", participant.getName(), resolveGameResultMessage(win)); - } - - private String resolveGameResultMessage(boolean win) { - if (win) { - return "승"; - } - return "패"; - } - - public String resolveDealerGameResult(DealerGameResult dealerGameResult) { - String prefix = String.join("", LINE_SEPARATOR, "## 최종 승패"); - String message = String.format("딜러: %d승 %d패", dealerGameResult.getWinCount(), dealerGameResult.getLoseCount()); - return String.join("", prefix, LINE_SEPARATOR, message); - } - public String resolveBetResultMessage(BetResult betResult) { - return String.format("%s: %d", betResult.getName(), betResult.getEarned()); + return String.format("%s: %d", betResult.getName(), betResult.getProfit()); } public String resolveBetResultsMessage(int dealerEarned, BetResults betResults) { - return new StringBuilder(resolveDealerProfitMessage(dealerEarned)) + return new StringBuilder("##최종 수익") + .append(resolveDealerProfitMessage(dealerEarned)) .append(LINE_SEPARATOR) .append(betResults.getBetResults().stream() .map(this::resolveBetResultMessage) .collect(Collectors.joining(LINE_SEPARATOR))).toString(); } - + public String resolveDealerProfitMessage(int dealerEarned) { return String.format("딜러: %d", dealerEarned); } diff --git a/src/main/java/blackjack/view/OutputView.java b/src/main/java/blackjack/view/OutputView.java index 9a3a6e06096..5ea1133f8c3 100644 --- a/src/main/java/blackjack/view/OutputView.java +++ b/src/main/java/blackjack/view/OutputView.java @@ -1,6 +1,5 @@ package blackjack.view; -import blackjack.domain.DealerGameResult; import blackjack.domain.player.Dealer; import blackjack.domain.player.Participant; import blackjack.domain.player.Player; @@ -33,14 +32,6 @@ public void printParticipantScore(Participant participant, Score score) { System.out.println(messageResolver.resolveParticipantScoreMessage(participant, score)); } - public void printPlayerGameResult(Player participant, boolean win) { - System.out.println(messageResolver.resolvePlayerGameResult(participant, win)); - } - - public void printDealerGameResult(DealerGameResult dealerGameResult) { - System.out.println(messageResolver.resolveDealerGameResult(dealerGameResult)); - } - public void printDealerInitialHand(Dealer dealer) { System.out.println(messageResolver.resolveDealerHandMessage(dealer)); } diff --git a/src/test/java/blackjack/domain/bet/BetsTest.java b/src/test/java/blackjack/domain/bet/BetsTest.java index 970c809a0fb..20fafc1d176 100644 --- a/src/test/java/blackjack/domain/bet/BetsTest.java +++ b/src/test/java/blackjack/domain/bet/BetsTest.java @@ -18,7 +18,7 @@ void testGetBetByPlayerName() { Bet bet2 = new Bet(new PlayerName("썬"), new Money(1_000_000)); Bets bets = new Bets(List.of(bet1, bet2)); - Bet found = bets.getBetByPlayerName("리비"); + Bet found = bets.findBetByPlayerName("리비"); assertThat(found.getBetAmount().getAmount()).isEqualTo(1_000); } @@ -29,7 +29,7 @@ void testFindBetWithInvalidPlayerName() { Bet bet2 = new Bet(new PlayerName("썬"), new Money(1_000_000)); Bets bets = new Bets(List.of(bet1, bet2)); - assertThatThrownBy(() -> bets.getBetByPlayerName("제리")) + assertThatThrownBy(() -> bets.findBetByPlayerName("제리")) .isInstanceOf(IllegalArgumentException.class) .hasMessage("[INTERNAL_ERROR] 해당 이름으로 등록된 베팅 정보를 찾을 수 없습니다"); } From 78f92dbf8ce76e007d4b4a46c69c858a57c6249a Mon Sep 17 00:00:00 2001 From: libienz Date: Thu, 14 Mar 2024 15:16:54 +0900 Subject: [PATCH 47/91] =?UTF-8?q?fix:=20=EC=B6=9C=EB=A0=A5=20=EC=A4=84?= =?UTF-8?q?=EB=B0=94=EA=BF=88=20=ED=98=95=EC=8B=9D=20=EC=88=98=EC=A0=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/view/MessageResolver.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/main/java/blackjack/view/MessageResolver.java b/src/main/java/blackjack/view/MessageResolver.java index d8f9b3f499a..4abfd0816a1 100644 --- a/src/main/java/blackjack/view/MessageResolver.java +++ b/src/main/java/blackjack/view/MessageResolver.java @@ -72,7 +72,9 @@ public String resolveBetResultMessage(BetResult betResult) { } public String resolveBetResultsMessage(int dealerEarned, BetResults betResults) { - return new StringBuilder("##최종 수익") + return new StringBuilder(LINE_SEPARATOR) + .append("##최종 수익") + .append(LINE_SEPARATOR) .append(resolveDealerProfitMessage(dealerEarned)) .append(LINE_SEPARATOR) .append(betResults.getBetResults().stream() From 2108b798fa719fd51cc3399d7f3991f8d7a7b31f Mon Sep 17 00:00:00 2001 From: libienz Date: Thu, 14 Mar 2024 15:28:24 +0900 Subject: [PATCH 48/91] =?UTF-8?q?refactor:=20=EB=B2=A0=ED=8C=85=20?= =?UTF-8?q?=EA=B2=B0=EA=B3=BC=EB=A5=BC=20=EC=83=9D=EC=84=B1=ED=95=98?= =?UTF-8?q?=EB=8A=94=20=EC=B1=85=EC=9E=84=20Bet=EB=8F=84=EB=A9=94=EC=9D=B8?= =?UTF-8?q?=EC=9C=BC=EB=A1=9C=20=EC=9D=B4=EC=A0=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/BlackJackGame.java | 8 +++----- src/main/java/blackjack/domain/bet/Bet.java | 7 +++++++ .../java/blackjack/domain/bet/BettingBank.java | 12 ------------ .../java/blackjack/domain/rule/GameResult.java | 10 +++++----- .../java/blackjack/domain/bet/BetsTest.java | 17 +++++++++++++++++ 5 files changed, 32 insertions(+), 22 deletions(-) delete mode 100644 src/main/java/blackjack/domain/bet/BettingBank.java diff --git a/src/main/java/blackjack/BlackJackGame.java b/src/main/java/blackjack/BlackJackGame.java index d82929d4200..f78d538c329 100644 --- a/src/main/java/blackjack/BlackJackGame.java +++ b/src/main/java/blackjack/BlackJackGame.java @@ -1,7 +1,6 @@ package blackjack; import blackjack.domain.bet.Bets; -import blackjack.domain.bet.BettingBank; import blackjack.domain.card.CardDeck; import blackjack.domain.card.Hand; import blackjack.domain.player.Dealer; @@ -43,13 +42,12 @@ public void run() { PlayerResults playerResults = judge.calculatePlayerResults(dealer, players); List playerNames = players.getPlayerNames(); - BettingBank bettingBank = new BettingBank(); BetResults betResults = new BetResults(playerNames.stream() - .map(playerName -> bettingBank.calculateBetResult( - bets.findBetByPlayerName(playerName), - playerResults.findResultByName(playerName))) + .map(bets::findBetByPlayerName) + .map(bet -> bet.calculateBetResult(playerResults.findResultByName(bet.getPlayerName()))) .toList()); + outputView.printBetResults(betResults.calculateDealerProfit().getAmount(), betResults); } diff --git a/src/main/java/blackjack/domain/bet/Bet.java b/src/main/java/blackjack/domain/bet/Bet.java index eaed3f54361..e38cd47a3d3 100644 --- a/src/main/java/blackjack/domain/bet/Bet.java +++ b/src/main/java/blackjack/domain/bet/Bet.java @@ -1,6 +1,8 @@ package blackjack.domain.bet; import blackjack.domain.player.PlayerName; +import blackjack.domain.rule.BetResult; +import blackjack.domain.rule.GameResult; public class Bet { @@ -12,6 +14,11 @@ public Bet(PlayerName playerName, Money betAmount) { this.betAmount = betAmount; } + public BetResult calculateBetResult(GameResult gameResult) { + Money earned = betAmount.multiply(gameResult.getProfitLeverage()); + return new BetResult(playerName.getValue(), earned); + } + public String getPlayerName() { return playerName.getValue(); } diff --git a/src/main/java/blackjack/domain/bet/BettingBank.java b/src/main/java/blackjack/domain/bet/BettingBank.java deleted file mode 100644 index 10489572c75..00000000000 --- a/src/main/java/blackjack/domain/bet/BettingBank.java +++ /dev/null @@ -1,12 +0,0 @@ -package blackjack.domain.bet; - -import blackjack.domain.rule.BetResult; -import blackjack.domain.rule.GameResult; - -public class BettingBank { - - public BetResult calculateBetResult(Bet bet, GameResult gameResult) { - Money earned = bet.getBetAmount().multiply(gameResult.getLeverage()); - return new BetResult(bet.getPlayerName(), earned); - } -} diff --git a/src/main/java/blackjack/domain/rule/GameResult.java b/src/main/java/blackjack/domain/rule/GameResult.java index ef182915059..ee835ce0749 100644 --- a/src/main/java/blackjack/domain/rule/GameResult.java +++ b/src/main/java/blackjack/domain/rule/GameResult.java @@ -7,13 +7,13 @@ public enum GameResult { PLAYER_LOSE(-1.0), PUSH(0.0); - private final double leverage; + private final double profitLeverage; - GameResult(double leverage) { - this.leverage = leverage; + GameResult(double profitLeverage) { + this.profitLeverage = profitLeverage; } - public double getLeverage() { - return leverage; + public double getProfitLeverage() { + return profitLeverage; } } diff --git a/src/test/java/blackjack/domain/bet/BetsTest.java b/src/test/java/blackjack/domain/bet/BetsTest.java index 20fafc1d176..111eac4cee4 100644 --- a/src/test/java/blackjack/domain/bet/BetsTest.java +++ b/src/test/java/blackjack/domain/bet/BetsTest.java @@ -1,7 +1,12 @@ package blackjack.domain.bet; +import static blackjack.domain.rule.GameResult.BLACKJACK_WIN; +import static blackjack.domain.rule.GameResult.PLAYER_LOSE; +import static blackjack.domain.rule.GameResult.PLAYER_WIN; +import static blackjack.domain.rule.GameResult.PUSH; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.junit.jupiter.api.Assertions.assertAll; import blackjack.domain.player.PlayerName; import java.util.List; @@ -33,4 +38,16 @@ void testFindBetWithInvalidPlayerName() { .isInstanceOf(IllegalArgumentException.class) .hasMessage("[INTERNAL_ERROR] 해당 이름으로 등록된 베팅 정보를 찾을 수 없습니다"); } + + @DisplayName("게임 결과를 받아 베팅 결과를 생성해낼 수 있다") + @Test + void testCreateBetResult() { + Bet bet1 = new Bet(new PlayerName("리비"), new Money(1_000)); + assertAll( + () -> assertThat(bet1.calculateBetResult(PLAYER_WIN).getProfit()).isEqualTo(1_000), + () -> assertThat(bet1.calculateBetResult(BLACKJACK_WIN).getProfit()).isEqualTo(1_500), + () -> assertThat(bet1.calculateBetResult(PLAYER_LOSE).getProfit()).isEqualTo(-1_000), + () -> assertThat(bet1.calculateBetResult(PUSH).getProfit()).isEqualTo(0) + ); + } } From be5d84ddc1fa05664a237c28950812077d4aff11 Mon Sep 17 00:00:00 2001 From: libienz Date: Thu, 14 Mar 2024 15:32:07 +0900 Subject: [PATCH 49/91] =?UTF-8?q?refactor:=20=EC=82=AC=EC=9A=A9=ED=95=98?= =?UTF-8?q?=EC=A7=80=20=EC=95=8A=EB=8A=94=20=EB=A9=94=EC=84=9C=EB=93=9C=20?= =?UTF-8?q?=EC=A0=9C=EA=B1=B0=20=EA=B0=9C=EC=84=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/blackjack/domain/player/Players.java | 8 ------ .../java/blackjack/domain/rule/Judge.java | 23 ----------------- .../java/blackjack/domain/rule/JudgeTest.java | 25 ------------------- 3 files changed, 56 deletions(-) diff --git a/src/main/java/blackjack/domain/player/Players.java b/src/main/java/blackjack/domain/player/Players.java index e567e5da88f..e472e114f3b 100644 --- a/src/main/java/blackjack/domain/player/Players.java +++ b/src/main/java/blackjack/domain/player/Players.java @@ -1,6 +1,5 @@ package blackjack.domain.player; -import blackjack.domain.rule.Score; import java.util.List; public class Players { @@ -18,13 +17,6 @@ public int countPlayer() { return players.size(); } - public int countPlayerWithScoreAbove(Score target) { - return (int) players.stream() - .map(Participant::calculateHandScore) - .filter(playerScore -> playerScore.isAbove(target)) - .count(); - } - public List getPlayerNames() { return players.stream() .map(Player::getName) diff --git a/src/main/java/blackjack/domain/rule/Judge.java b/src/main/java/blackjack/domain/rule/Judge.java index c0b903bf398..782c70d4b78 100644 --- a/src/main/java/blackjack/domain/rule/Judge.java +++ b/src/main/java/blackjack/domain/rule/Judge.java @@ -5,35 +5,12 @@ import static blackjack.domain.rule.GameResult.PLAYER_WIN; import static blackjack.domain.rule.GameResult.PUSH; -import blackjack.domain.DealerGameResult; import blackjack.domain.player.Dealer; import blackjack.domain.player.Player; import blackjack.domain.player.Players; public class Judge { - private static final Score BLACK_JACK = new Score(21); - - public DealerGameResult calculateDealerGameResult(Dealer dealer, Players players) { - int playerWinCount = (int) players.getPlayers().stream() - .filter(player -> isPlayerWin(dealer, player)) - .count(); - int dealerWinCount = players.countPlayer() - playerWinCount; - return new DealerGameResult(dealerWinCount, playerWinCount); - } - - public boolean isPlayerWin(Dealer dealer, Player player) { - Score dealerScore = dealer.calculateHandScore(); - Score playerScore = player.calculateHandScore(); - if (playerScore.isAbove(BLACK_JACK)) { - return false; - } - if (dealerScore.isAbove(BLACK_JACK)) { - return true; - } - return playerScore.isAbove(dealerScore); - } - public PlayerResults calculatePlayerResults(Dealer dealer, Players players) { return new PlayerResults(players.getPlayers().stream() .map(player -> new PlayerResult(player.getName(), calculatePlayerResult(dealer, player))) diff --git a/src/test/java/blackjack/domain/rule/JudgeTest.java b/src/test/java/blackjack/domain/rule/JudgeTest.java index 493c4bc4698..e9e63c6fabf 100644 --- a/src/test/java/blackjack/domain/rule/JudgeTest.java +++ b/src/test/java/blackjack/domain/rule/JudgeTest.java @@ -5,15 +5,11 @@ import static blackjack.domain.rule.GameResult.PLAYER_WIN; import static blackjack.domain.rule.GameResult.PUSH; import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.jupiter.api.Assertions.assertAll; -import blackjack.domain.DealerGameResult; import blackjack.domain.card.TestHandCreator; import blackjack.domain.player.Dealer; import blackjack.domain.player.Player; -import blackjack.domain.player.Players; import blackjack.domain.player.TestPlayerCreator; -import java.util.List; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; @@ -27,14 +23,6 @@ void setUp() { judge = new Judge(); } - @DisplayName("딜러와 플레이어 중 누가 이겼는지 알 수 있다") - @Test - void testSelectWinner() { - Player player = TestPlayerCreator.of("리비", 2, 3); - Dealer dealer = new Dealer(TestHandCreator.of(3, 4)); - assertThat(judge.isPlayerWin(dealer, player)).isFalse(); - } - @DisplayName("플레이어 블랙잭이고 딜러가 블랙잭이 아니면 플레이어가 블랙잭 승리를 한다.") @Test void testPlayerBlackJackWin() { @@ -74,17 +62,4 @@ void testPlayerLose() { Dealer dealer = new Dealer(TestHandCreator.of(10, 10)); assertThat(judge.calculatePlayerResult(dealer, player)).isEqualTo(PLAYER_LOSE); } - - @DisplayName("딜러의 전적을 계산할 수 있다") - @Test - void testCalculateDealerResult() { - Player player = TestPlayerCreator.of("리비", 2, 3); - Dealer dealer = new Dealer(TestHandCreator.of(3, 4)); - Players players = new Players(List.of(player)); - DealerGameResult dealerGameResult = judge.calculateDealerGameResult(dealer, players); - assertAll( - () -> assertThat(dealerGameResult.getWinCount()).isEqualTo(1), - () -> assertThat(dealerGameResult.getLoseCount()).isEqualTo(0) - ); - } } From 31a49dfc84ce7a5a84241ec40c77decba7ead7a8 Mon Sep 17 00:00:00 2001 From: libienz Date: Thu, 14 Mar 2024 16:52:13 +0900 Subject: [PATCH 50/91] =?UTF-8?q?refactor:=20=EC=82=AC=EC=9A=A9=ED=95=98?= =?UTF-8?q?=EC=A7=80=20=EC=95=8A=EB=8A=94=20=ED=81=B4=EB=9E=98=EC=8A=A4=20?= =?UTF-8?q?=EC=A0=9C=EA=B1=B0=20=EA=B0=9C=EC=84=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../blackjack/domain/DealerGameResult.java | 20 ------------------- 1 file changed, 20 deletions(-) delete mode 100644 src/main/java/blackjack/domain/DealerGameResult.java diff --git a/src/main/java/blackjack/domain/DealerGameResult.java b/src/main/java/blackjack/domain/DealerGameResult.java deleted file mode 100644 index 6e0eae9731e..00000000000 --- a/src/main/java/blackjack/domain/DealerGameResult.java +++ /dev/null @@ -1,20 +0,0 @@ -package blackjack.domain; - -public class DealerGameResult { - - private final int winCount; - private final int loseCount; - - public DealerGameResult(int winCount, int loseCount) { - this.winCount = winCount; - this.loseCount = loseCount; - } - - public int getWinCount() { - return winCount; - } - - public int getLoseCount() { - return loseCount; - } -} From bf40b62b5645c0cce145846fcb1caae83aeae5c0 Mon Sep 17 00:00:00 2001 From: libienz Date: Thu, 14 Mar 2024 20:53:53 +0900 Subject: [PATCH 51/91] =?UTF-8?q?refactor:=20=ED=8C=A8=ED=82=A4=EC=A7=80?= =?UTF-8?q?=20=EB=AA=85=20=EC=88=98=EC=A0=95=20=EB=B0=8F=20=EA=B5=AC?= =?UTF-8?q?=EC=A1=B0=20=EA=B0=9C=EC=84=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/BlackJackGame.java | 6 +++--- .../java/blackjack/domain/{rule => }/Judge.java | 13 ++++++++----- .../java/blackjack/domain/{rule => }/Score.java | 2 +- src/main/java/blackjack/domain/bet/Bet.java | 4 ++-- src/main/java/blackjack/domain/card/Hand.java | 2 +- .../java/blackjack/domain/player/Participant.java | 2 +- .../domain/{rule => result}/BetResult.java | 2 +- .../domain/{rule => result}/BetResults.java | 2 +- .../domain/{rule => result}/GameResult.java | 2 +- .../domain/{rule => result}/PlayerResult.java | 2 +- .../domain/{rule => result}/PlayerResults.java | 2 +- src/main/java/blackjack/view/MessageResolver.java | 6 +++--- src/main/java/blackjack/view/OutputView.java | 6 +++--- .../java/blackjack/domain/{rule => }/JudgeTest.java | 10 +++++----- .../java/blackjack/domain/{rule => }/ScoreTest.java | 2 +- src/test/java/blackjack/domain/bet/BetsTest.java | 8 ++++---- .../domain/{rule => result}/BetResultsTest.java | 2 +- .../domain/{rule => result}/PlayerResultsTest.java | 6 +++--- 18 files changed, 41 insertions(+), 38 deletions(-) rename src/main/java/blackjack/domain/{rule => }/Judge.java (72%) rename src/main/java/blackjack/domain/{rule => }/Score.java (96%) rename src/main/java/blackjack/domain/{rule => result}/BetResult.java (91%) rename src/main/java/blackjack/domain/{rule => result}/BetResults.java (94%) rename src/main/java/blackjack/domain/{rule => result}/GameResult.java (90%) rename src/main/java/blackjack/domain/{rule => result}/PlayerResult.java (92%) rename src/main/java/blackjack/domain/{rule => result}/PlayerResults.java (94%) rename src/test/java/blackjack/domain/{rule => }/JudgeTest.java (90%) rename src/test/java/blackjack/domain/{rule => }/ScoreTest.java (97%) rename src/test/java/blackjack/domain/{rule => result}/BetResultsTest.java (95%) rename src/test/java/blackjack/domain/{rule => result}/PlayerResultsTest.java (81%) diff --git a/src/main/java/blackjack/BlackJackGame.java b/src/main/java/blackjack/BlackJackGame.java index f78d538c329..455f850caeb 100644 --- a/src/main/java/blackjack/BlackJackGame.java +++ b/src/main/java/blackjack/BlackJackGame.java @@ -1,5 +1,6 @@ package blackjack; +import blackjack.domain.Judge; import blackjack.domain.bet.Bets; import blackjack.domain.card.CardDeck; import blackjack.domain.card.Hand; @@ -8,9 +9,8 @@ import blackjack.domain.player.Player; import blackjack.domain.player.PlayerName; import blackjack.domain.player.Players; -import blackjack.domain.rule.BetResults; -import blackjack.domain.rule.Judge; -import blackjack.domain.rule.PlayerResults; +import blackjack.domain.result.BetResults; +import blackjack.domain.result.PlayerResults; import blackjack.view.InputView; import blackjack.view.OutputView; import java.util.List; diff --git a/src/main/java/blackjack/domain/rule/Judge.java b/src/main/java/blackjack/domain/Judge.java similarity index 72% rename from src/main/java/blackjack/domain/rule/Judge.java rename to src/main/java/blackjack/domain/Judge.java index 782c70d4b78..1b91f81b508 100644 --- a/src/main/java/blackjack/domain/rule/Judge.java +++ b/src/main/java/blackjack/domain/Judge.java @@ -1,13 +1,16 @@ -package blackjack.domain.rule; +package blackjack.domain; -import static blackjack.domain.rule.GameResult.BLACKJACK_WIN; -import static blackjack.domain.rule.GameResult.PLAYER_LOSE; -import static blackjack.domain.rule.GameResult.PLAYER_WIN; -import static blackjack.domain.rule.GameResult.PUSH; +import static blackjack.domain.result.GameResult.BLACKJACK_WIN; +import static blackjack.domain.result.GameResult.PLAYER_LOSE; +import static blackjack.domain.result.GameResult.PLAYER_WIN; +import static blackjack.domain.result.GameResult.PUSH; import blackjack.domain.player.Dealer; import blackjack.domain.player.Player; import blackjack.domain.player.Players; +import blackjack.domain.result.GameResult; +import blackjack.domain.result.PlayerResult; +import blackjack.domain.result.PlayerResults; public class Judge { diff --git a/src/main/java/blackjack/domain/rule/Score.java b/src/main/java/blackjack/domain/Score.java similarity index 96% rename from src/main/java/blackjack/domain/rule/Score.java rename to src/main/java/blackjack/domain/Score.java index c471570bdce..6197fa9e01f 100644 --- a/src/main/java/blackjack/domain/rule/Score.java +++ b/src/main/java/blackjack/domain/Score.java @@ -1,4 +1,4 @@ -package blackjack.domain.rule; +package blackjack.domain; import java.util.Objects; diff --git a/src/main/java/blackjack/domain/bet/Bet.java b/src/main/java/blackjack/domain/bet/Bet.java index e38cd47a3d3..8a5e1703810 100644 --- a/src/main/java/blackjack/domain/bet/Bet.java +++ b/src/main/java/blackjack/domain/bet/Bet.java @@ -1,8 +1,8 @@ package blackjack.domain.bet; import blackjack.domain.player.PlayerName; -import blackjack.domain.rule.BetResult; -import blackjack.domain.rule.GameResult; +import blackjack.domain.result.BetResult; +import blackjack.domain.result.GameResult; public class Bet { diff --git a/src/main/java/blackjack/domain/card/Hand.java b/src/main/java/blackjack/domain/card/Hand.java index 2500f414126..c59798b6119 100644 --- a/src/main/java/blackjack/domain/card/Hand.java +++ b/src/main/java/blackjack/domain/card/Hand.java @@ -1,6 +1,6 @@ package blackjack.domain.card; -import blackjack.domain.rule.Score; +import blackjack.domain.Score; import java.util.List; public class Hand { diff --git a/src/main/java/blackjack/domain/player/Participant.java b/src/main/java/blackjack/domain/player/Participant.java index 09920b70493..39a4f8f5bbc 100644 --- a/src/main/java/blackjack/domain/player/Participant.java +++ b/src/main/java/blackjack/domain/player/Participant.java @@ -1,8 +1,8 @@ package blackjack.domain.player; +import blackjack.domain.Score; import blackjack.domain.card.Card; import blackjack.domain.card.Hand; -import blackjack.domain.rule.Score; import java.util.Objects; public abstract class Participant { diff --git a/src/main/java/blackjack/domain/rule/BetResult.java b/src/main/java/blackjack/domain/result/BetResult.java similarity index 91% rename from src/main/java/blackjack/domain/rule/BetResult.java rename to src/main/java/blackjack/domain/result/BetResult.java index ad6a609787e..7d6f0c4604e 100644 --- a/src/main/java/blackjack/domain/rule/BetResult.java +++ b/src/main/java/blackjack/domain/result/BetResult.java @@ -1,4 +1,4 @@ -package blackjack.domain.rule; +package blackjack.domain.result; import blackjack.domain.bet.Money; diff --git a/src/main/java/blackjack/domain/rule/BetResults.java b/src/main/java/blackjack/domain/result/BetResults.java similarity index 94% rename from src/main/java/blackjack/domain/rule/BetResults.java rename to src/main/java/blackjack/domain/result/BetResults.java index fecd7b0834f..2d71b79dfc6 100644 --- a/src/main/java/blackjack/domain/rule/BetResults.java +++ b/src/main/java/blackjack/domain/result/BetResults.java @@ -1,4 +1,4 @@ -package blackjack.domain.rule; +package blackjack.domain.result; import blackjack.domain.bet.Money; import java.util.List; diff --git a/src/main/java/blackjack/domain/rule/GameResult.java b/src/main/java/blackjack/domain/result/GameResult.java similarity index 90% rename from src/main/java/blackjack/domain/rule/GameResult.java rename to src/main/java/blackjack/domain/result/GameResult.java index ee835ce0749..44471d6a9f5 100644 --- a/src/main/java/blackjack/domain/rule/GameResult.java +++ b/src/main/java/blackjack/domain/result/GameResult.java @@ -1,4 +1,4 @@ -package blackjack.domain.rule; +package blackjack.domain.result; public enum GameResult { diff --git a/src/main/java/blackjack/domain/rule/PlayerResult.java b/src/main/java/blackjack/domain/result/PlayerResult.java similarity index 92% rename from src/main/java/blackjack/domain/rule/PlayerResult.java rename to src/main/java/blackjack/domain/result/PlayerResult.java index 8523a0a5caf..cab2a38c74f 100644 --- a/src/main/java/blackjack/domain/rule/PlayerResult.java +++ b/src/main/java/blackjack/domain/result/PlayerResult.java @@ -1,4 +1,4 @@ -package blackjack.domain.rule; +package blackjack.domain.result; public class PlayerResult { diff --git a/src/main/java/blackjack/domain/rule/PlayerResults.java b/src/main/java/blackjack/domain/result/PlayerResults.java similarity index 94% rename from src/main/java/blackjack/domain/rule/PlayerResults.java rename to src/main/java/blackjack/domain/result/PlayerResults.java index d192a35facd..1e3e1e48eff 100644 --- a/src/main/java/blackjack/domain/rule/PlayerResults.java +++ b/src/main/java/blackjack/domain/result/PlayerResults.java @@ -1,4 +1,4 @@ -package blackjack.domain.rule; +package blackjack.domain.result; import java.util.List; diff --git a/src/main/java/blackjack/view/MessageResolver.java b/src/main/java/blackjack/view/MessageResolver.java index 4abfd0816a1..fa0be756c66 100644 --- a/src/main/java/blackjack/view/MessageResolver.java +++ b/src/main/java/blackjack/view/MessageResolver.java @@ -3,6 +3,7 @@ import static blackjack.view.CardDescription.NUMBER_NAME; import static blackjack.view.CardDescription.SHAPE_NAME; +import blackjack.domain.Score; import blackjack.domain.card.Card; import blackjack.domain.card.CardNumber; import blackjack.domain.card.CardShape; @@ -11,9 +12,8 @@ import blackjack.domain.player.Participant; import blackjack.domain.player.Player; import blackjack.domain.player.Players; -import blackjack.domain.rule.BetResult; -import blackjack.domain.rule.BetResults; -import blackjack.domain.rule.Score; +import blackjack.domain.result.BetResult; +import blackjack.domain.result.BetResults; import java.util.stream.Collectors; public class MessageResolver { diff --git a/src/main/java/blackjack/view/OutputView.java b/src/main/java/blackjack/view/OutputView.java index 5ea1133f8c3..c4265ca38b7 100644 --- a/src/main/java/blackjack/view/OutputView.java +++ b/src/main/java/blackjack/view/OutputView.java @@ -1,12 +1,12 @@ package blackjack.view; +import blackjack.domain.Score; import blackjack.domain.player.Dealer; import blackjack.domain.player.Participant; import blackjack.domain.player.Player; import blackjack.domain.player.Players; -import blackjack.domain.rule.BetResult; -import blackjack.domain.rule.BetResults; -import blackjack.domain.rule.Score; +import blackjack.domain.result.BetResult; +import blackjack.domain.result.BetResults; public class OutputView { diff --git a/src/test/java/blackjack/domain/rule/JudgeTest.java b/src/test/java/blackjack/domain/JudgeTest.java similarity index 90% rename from src/test/java/blackjack/domain/rule/JudgeTest.java rename to src/test/java/blackjack/domain/JudgeTest.java index e9e63c6fabf..9ebc404ccab 100644 --- a/src/test/java/blackjack/domain/rule/JudgeTest.java +++ b/src/test/java/blackjack/domain/JudgeTest.java @@ -1,9 +1,9 @@ -package blackjack.domain.rule; +package blackjack.domain; -import static blackjack.domain.rule.GameResult.BLACKJACK_WIN; -import static blackjack.domain.rule.GameResult.PLAYER_LOSE; -import static blackjack.domain.rule.GameResult.PLAYER_WIN; -import static blackjack.domain.rule.GameResult.PUSH; +import static blackjack.domain.result.GameResult.BLACKJACK_WIN; +import static blackjack.domain.result.GameResult.PLAYER_LOSE; +import static blackjack.domain.result.GameResult.PLAYER_WIN; +import static blackjack.domain.result.GameResult.PUSH; import static org.assertj.core.api.Assertions.assertThat; import blackjack.domain.card.TestHandCreator; diff --git a/src/test/java/blackjack/domain/rule/ScoreTest.java b/src/test/java/blackjack/domain/ScoreTest.java similarity index 97% rename from src/test/java/blackjack/domain/rule/ScoreTest.java rename to src/test/java/blackjack/domain/ScoreTest.java index 1c2cad433f2..90a39b3650c 100644 --- a/src/test/java/blackjack/domain/rule/ScoreTest.java +++ b/src/test/java/blackjack/domain/ScoreTest.java @@ -1,4 +1,4 @@ -package blackjack.domain.rule; +package blackjack.domain; import static org.assertj.core.api.Assertions.assertThat; diff --git a/src/test/java/blackjack/domain/bet/BetsTest.java b/src/test/java/blackjack/domain/bet/BetsTest.java index 111eac4cee4..1913ddde4c6 100644 --- a/src/test/java/blackjack/domain/bet/BetsTest.java +++ b/src/test/java/blackjack/domain/bet/BetsTest.java @@ -1,9 +1,9 @@ package blackjack.domain.bet; -import static blackjack.domain.rule.GameResult.BLACKJACK_WIN; -import static blackjack.domain.rule.GameResult.PLAYER_LOSE; -import static blackjack.domain.rule.GameResult.PLAYER_WIN; -import static blackjack.domain.rule.GameResult.PUSH; +import static blackjack.domain.result.GameResult.BLACKJACK_WIN; +import static blackjack.domain.result.GameResult.PLAYER_LOSE; +import static blackjack.domain.result.GameResult.PLAYER_WIN; +import static blackjack.domain.result.GameResult.PUSH; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.junit.jupiter.api.Assertions.assertAll; diff --git a/src/test/java/blackjack/domain/rule/BetResultsTest.java b/src/test/java/blackjack/domain/result/BetResultsTest.java similarity index 95% rename from src/test/java/blackjack/domain/rule/BetResultsTest.java rename to src/test/java/blackjack/domain/result/BetResultsTest.java index 3ddaa68249b..8381e522cb8 100644 --- a/src/test/java/blackjack/domain/rule/BetResultsTest.java +++ b/src/test/java/blackjack/domain/result/BetResultsTest.java @@ -1,4 +1,4 @@ -package blackjack.domain.rule; +package blackjack.domain.result; import static org.assertj.core.api.Assertions.assertThat; diff --git a/src/test/java/blackjack/domain/rule/PlayerResultsTest.java b/src/test/java/blackjack/domain/result/PlayerResultsTest.java similarity index 81% rename from src/test/java/blackjack/domain/rule/PlayerResultsTest.java rename to src/test/java/blackjack/domain/result/PlayerResultsTest.java index 169fff77f5e..67509797a33 100644 --- a/src/test/java/blackjack/domain/rule/PlayerResultsTest.java +++ b/src/test/java/blackjack/domain/result/PlayerResultsTest.java @@ -1,7 +1,7 @@ -package blackjack.domain.rule; +package blackjack.domain.result; -import static blackjack.domain.rule.GameResult.PLAYER_LOSE; -import static blackjack.domain.rule.GameResult.PLAYER_WIN; +import static blackjack.domain.result.GameResult.PLAYER_LOSE; +import static blackjack.domain.result.GameResult.PLAYER_WIN; import static org.assertj.core.api.Assertions.assertThat; import java.util.List; From d48fe9770d5f1b47b8c44b3c0f11e5c853e80393 Mon Sep 17 00:00:00 2001 From: libienz Date: Fri, 15 Mar 2024 13:52:05 +0900 Subject: [PATCH 52/91] =?UTF-8?q?feat:=20=EB=B2=A0=ED=8C=85=20=EA=B8=88?= =?UTF-8?q?=EC=95=A1=EA=B3=BC=20=ED=94=8C=EB=A0=88=EC=9D=B4=EC=96=B4?= =?UTF-8?q?=EB=A5=BC=20=EB=A7=A4=ED=95=91=ED=95=98=EB=8A=94=20=EC=83=88?= =?UTF-8?q?=EB=A1=9C=EC=9A=B4=20=EB=8F=84=EB=A9=94=EC=9D=B8=20=EA=B5=AC?= =?UTF-8?q?=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/bet/BettingBank.java | 13 +++++++++++++ src/main/java/blackjack/view/InputView.java | 13 +++++++++++++ 2 files changed, 26 insertions(+) create mode 100644 src/main/java/blackjack/domain/bet/BettingBank.java diff --git a/src/main/java/blackjack/domain/bet/BettingBank.java b/src/main/java/blackjack/domain/bet/BettingBank.java new file mode 100644 index 00000000000..d19e863fe60 --- /dev/null +++ b/src/main/java/blackjack/domain/bet/BettingBank.java @@ -0,0 +1,13 @@ +package blackjack.domain.bet; + +import blackjack.domain.player.Player; +import java.util.Map; + +public class BettingBank { + + private final Map playerMoneyMap; + + public BettingBank(Map playerMoneyMap) { + this.playerMoneyMap = playerMoneyMap; + } +} diff --git a/src/main/java/blackjack/view/InputView.java b/src/main/java/blackjack/view/InputView.java index 35507742ba7..1b8a550fe78 100644 --- a/src/main/java/blackjack/view/InputView.java +++ b/src/main/java/blackjack/view/InputView.java @@ -4,11 +4,14 @@ import blackjack.domain.DrawDecision; import blackjack.domain.bet.Bet; import blackjack.domain.bet.Bets; +import blackjack.domain.bet.BettingBank; +import blackjack.domain.bet.Money; import blackjack.domain.player.Player; import blackjack.domain.player.PlayerName; import blackjack.domain.player.Players; import java.util.List; import java.util.Scanner; +import java.util.stream.Collectors; public class InputView { @@ -39,6 +42,16 @@ public Bets readBets(Players players) { .toList()); } + public BettingBank readBetInformation(Players players) { + return new BettingBank(players.getPlayers().stream() + .collect(Collectors.toMap(player -> player, this::readBetAmount))); + } + + public Money readBetAmount(Player player) { + System.out.println(String.format("%s의 배팅 금액은?", player.getName())); + return new Money(Integer.parseInt(scanner.nextLine())); + } + public Bet readBet(String playerName) { System.out.println(String.format("%s의 배팅 금액은?", playerName)); return inputMapper.mapToBet(playerName, Integer.parseInt(scanner.nextLine())); From 8a035a549d6ecb0912226d7ff5a0b2a3f9240c40 Mon Sep 17 00:00:00 2001 From: libienz Date: Fri, 15 Mar 2024 13:57:43 +0900 Subject: [PATCH 53/91] =?UTF-8?q?feat:=20Player=EC=99=80=20=EA=B2=8C?= =?UTF-8?q?=EC=9E=84=20=EA=B2=B0=EA=B3=BC=EB=A5=BC=20=EB=A7=A4=ED=95=91?= =?UTF-8?q?=ED=95=B4=EC=A3=BC=EB=8A=94=20=EB=8F=84=EB=A9=94=EC=9D=B8=20?= =?UTF-8?q?=EC=86=8D=EC=84=B1=20=EC=A0=95=EC=9D=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../blackjack/domain/result/PlayerGameResult.java | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 src/main/java/blackjack/domain/result/PlayerGameResult.java diff --git a/src/main/java/blackjack/domain/result/PlayerGameResult.java b/src/main/java/blackjack/domain/result/PlayerGameResult.java new file mode 100644 index 00000000000..00213f191e8 --- /dev/null +++ b/src/main/java/blackjack/domain/result/PlayerGameResult.java @@ -0,0 +1,13 @@ +package blackjack.domain.result; + +import blackjack.domain.player.Player; +import java.util.Map; + +public class PlayerGameResult { + + private final Map playerGameResultMap; + + public PlayerGameResult(Map playerGameResultMap) { + this.playerGameResultMap = playerGameResultMap; + } +} From ba815749a5f163d985bffcdfc97684942c9ea221 Mon Sep 17 00:00:00 2001 From: libienz Date: Fri, 15 Mar 2024 14:39:06 +0900 Subject: [PATCH 54/91] =?UTF-8?q?feat:=20Profit=20=EC=9B=90=EC=8B=9C?= =?UTF-8?q?=EA=B0=92=20=ED=8F=AC=EC=9E=A5=20=ED=81=B4=EB=9E=98=EC=8A=A4=20?= =?UTF-8?q?=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/bet/Profit.java | 10 ++++++++++ 1 file changed, 10 insertions(+) create mode 100644 src/main/java/blackjack/domain/bet/Profit.java diff --git a/src/main/java/blackjack/domain/bet/Profit.java b/src/main/java/blackjack/domain/bet/Profit.java new file mode 100644 index 00000000000..6c71b7a6f32 --- /dev/null +++ b/src/main/java/blackjack/domain/bet/Profit.java @@ -0,0 +1,10 @@ +package blackjack.domain.bet; + +public class Profit { + + private final int value; + + public Profit(int value) { + this.value = value; + } +} From ac68319693d776f5852d5de69a47875baa495e2b Mon Sep 17 00:00:00 2001 From: libienz Date: Fri, 15 Mar 2024 15:01:57 +0900 Subject: [PATCH 55/91] =?UTF-8?q?feat:=20Profit=20=EB=8F=84=EB=A9=94?= =?UTF-8?q?=EC=9D=B8=20=EA=B2=8C=ED=84=B0=20=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/bet/Profit.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/main/java/blackjack/domain/bet/Profit.java b/src/main/java/blackjack/domain/bet/Profit.java index 6c71b7a6f32..28b6a99189e 100644 --- a/src/main/java/blackjack/domain/bet/Profit.java +++ b/src/main/java/blackjack/domain/bet/Profit.java @@ -7,4 +7,8 @@ public class Profit { public Profit(int value) { this.value = value; } + + public int getValue() { + return value; + } } From c09639fd8bf018ba7094c02eecb4d0d99c667ccb Mon Sep 17 00:00:00 2001 From: libienz Date: Fri, 15 Mar 2024 15:02:53 +0900 Subject: [PATCH 56/91] =?UTF-8?q?feat:=20Money=EB=8F=84=EB=A9=94=EC=9D=B8?= =?UTF-8?q?=EC=97=90=20=EC=9D=B4=EC=9C=A8=EC=9D=84=20=EC=A0=81=EC=9A=A9?= =?UTF-8?q?=ED=96=88=EC=9D=84=20=EB=95=8C=20Profit=20=EB=8F=84=EB=A9=94?= =?UTF-8?q?=EC=9D=B8=EC=9D=84=20=EB=B0=98=ED=99=98=ED=95=98=EB=8F=84?= =?UTF-8?q?=EB=A1=9D=20=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/bet/Money.java | 4 ++++ src/test/java/blackjack/domain/bet/MoneyTest.java | 7 +++++++ 2 files changed, 11 insertions(+) diff --git a/src/main/java/blackjack/domain/bet/Money.java b/src/main/java/blackjack/domain/bet/Money.java index d71f0931275..5c569dffd92 100644 --- a/src/main/java/blackjack/domain/bet/Money.java +++ b/src/main/java/blackjack/domain/bet/Money.java @@ -16,6 +16,10 @@ public Money multiply(double scope) { return new Money((int) (amount * scope)); } + public Profit calculateProfit(double leverage) { + return new Profit((int) (amount * leverage)); + } + public Money add(Money other) { return new Money(amount + other.amount); } diff --git a/src/test/java/blackjack/domain/bet/MoneyTest.java b/src/test/java/blackjack/domain/bet/MoneyTest.java index 8036baaa182..7b3a0bed9d0 100644 --- a/src/test/java/blackjack/domain/bet/MoneyTest.java +++ b/src/test/java/blackjack/domain/bet/MoneyTest.java @@ -51,4 +51,11 @@ void testInverseMoney() { Money money = new Money(1000); assertThat(money.inverse().getAmount()).isEqualTo(-1000); } + + @DisplayName("돈에 특정 이율을 적용한 Profit을 계산할 수 있다") + @Test + void testCalculateProfit() { + Money money = new Money(1000); + assertThat(money.calculateProfit(1.5).getValue()).isEqualTo(1500); + } } From 0a8cfbc6d9d7002764e9795fc5bb1099e8414c36 Mon Sep 17 00:00:00 2001 From: libienz Date: Fri, 15 Mar 2024 15:10:49 +0900 Subject: [PATCH 57/91] =?UTF-8?q?feat:=20PlayerGameResult=20=EB=8F=84?= =?UTF-8?q?=EB=A9=94=EC=9D=B8=20=EA=B2=8C=ED=84=B0=20=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../blackjack/domain/result/PlayerGameResult.java | 4 ++++ .../domain/result/PlayerProfitResult.java | 14 ++++++++++++++ 2 files changed, 18 insertions(+) create mode 100644 src/main/java/blackjack/domain/result/PlayerProfitResult.java diff --git a/src/main/java/blackjack/domain/result/PlayerGameResult.java b/src/main/java/blackjack/domain/result/PlayerGameResult.java index 00213f191e8..d9479022c1a 100644 --- a/src/main/java/blackjack/domain/result/PlayerGameResult.java +++ b/src/main/java/blackjack/domain/result/PlayerGameResult.java @@ -10,4 +10,8 @@ public class PlayerGameResult { public PlayerGameResult(Map playerGameResultMap) { this.playerGameResultMap = playerGameResultMap; } + + public Map getPlayerGameResultMap() { + return playerGameResultMap; + } } diff --git a/src/main/java/blackjack/domain/result/PlayerProfitResult.java b/src/main/java/blackjack/domain/result/PlayerProfitResult.java new file mode 100644 index 00000000000..c44694379e2 --- /dev/null +++ b/src/main/java/blackjack/domain/result/PlayerProfitResult.java @@ -0,0 +1,14 @@ +package blackjack.domain.result; + +import blackjack.domain.bet.Profit; +import blackjack.domain.player.Player; +import java.util.Map; + +public class PlayerProfitResult { + + private final Map playerProfitMap; + + public PlayerProfitResult(Map playerProfitMap) { + this.playerProfitMap = playerProfitMap; + } +} From cc9f461f9bf2893f0023703a713a9d7aabb221d3 Mon Sep 17 00:00:00 2001 From: libienz Date: Fri, 15 Mar 2024 15:29:36 +0900 Subject: [PATCH 58/91] =?UTF-8?q?feat:=20=ED=8A=B9=EC=A0=95=20=ED=94=8C?= =?UTF-8?q?=EB=A0=88=EC=9D=B4=EC=96=B4=EC=9D=98=20=EA=B2=B0=EA=B3=BC?= =?UTF-8?q?=EB=A5=BC=20=EC=A1=B0=ED=9A=8C=ED=95=98=EB=8A=94=20=EA=B8=B0?= =?UTF-8?q?=EB=8A=A5=20=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../domain/result/PlayerGameResult.java | 4 +++ .../domain/result/PlayerGameResultTest.java | 28 +++++++++++++++++++ 2 files changed, 32 insertions(+) create mode 100644 src/test/java/blackjack/domain/result/PlayerGameResultTest.java diff --git a/src/main/java/blackjack/domain/result/PlayerGameResult.java b/src/main/java/blackjack/domain/result/PlayerGameResult.java index d9479022c1a..993a8c75b12 100644 --- a/src/main/java/blackjack/domain/result/PlayerGameResult.java +++ b/src/main/java/blackjack/domain/result/PlayerGameResult.java @@ -14,4 +14,8 @@ public PlayerGameResult(Map playerGameResultMap) { public Map getPlayerGameResultMap() { return playerGameResultMap; } + + public GameResult findGameResultOfPlayer(Player player) { + return playerGameResultMap.get(player); + } } diff --git a/src/test/java/blackjack/domain/result/PlayerGameResultTest.java b/src/test/java/blackjack/domain/result/PlayerGameResultTest.java new file mode 100644 index 00000000000..5f51c8df8ad --- /dev/null +++ b/src/test/java/blackjack/domain/result/PlayerGameResultTest.java @@ -0,0 +1,28 @@ +package blackjack.domain.result; + +import static org.assertj.core.api.Assertions.assertThat; + +import blackjack.domain.player.Player; +import blackjack.domain.player.TestPlayerCreator; +import java.util.HashMap; +import java.util.Map; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +@DisplayName("플레이어들 게임 결과 도메인 테스트") +class PlayerGameResultTest { + + @DisplayName("특정 플레이어의 결과를 조회할 수 있다") + @Test + void testFindPlayerResult() { + Player player1 = TestPlayerCreator.of("리비", 3, 4, 5); + Player player2 = TestPlayerCreator.of("썬", 3, 4); + + Map playerResultMap = new HashMap<>(); + playerResultMap.put(player1, GameResult.PLAYER_WIN); + playerResultMap.put(player2, GameResult.PLAYER_LOSE); + + PlayerGameResult playerGameResult = new PlayerGameResult(playerResultMap); + assertThat(playerGameResult.findGameResultOfPlayer(player1)).isEqualTo(GameResult.PLAYER_WIN); + } +} From d322e727bddbafb56da04db9d479d6d124412655 Mon Sep 17 00:00:00 2001 From: libienz Date: Fri, 15 Mar 2024 16:01:45 +0900 Subject: [PATCH 59/91] =?UTF-8?q?feat:=20Profit=20=EB=8F=99=EB=93=B1?= =?UTF-8?q?=EC=84=B1=20=EB=B0=8F=20=ED=95=B4=EC=8B=9C=20=EC=9E=AC=EC=A0=95?= =?UTF-8?q?=EC=9D=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/blackjack/domain/bet/Profit.java | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/src/main/java/blackjack/domain/bet/Profit.java b/src/main/java/blackjack/domain/bet/Profit.java index 28b6a99189e..777bff6b67f 100644 --- a/src/main/java/blackjack/domain/bet/Profit.java +++ b/src/main/java/blackjack/domain/bet/Profit.java @@ -1,5 +1,7 @@ package blackjack.domain.bet; +import java.util.Objects; + public class Profit { private final int value; @@ -11,4 +13,22 @@ public Profit(int 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); + } } From 99325f59b4d46f98fff049d4b56caf4d8151fe4e Mon Sep 17 00:00:00 2001 From: libienz Date: Fri, 15 Mar 2024 16:02:38 +0900 Subject: [PATCH 60/91] =?UTF-8?q?feat:=20=ED=8A=B9=EC=A0=95=20=ED=94=8C?= =?UTF-8?q?=EB=A0=88=EC=9D=B4=EC=96=B4=EC=9D=98=20=EC=88=98=EC=9D=B5?= =?UTF-8?q?=EB=A5=A0=EC=9D=84=20=EC=A1=B0=ED=9A=8C=ED=95=98=EB=8A=94=20?= =?UTF-8?q?=EA=B8=B0=EB=8A=A5=20=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../domain/result/PlayerProfitResult.java | 4 +++ .../domain/result/PlayerProfitResultTest.java | 29 +++++++++++++++++++ 2 files changed, 33 insertions(+) create mode 100644 src/test/java/blackjack/domain/result/PlayerProfitResultTest.java diff --git a/src/main/java/blackjack/domain/result/PlayerProfitResult.java b/src/main/java/blackjack/domain/result/PlayerProfitResult.java index c44694379e2..2a36adefa32 100644 --- a/src/main/java/blackjack/domain/result/PlayerProfitResult.java +++ b/src/main/java/blackjack/domain/result/PlayerProfitResult.java @@ -11,4 +11,8 @@ public class PlayerProfitResult { public PlayerProfitResult(Map playerProfitMap) { this.playerProfitMap = playerProfitMap; } + + public Profit findProfitOfPlayer(Player player) { + return playerProfitMap.get(player); + } } diff --git a/src/test/java/blackjack/domain/result/PlayerProfitResultTest.java b/src/test/java/blackjack/domain/result/PlayerProfitResultTest.java new file mode 100644 index 00000000000..2a9a88bca79 --- /dev/null +++ b/src/test/java/blackjack/domain/result/PlayerProfitResultTest.java @@ -0,0 +1,29 @@ +package blackjack.domain.result; + +import static org.assertj.core.api.Assertions.assertThat; + +import blackjack.domain.bet.Profit; +import blackjack.domain.player.Player; +import blackjack.domain.player.TestPlayerCreator; +import java.util.HashMap; +import java.util.Map; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +@DisplayName("플레이어의 수익 도메인 테스트") +class PlayerProfitResultTest { + + @DisplayName("특정 플레이어의 수익을 조회할 수 있다") + @Test + void testFindProfitOfPlayer() { + Player player1 = TestPlayerCreator.of("썬", 1, 2, 3, 4); + Player player2 = TestPlayerCreator.of("리비", 3, 4); + + Map playerProfitMap = new HashMap<>(); + playerProfitMap.put(player1, new Profit(30)); + playerProfitMap.put(player2, new Profit(40)); + PlayerProfitResult playerProfitResult = new PlayerProfitResult(playerProfitMap); + + assertThat(playerProfitResult.findProfitOfPlayer(player1)).isEqualTo(new Profit(30)); + } +} From 13f58d2e4a5162c4c4718d1504d3013b956996b4 Mon Sep 17 00:00:00 2001 From: libienz Date: Fri, 15 Mar 2024 16:39:38 +0900 Subject: [PATCH 61/91] =?UTF-8?q?feat:=20=ED=94=8C=EB=A0=88=EC=9D=B4?= =?UTF-8?q?=EC=96=B4=EB=93=A4=20=EA=B2=8C=EC=9E=84=20=EA=B2=B0=EA=B3=BC?= =?UTF-8?q?=EB=A5=BC=20=EA=B3=84=EC=82=B0=ED=95=98=EB=8A=94=20=EA=B8=B0?= =?UTF-8?q?=EB=8A=A5=20=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/Judge.java | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/main/java/blackjack/domain/Judge.java b/src/main/java/blackjack/domain/Judge.java index 1b91f81b508..7d59725b769 100644 --- a/src/main/java/blackjack/domain/Judge.java +++ b/src/main/java/blackjack/domain/Judge.java @@ -9,8 +9,10 @@ import blackjack.domain.player.Player; import blackjack.domain.player.Players; import blackjack.domain.result.GameResult; +import blackjack.domain.result.PlayerGameResult; import blackjack.domain.result.PlayerResult; import blackjack.domain.result.PlayerResults; +import java.util.stream.Collectors; public class Judge { @@ -20,6 +22,11 @@ public PlayerResults calculatePlayerResults(Dealer dealer, Players players) { .toList()); } + public PlayerGameResult calculatePlayerGameResult(Dealer dealer, Players players) { + return new PlayerGameResult(players.getPlayers().stream() + .collect(Collectors.toMap(player -> player, player -> calculatePlayerResult(dealer, player)))); + } + public GameResult calculatePlayerResult(Dealer dealer, Player player) { Score playerScore = player.calculateHandScore(); Score dealerScore = dealer.calculateHandScore(); From 79a851b309200653bacbd6657b0d4808f4aad141 Mon Sep 17 00:00:00 2001 From: libienz Date: Fri, 15 Mar 2024 16:50:47 +0900 Subject: [PATCH 62/91] =?UTF-8?q?feat:=20=ED=94=8C=EB=A0=88=EC=9D=B4?= =?UTF-8?q?=EC=96=B4=EB=93=A4=20=EC=88=98=EC=9D=B5=20=EA=B3=84=EC=82=B0=20?= =?UTF-8?q?=EA=B8=B0=EB=8A=A5=20=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../blackjack/domain/bet/BettingBank.java | 17 ++++++++ .../blackjack/domain/bet/BettingBankTest.java | 43 +++++++++++++++++++ 2 files changed, 60 insertions(+) create mode 100644 src/test/java/blackjack/domain/bet/BettingBankTest.java diff --git a/src/main/java/blackjack/domain/bet/BettingBank.java b/src/main/java/blackjack/domain/bet/BettingBank.java index d19e863fe60..1d08422eb90 100644 --- a/src/main/java/blackjack/domain/bet/BettingBank.java +++ b/src/main/java/blackjack/domain/bet/BettingBank.java @@ -1,7 +1,11 @@ package blackjack.domain.bet; import blackjack.domain.player.Player; +import blackjack.domain.result.GameResult; +import blackjack.domain.result.PlayerGameResult; +import blackjack.domain.result.PlayerProfitResult; import java.util.Map; +import java.util.stream.Collectors; public class BettingBank { @@ -10,4 +14,17 @@ public class BettingBank { public BettingBank(Map playerMoneyMap) { this.playerMoneyMap = playerMoneyMap; } + + public PlayerProfitResult calculateProfitResult(PlayerGameResult playerGameResult) { + return new PlayerProfitResult(playerMoneyMap.keySet().stream() + .collect(Collectors.toMap( + player -> player, + player -> calculatePlayerProfit(player, playerGameResult)))); + } + + private Profit calculatePlayerProfit(Player player, PlayerGameResult playerGameResult) { + GameResult gameResultOfPlayer = playerGameResult.findGameResultOfPlayer(player); + Money betOfPlayer = playerMoneyMap.get(player); + return betOfPlayer.calculateProfit(gameResultOfPlayer.getProfitLeverage()); + } } diff --git a/src/test/java/blackjack/domain/bet/BettingBankTest.java b/src/test/java/blackjack/domain/bet/BettingBankTest.java new file mode 100644 index 00000000000..f41eb2bc14d --- /dev/null +++ b/src/test/java/blackjack/domain/bet/BettingBankTest.java @@ -0,0 +1,43 @@ +package blackjack.domain.bet; + +import static blackjack.domain.result.GameResult.BLACKJACK_WIN; +import static blackjack.domain.result.GameResult.PLAYER_LOSE; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertAll; + +import blackjack.domain.player.Player; +import blackjack.domain.player.TestPlayerCreator; +import blackjack.domain.result.GameResult; +import blackjack.domain.result.PlayerGameResult; +import blackjack.domain.result.PlayerProfitResult; +import java.util.HashMap; +import java.util.Map; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +@DisplayName("베팅 관리자 도메인 테스트") +class BettingBankTest { + + @DisplayName("플레이어들의 통합 수익을 계산할 수 있다") + @Test + void testCalculatePlayerProfit() { + Player player1 = TestPlayerCreator.of("리비", 1, 10); + Player player2 = TestPlayerCreator.of("썬", 3, 4, 5, 6); + + Map playerMoneyMap = new HashMap<>(); + playerMoneyMap.put(player1, new Money(1000)); + playerMoneyMap.put(player2, new Money(1000)); + BettingBank bettingBank = new BettingBank(playerMoneyMap); + + Map playerGameResultMap = new HashMap<>(); + playerGameResultMap.put(player1, BLACKJACK_WIN); + playerGameResultMap.put(player2, PLAYER_LOSE); + PlayerGameResult playerGameResult = new PlayerGameResult(playerGameResultMap); + + PlayerProfitResult playerProfitResult = bettingBank.calculateProfitResult(playerGameResult); + assertAll( + () -> assertThat(playerProfitResult.findProfitOfPlayer(player1).getValue()).isEqualTo(1500), + () -> assertThat(playerProfitResult.findProfitOfPlayer(player2).getValue()).isEqualTo(-1000) + ); + } +} From a1ac0da5392ef2fdd51d304afb6aacf6f35df4e0 Mon Sep 17 00:00:00 2001 From: libienz Date: Fri, 15 Mar 2024 16:57:32 +0900 Subject: [PATCH 63/91] =?UTF-8?q?feat:=20=EC=88=98=EC=9D=B5=EC=97=90=20?= =?UTF-8?q?=EB=8B=A4=EB=A5=B8=20=EC=88=98=EC=9D=B5=EC=9D=84=20=EB=8D=94?= =?UTF-8?q?=ED=95=98=EB=8A=94=20=EA=B8=B0=EB=8A=A5=20=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/bet/Profit.java | 4 ++++ .../java/blackjack/domain/bet/ProfitTest.java | 18 ++++++++++++++++++ 2 files changed, 22 insertions(+) create mode 100644 src/test/java/blackjack/domain/bet/ProfitTest.java diff --git a/src/main/java/blackjack/domain/bet/Profit.java b/src/main/java/blackjack/domain/bet/Profit.java index 777bff6b67f..1cc07522715 100644 --- a/src/main/java/blackjack/domain/bet/Profit.java +++ b/src/main/java/blackjack/domain/bet/Profit.java @@ -10,6 +10,10 @@ public Profit(int value) { this.value = value; } + public Profit add(Profit other) { + return new Profit(this.value + other.value); + } + public int getValue() { return value; } diff --git a/src/test/java/blackjack/domain/bet/ProfitTest.java b/src/test/java/blackjack/domain/bet/ProfitTest.java new file mode 100644 index 00000000000..3bc9cb32125 --- /dev/null +++ b/src/test/java/blackjack/domain/bet/ProfitTest.java @@ -0,0 +1,18 @@ +package blackjack.domain.bet; + +import static org.assertj.core.api.Assertions.assertThat; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +@DisplayName("수익 금액 테스트") +class ProfitTest { + + @DisplayName("수익에 다른 수익을 더할 수 있다") + @Test + void testAdd() { + Profit profit1 = new Profit(1000); + Profit profit2 = new Profit(-1000); + assertThat(profit1.add(profit2).getValue()).isEqualTo(0); + } +} From eaa7fe4166f98ba70ba939b67bd5c8632b4258a5 Mon Sep 17 00:00:00 2001 From: libienz Date: Fri, 15 Mar 2024 16:58:58 +0900 Subject: [PATCH 64/91] =?UTF-8?q?feat:=20=ED=94=8C=EB=A0=88=EC=9D=B4?= =?UTF-8?q?=EC=96=B4=EB=93=A4=EC=9D=98=20=EC=88=98=EC=9D=B5=20=EC=B4=9D?= =?UTF-8?q?=ED=95=A9=EC=9D=84=20=EA=B3=84=EC=82=B0=ED=95=98=EB=8A=94=20?= =?UTF-8?q?=EA=B8=B0=EB=8A=A5=20=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../domain/result/PlayerProfitResult.java | 5 +++++ .../domain/result/PlayerProfitResultTest.java | 14 ++++++++++++++ 2 files changed, 19 insertions(+) diff --git a/src/main/java/blackjack/domain/result/PlayerProfitResult.java b/src/main/java/blackjack/domain/result/PlayerProfitResult.java index 2a36adefa32..13f462e6a63 100644 --- a/src/main/java/blackjack/domain/result/PlayerProfitResult.java +++ b/src/main/java/blackjack/domain/result/PlayerProfitResult.java @@ -15,4 +15,9 @@ public PlayerProfitResult(Map playerProfitMap) { public Profit findProfitOfPlayer(Player player) { return playerProfitMap.get(player); } + + public Profit calculateTotalProfit() { + return playerProfitMap.values().stream() + .reduce(new Profit(0), Profit::add); + } } diff --git a/src/test/java/blackjack/domain/result/PlayerProfitResultTest.java b/src/test/java/blackjack/domain/result/PlayerProfitResultTest.java index 2a9a88bca79..6bd04df26bb 100644 --- a/src/test/java/blackjack/domain/result/PlayerProfitResultTest.java +++ b/src/test/java/blackjack/domain/result/PlayerProfitResultTest.java @@ -26,4 +26,18 @@ void testFindProfitOfPlayer() { assertThat(playerProfitResult.findProfitOfPlayer(player1)).isEqualTo(new Profit(30)); } + + @DisplayName("전체 플레이어들의 수익을 총합계산할 수 있다") + @Test + void testCalculateTotalProfit() { + Player player1 = TestPlayerCreator.of("썬", 1, 2, 3, 4); + Player player2 = TestPlayerCreator.of("리비", 3, 4); + + Map playerProfitMap = new HashMap<>(); + playerProfitMap.put(player1, new Profit(-30000)); + playerProfitMap.put(player2, new Profit(40000)); + PlayerProfitResult playerProfitResult = new PlayerProfitResult(playerProfitMap); + + assertThat(playerProfitResult.calculateTotalProfit().getValue()).isEqualTo(10000); + } } From 15a5788ec8d761d10a66094a462fae080b8da6ad Mon Sep 17 00:00:00 2001 From: libienz Date: Fri, 15 Mar 2024 17:02:46 +0900 Subject: [PATCH 65/91] =?UTF-8?q?feat:=20=EC=88=98=EC=9D=B5=EC=9D=84=20?= =?UTF-8?q?=EB=B0=98=EC=A0=84=EC=8B=9C=ED=82=A4=EB=8A=94=20=EA=B8=B0?= =?UTF-8?q?=EB=8A=A5=20=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/bet/Profit.java | 4 ++++ src/test/java/blackjack/domain/bet/ProfitTest.java | 7 +++++++ 2 files changed, 11 insertions(+) diff --git a/src/main/java/blackjack/domain/bet/Profit.java b/src/main/java/blackjack/domain/bet/Profit.java index 1cc07522715..508b4230b21 100644 --- a/src/main/java/blackjack/domain/bet/Profit.java +++ b/src/main/java/blackjack/domain/bet/Profit.java @@ -14,6 +14,10 @@ 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; } diff --git a/src/test/java/blackjack/domain/bet/ProfitTest.java b/src/test/java/blackjack/domain/bet/ProfitTest.java index 3bc9cb32125..25803f36191 100644 --- a/src/test/java/blackjack/domain/bet/ProfitTest.java +++ b/src/test/java/blackjack/domain/bet/ProfitTest.java @@ -15,4 +15,11 @@ void testAdd() { Profit profit2 = new Profit(-1000); assertThat(profit1.add(profit2).getValue()).isEqualTo(0); } + + @DisplayName("수익을 반전시킨 결과를 볼 수 있다") + @Test + void testInverse() { + Profit profit = new Profit(1000); + assertThat(profit.inverse().getValue()).isEqualTo(-1000); + } } From 0d896e59bd4b04a0c136be0399cc08883cc23e21 Mon Sep 17 00:00:00 2001 From: libienz Date: Fri, 15 Mar 2024 17:15:51 +0900 Subject: [PATCH 66/91] =?UTF-8?q?feat:=20=EB=94=9C=EB=9F=AC=20=EC=88=98?= =?UTF-8?q?=EC=9D=B5=EB=A5=A0=20=EA=B3=84=EC=82=B0=20=EA=B8=B0=EB=8A=A5=20?= =?UTF-8?q?=EA=B5=AC=ED=98=84=20=EB=B0=8F=20=EA=B2=8C=ED=84=B0=20=EC=B6=94?= =?UTF-8?q?=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../domain/result/PlayerProfitResult.java | 8 ++++++++ .../domain/result/PlayerProfitResultTest.java | 14 ++++++++++++++ 2 files changed, 22 insertions(+) diff --git a/src/main/java/blackjack/domain/result/PlayerProfitResult.java b/src/main/java/blackjack/domain/result/PlayerProfitResult.java index 13f462e6a63..e9f31a46192 100644 --- a/src/main/java/blackjack/domain/result/PlayerProfitResult.java +++ b/src/main/java/blackjack/domain/result/PlayerProfitResult.java @@ -20,4 +20,12 @@ public Profit calculateTotalProfit() { return playerProfitMap.values().stream() .reduce(new Profit(0), Profit::add); } + + public Profit calculateDealerProfit() { + return calculateTotalProfit().inverse(); + } + + public Map getPlayerProfitMap() { + return playerProfitMap; + } } diff --git a/src/test/java/blackjack/domain/result/PlayerProfitResultTest.java b/src/test/java/blackjack/domain/result/PlayerProfitResultTest.java index 6bd04df26bb..e2fb7b66619 100644 --- a/src/test/java/blackjack/domain/result/PlayerProfitResultTest.java +++ b/src/test/java/blackjack/domain/result/PlayerProfitResultTest.java @@ -40,4 +40,18 @@ void testCalculateTotalProfit() { assertThat(playerProfitResult.calculateTotalProfit().getValue()).isEqualTo(10000); } + + @DisplayName("딜러의 수익을 계산할 수 있다") + @Test + void testCalculateDealerProfit() { + Player player1 = TestPlayerCreator.of("썬", 1, 2, 3, 4); + Player player2 = TestPlayerCreator.of("리비", 3, 4); + + Map playerProfitMap = new HashMap<>(); + playerProfitMap.put(player1, new Profit(-30000)); + playerProfitMap.put(player2, new Profit(40000)); + PlayerProfitResult playerProfitResult = new PlayerProfitResult(playerProfitMap); + + assertThat(playerProfitResult.calculateDealerProfit().getValue()).isEqualTo(-10000); + } } From a51e5b64ce8cd6d091092f331b7db13a0f8a120a Mon Sep 17 00:00:00 2001 From: libienz Date: Fri, 15 Mar 2024 17:32:58 +0900 Subject: [PATCH 67/91] =?UTF-8?q?feat:=20=EC=83=88=EB=A1=9C=20=EC=A0=95?= =?UTF-8?q?=EC=9D=98=ED=95=9C=20=EB=8F=84=EB=A9=94=EC=9D=B8=EC=9D=84=20?= =?UTF-8?q?=EB=B0=94=EB=9D=BC=EB=B3=B4=EB=8A=94=20=EB=B7=B0=EB=A1=9C?= =?UTF-8?q?=EC=A7=81=20=EC=B6=94=EA=B0=80=20=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/BlackJackGame.java | 22 +++++-------- .../java/blackjack/view/MessageResolver.java | 33 +++++++++++++++++-- src/main/java/blackjack/view/OutputView.java | 6 ++++ 3 files changed, 46 insertions(+), 15 deletions(-) diff --git a/src/main/java/blackjack/BlackJackGame.java b/src/main/java/blackjack/BlackJackGame.java index 455f850caeb..f26f1bb4a64 100644 --- a/src/main/java/blackjack/BlackJackGame.java +++ b/src/main/java/blackjack/BlackJackGame.java @@ -1,7 +1,8 @@ package blackjack; import blackjack.domain.Judge; -import blackjack.domain.bet.Bets; +import blackjack.domain.bet.BettingBank; +import blackjack.domain.bet.Profit; import blackjack.domain.card.CardDeck; import blackjack.domain.card.Hand; import blackjack.domain.player.Dealer; @@ -9,8 +10,8 @@ import blackjack.domain.player.Player; import blackjack.domain.player.PlayerName; import blackjack.domain.player.Players; -import blackjack.domain.result.BetResults; -import blackjack.domain.result.PlayerResults; +import blackjack.domain.result.PlayerGameResult; +import blackjack.domain.result.PlayerProfitResult; import blackjack.view.InputView; import blackjack.view.OutputView; import java.util.List; @@ -28,7 +29,7 @@ public BlackJackGame(InputView inputView, OutputView outputView) { public void run() { CardDeck cardDeck = CardDeck.createShuffledDeck(); Players players = initPlayers(cardDeck); - Bets bets = inputView.readBets(players); + BettingBank bettingBank = inputView.readBetInformation(players); Dealer dealer = new Dealer(Hand.createHandFrom(cardDeck)); Judge judge = new Judge(); printPlayersInformation(players, dealer); @@ -40,15 +41,10 @@ public void run() { printParticipantScore(dealer); printPlayersScore(players); - PlayerResults playerResults = judge.calculatePlayerResults(dealer, players); - List playerNames = players.getPlayerNames(); - - BetResults betResults = new BetResults(playerNames.stream() - .map(bets::findBetByPlayerName) - .map(bet -> bet.calculateBetResult(playerResults.findResultByName(bet.getPlayerName()))) - .toList()); - - outputView.printBetResults(betResults.calculateDealerProfit().getAmount(), betResults); + PlayerGameResult playerGameResult = judge.calculatePlayerGameResult(dealer, players); + PlayerProfitResult playerProfitResult = bettingBank.calculateProfitResult(playerGameResult); + Profit profit = playerProfitResult.calculateDealerProfit(); + outputView.printProfitResults(playerProfitResult, profit); } private Players initPlayers(CardDeck cardDeck) { diff --git a/src/main/java/blackjack/view/MessageResolver.java b/src/main/java/blackjack/view/MessageResolver.java index fa0be756c66..21969e7616a 100644 --- a/src/main/java/blackjack/view/MessageResolver.java +++ b/src/main/java/blackjack/view/MessageResolver.java @@ -4,6 +4,7 @@ import static blackjack.view.CardDescription.SHAPE_NAME; import blackjack.domain.Score; +import blackjack.domain.bet.Profit; import blackjack.domain.card.Card; import blackjack.domain.card.CardNumber; import blackjack.domain.card.CardShape; @@ -14,6 +15,8 @@ import blackjack.domain.player.Players; import blackjack.domain.result.BetResult; import blackjack.domain.result.BetResults; +import blackjack.domain.result.PlayerProfitResult; +import java.util.Map; import java.util.stream.Collectors; public class MessageResolver { @@ -82,7 +85,33 @@ public String resolveBetResultsMessage(int dealerEarned, BetResults betResults) .collect(Collectors.joining(LINE_SEPARATOR))).toString(); } - public String resolveDealerProfitMessage(int dealerEarned) { - return String.format("딜러: %d", dealerEarned); + public String resolveProfitResultMessage(PlayerProfitResult playerProfitResult, Profit dealerProfit) { + return new StringBuilder(LINE_SEPARATOR) + .append("##최종 수익") + .append(LINE_SEPARATOR) + .append(resolveDealerProfitMessage(dealerProfit)) + .append(LINE_SEPARATOR) + .append(resolvePlayerProfitMessage(playerProfitResult)).toString(); + } + + public String resolveDealerProfitMessage(Profit dealerProfit) { + return String.format("딜러: %d", dealerProfit.getValue()); + } + + public String resolveDealerProfitMessage(int dealerProfit) { + return String.format("딜러: %d", dealerProfit); + } + + public String resolvePlayerProfitMessage(PlayerProfitResult playerProfitResult) { + Map playerProfitMap = playerProfitResult.getPlayerProfitMap(); + return playerProfitMap.entrySet().stream() + .map(this::resolveSingleProfitMessage) + .collect(Collectors.joining(LINE_SEPARATOR)); + } + + public String resolveSingleProfitMessage(Map.Entry playerProfit) { + String playerName = playerProfit.getKey().getName(); + int profit = playerProfit.getValue().getValue(); + return String.format("%s: %d", playerName, profit); } } diff --git a/src/main/java/blackjack/view/OutputView.java b/src/main/java/blackjack/view/OutputView.java index c4265ca38b7..36384cd0a84 100644 --- a/src/main/java/blackjack/view/OutputView.java +++ b/src/main/java/blackjack/view/OutputView.java @@ -1,12 +1,14 @@ package blackjack.view; import blackjack.domain.Score; +import blackjack.domain.bet.Profit; import blackjack.domain.player.Dealer; import blackjack.domain.player.Participant; import blackjack.domain.player.Player; import blackjack.domain.player.Players; import blackjack.domain.result.BetResult; import blackjack.domain.result.BetResults; +import blackjack.domain.result.PlayerProfitResult; public class OutputView { @@ -40,6 +42,10 @@ public void printBetResults(int dealerEarned, BetResults betResults) { System.out.println(messageResolver.resolveBetResultsMessage(dealerEarned, betResults)); } + public void printProfitResults(PlayerProfitResult playerProfitResult, Profit dealerProfit) { + System.out.println(messageResolver.resolveProfitResultMessage(playerProfitResult, dealerProfit)); + } + public void printBetResult(BetResult betResult) { System.out.println(messageResolver.resolveBetResultMessage(betResult)); } From c71f92e1401cf6e749243c04129ba39a377da6fd Mon Sep 17 00:00:00 2001 From: libienz Date: Fri, 15 Mar 2024 17:35:12 +0900 Subject: [PATCH 68/91] =?UTF-8?q?refactor:=20=EC=82=AC=EC=9A=A9=ED=95=98?= =?UTF-8?q?=EC=A7=80=20=EC=95=8A=EB=8A=94=20=EB=B7=B0=EB=A1=9C=EC=A7=81=20?= =?UTF-8?q?=EC=A0=9C=EA=B1=B0=20=EA=B0=9C=EC=84=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/blackjack/view/MessageResolver.java | 21 ------------------- src/main/java/blackjack/view/OutputView.java | 11 ---------- 2 files changed, 32 deletions(-) diff --git a/src/main/java/blackjack/view/MessageResolver.java b/src/main/java/blackjack/view/MessageResolver.java index 21969e7616a..27c0d4ee93e 100644 --- a/src/main/java/blackjack/view/MessageResolver.java +++ b/src/main/java/blackjack/view/MessageResolver.java @@ -13,8 +13,6 @@ import blackjack.domain.player.Participant; import blackjack.domain.player.Player; import blackjack.domain.player.Players; -import blackjack.domain.result.BetResult; -import blackjack.domain.result.BetResults; import blackjack.domain.result.PlayerProfitResult; import java.util.Map; import java.util.stream.Collectors; @@ -70,21 +68,6 @@ public String resolveParticipantScoreMessage(Participant participant, Score scor return String.format("%s - 결과: %d", handMessage, score.getValue()); } - public String resolveBetResultMessage(BetResult betResult) { - return String.format("%s: %d", betResult.getName(), betResult.getProfit()); - } - - public String resolveBetResultsMessage(int dealerEarned, BetResults betResults) { - return new StringBuilder(LINE_SEPARATOR) - .append("##최종 수익") - .append(LINE_SEPARATOR) - .append(resolveDealerProfitMessage(dealerEarned)) - .append(LINE_SEPARATOR) - .append(betResults.getBetResults().stream() - .map(this::resolveBetResultMessage) - .collect(Collectors.joining(LINE_SEPARATOR))).toString(); - } - public String resolveProfitResultMessage(PlayerProfitResult playerProfitResult, Profit dealerProfit) { return new StringBuilder(LINE_SEPARATOR) .append("##최종 수익") @@ -98,10 +81,6 @@ public String resolveDealerProfitMessage(Profit dealerProfit) { return String.format("딜러: %d", dealerProfit.getValue()); } - public String resolveDealerProfitMessage(int dealerProfit) { - return String.format("딜러: %d", dealerProfit); - } - public String resolvePlayerProfitMessage(PlayerProfitResult playerProfitResult) { Map playerProfitMap = playerProfitResult.getPlayerProfitMap(); return playerProfitMap.entrySet().stream() diff --git a/src/main/java/blackjack/view/OutputView.java b/src/main/java/blackjack/view/OutputView.java index 36384cd0a84..c68ef129830 100644 --- a/src/main/java/blackjack/view/OutputView.java +++ b/src/main/java/blackjack/view/OutputView.java @@ -6,8 +6,6 @@ import blackjack.domain.player.Participant; import blackjack.domain.player.Player; import blackjack.domain.player.Players; -import blackjack.domain.result.BetResult; -import blackjack.domain.result.BetResults; import blackjack.domain.result.PlayerProfitResult; public class OutputView { @@ -38,16 +36,7 @@ public void printDealerInitialHand(Dealer dealer) { System.out.println(messageResolver.resolveDealerHandMessage(dealer)); } - public void printBetResults(int dealerEarned, BetResults betResults) { - System.out.println(messageResolver.resolveBetResultsMessage(dealerEarned, betResults)); - } - public void printProfitResults(PlayerProfitResult playerProfitResult, Profit dealerProfit) { System.out.println(messageResolver.resolveProfitResultMessage(playerProfitResult, dealerProfit)); } - - public void printBetResult(BetResult betResult) { - System.out.println(messageResolver.resolveBetResultMessage(betResult)); - } - } From 96e6f7daebd099e67a801a5fc5cf2e055fb2b6cd Mon Sep 17 00:00:00 2001 From: libienz Date: Fri, 15 Mar 2024 17:38:50 +0900 Subject: [PATCH 69/91] =?UTF-8?q?refactor:=20=EC=82=AC=EC=9A=A9=ED=95=98?= =?UTF-8?q?=EC=A7=80=20=EC=95=8A=EB=8A=94=20=ED=81=B4=EB=9E=98=EC=8A=A4=20?= =?UTF-8?q?=EC=A0=9C=EA=B1=B0=20=EA=B0=9C=EC=84=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/InputMapper.java | 6 --- src/main/java/blackjack/domain/bet/Bet.java | 29 ---------- src/main/java/blackjack/domain/bet/Bets.java | 19 ------- .../blackjack/domain/result/BetResult.java | 22 -------- .../blackjack/domain/result/BetResults.java | 24 --------- src/main/java/blackjack/view/InputView.java | 14 ----- .../java/blackjack/domain/bet/BetsTest.java | 53 ------------------- .../domain/result/BetResultsTest.java | 22 -------- 8 files changed, 189 deletions(-) delete mode 100644 src/main/java/blackjack/domain/bet/Bet.java delete mode 100644 src/main/java/blackjack/domain/bet/Bets.java delete mode 100644 src/main/java/blackjack/domain/result/BetResult.java delete mode 100644 src/main/java/blackjack/domain/result/BetResults.java delete mode 100644 src/test/java/blackjack/domain/bet/BetsTest.java delete mode 100644 src/test/java/blackjack/domain/result/BetResultsTest.java diff --git a/src/main/java/blackjack/InputMapper.java b/src/main/java/blackjack/InputMapper.java index d55bf075014..f108f887aae 100644 --- a/src/main/java/blackjack/InputMapper.java +++ b/src/main/java/blackjack/InputMapper.java @@ -1,8 +1,6 @@ package blackjack; import blackjack.domain.DrawDecision; -import blackjack.domain.bet.Bet; -import blackjack.domain.bet.Money; import blackjack.domain.player.PlayerName; import java.util.Arrays; import java.util.List; @@ -21,8 +19,4 @@ public List mapToPlayerNames(String target) { public DrawDecision mapToDrawDecision(String target) { return DrawDecision.from(target); } - - public Bet mapToBet(String name, int betAmount) { - return new Bet(new PlayerName(name), new Money(betAmount)); - } } diff --git a/src/main/java/blackjack/domain/bet/Bet.java b/src/main/java/blackjack/domain/bet/Bet.java deleted file mode 100644 index 8a5e1703810..00000000000 --- a/src/main/java/blackjack/domain/bet/Bet.java +++ /dev/null @@ -1,29 +0,0 @@ -package blackjack.domain.bet; - -import blackjack.domain.player.PlayerName; -import blackjack.domain.result.BetResult; -import blackjack.domain.result.GameResult; - -public class Bet { - - private final PlayerName playerName; - private final Money betAmount; - - public Bet(PlayerName playerName, Money betAmount) { - this.playerName = playerName; - this.betAmount = betAmount; - } - - public BetResult calculateBetResult(GameResult gameResult) { - Money earned = betAmount.multiply(gameResult.getProfitLeverage()); - return new BetResult(playerName.getValue(), earned); - } - - public String getPlayerName() { - return playerName.getValue(); - } - - public Money getBetAmount() { - return betAmount; - } -} diff --git a/src/main/java/blackjack/domain/bet/Bets.java b/src/main/java/blackjack/domain/bet/Bets.java deleted file mode 100644 index 07f4ef81315..00000000000 --- a/src/main/java/blackjack/domain/bet/Bets.java +++ /dev/null @@ -1,19 +0,0 @@ -package blackjack.domain.bet; - -import java.util.List; - -public class Bets { - - private final List bets; - - public Bets(List bets) { - this.bets = bets; - } - - public Bet findBetByPlayerName(String playerName) { - return bets.stream() - .filter(bet -> bet.getPlayerName().equals(playerName)) - .findFirst() - .orElseThrow(() -> new IllegalArgumentException("[INTERNAL_ERROR] 해당 이름으로 등록된 베팅 정보를 찾을 수 없습니다")); - } -} diff --git a/src/main/java/blackjack/domain/result/BetResult.java b/src/main/java/blackjack/domain/result/BetResult.java deleted file mode 100644 index 7d6f0c4604e..00000000000 --- a/src/main/java/blackjack/domain/result/BetResult.java +++ /dev/null @@ -1,22 +0,0 @@ -package blackjack.domain.result; - -import blackjack.domain.bet.Money; - -public class BetResult { - - private final String name; - private final Money profit; - - public BetResult(String name, Money profit) { - this.name = name; - this.profit = profit; - } - - public String getName() { - return name; - } - - public int getProfit() { - return profit.getAmount(); - } -} diff --git a/src/main/java/blackjack/domain/result/BetResults.java b/src/main/java/blackjack/domain/result/BetResults.java deleted file mode 100644 index 2d71b79dfc6..00000000000 --- a/src/main/java/blackjack/domain/result/BetResults.java +++ /dev/null @@ -1,24 +0,0 @@ -package blackjack.domain.result; - -import blackjack.domain.bet.Money; -import java.util.List; - -public class BetResults { - - private final List betResults; - - public BetResults(List betResults) { - this.betResults = betResults; - } - - public Money calculateDealerProfit() { - return new Money(betResults.stream() - .map(BetResult::getProfit) - .reduce(0, Integer::sum)) - .inverse(); - } - - public List getBetResults() { - return betResults; - } -} diff --git a/src/main/java/blackjack/view/InputView.java b/src/main/java/blackjack/view/InputView.java index 1b8a550fe78..85af8819a21 100644 --- a/src/main/java/blackjack/view/InputView.java +++ b/src/main/java/blackjack/view/InputView.java @@ -2,8 +2,6 @@ import blackjack.InputMapper; import blackjack.domain.DrawDecision; -import blackjack.domain.bet.Bet; -import blackjack.domain.bet.Bets; import blackjack.domain.bet.BettingBank; import blackjack.domain.bet.Money; import blackjack.domain.player.Player; @@ -35,13 +33,6 @@ public DrawDecision readDrawDecision(String name) { return inputMapper.mapToDrawDecision(scanner.nextLine()); } - public Bets readBets(Players players) { - return new Bets(players.getPlayers().stream() - .map(Player::getName) - .map(this::readBet) - .toList()); - } - public BettingBank readBetInformation(Players players) { return new BettingBank(players.getPlayers().stream() .collect(Collectors.toMap(player -> player, this::readBetAmount))); @@ -51,9 +42,4 @@ public Money readBetAmount(Player player) { System.out.println(String.format("%s의 배팅 금액은?", player.getName())); return new Money(Integer.parseInt(scanner.nextLine())); } - - public Bet readBet(String playerName) { - System.out.println(String.format("%s의 배팅 금액은?", playerName)); - return inputMapper.mapToBet(playerName, Integer.parseInt(scanner.nextLine())); - } } diff --git a/src/test/java/blackjack/domain/bet/BetsTest.java b/src/test/java/blackjack/domain/bet/BetsTest.java deleted file mode 100644 index 1913ddde4c6..00000000000 --- a/src/test/java/blackjack/domain/bet/BetsTest.java +++ /dev/null @@ -1,53 +0,0 @@ -package blackjack.domain.bet; - -import static blackjack.domain.result.GameResult.BLACKJACK_WIN; -import static blackjack.domain.result.GameResult.PLAYER_LOSE; -import static blackjack.domain.result.GameResult.PLAYER_WIN; -import static blackjack.domain.result.GameResult.PUSH; -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.Assertions.assertThatThrownBy; -import static org.junit.jupiter.api.Assertions.assertAll; - -import blackjack.domain.player.PlayerName; -import java.util.List; -import org.junit.jupiter.api.DisplayName; -import org.junit.jupiter.api.Test; - -@DisplayName("베팅 정보들 도메인 테스트") -class BetsTest { - - @DisplayName("플레이어 이름으로 등록된 베팅정보를 찾아올 수 있다") - @Test - void testGetBetByPlayerName() { - Bet bet1 = new Bet(new PlayerName("리비"), new Money(1_000)); - Bet bet2 = new Bet(new PlayerName("썬"), new Money(1_000_000)); - Bets bets = new Bets(List.of(bet1, bet2)); - - Bet found = bets.findBetByPlayerName("리비"); - assertThat(found.getBetAmount().getAmount()).isEqualTo(1_000); - } - - @DisplayName("플레이어 이름으로 등록된 베팅정보를 찾을 수 없을 경우 예외를 발생시킨다") - @Test - void testFindBetWithInvalidPlayerName() { - Bet bet1 = new Bet(new PlayerName("리비"), new Money(1_000)); - Bet bet2 = new Bet(new PlayerName("썬"), new Money(1_000_000)); - Bets bets = new Bets(List.of(bet1, bet2)); - - assertThatThrownBy(() -> bets.findBetByPlayerName("제리")) - .isInstanceOf(IllegalArgumentException.class) - .hasMessage("[INTERNAL_ERROR] 해당 이름으로 등록된 베팅 정보를 찾을 수 없습니다"); - } - - @DisplayName("게임 결과를 받아 베팅 결과를 생성해낼 수 있다") - @Test - void testCreateBetResult() { - Bet bet1 = new Bet(new PlayerName("리비"), new Money(1_000)); - assertAll( - () -> assertThat(bet1.calculateBetResult(PLAYER_WIN).getProfit()).isEqualTo(1_000), - () -> assertThat(bet1.calculateBetResult(BLACKJACK_WIN).getProfit()).isEqualTo(1_500), - () -> assertThat(bet1.calculateBetResult(PLAYER_LOSE).getProfit()).isEqualTo(-1_000), - () -> assertThat(bet1.calculateBetResult(PUSH).getProfit()).isEqualTo(0) - ); - } -} diff --git a/src/test/java/blackjack/domain/result/BetResultsTest.java b/src/test/java/blackjack/domain/result/BetResultsTest.java deleted file mode 100644 index 8381e522cb8..00000000000 --- a/src/test/java/blackjack/domain/result/BetResultsTest.java +++ /dev/null @@ -1,22 +0,0 @@ -package blackjack.domain.result; - -import static org.assertj.core.api.Assertions.assertThat; - -import blackjack.domain.bet.Money; -import java.util.List; -import org.junit.jupiter.api.DisplayName; -import org.junit.jupiter.api.Test; - -@DisplayName("베팅 결과들 도메인 테스트") -class BetResultsTest { - - @DisplayName("딜러가 얼마의 수익을 냈는지 계산할 수 있다") - @Test - void testCalculatePalyersProfit() { - BetResult betResult1 = new BetResult("리비", new Money(10000)); - BetResult betResult2 = new BetResult("썬", new Money(20000)); - BetResults betResults = new BetResults(List.of(betResult1, betResult2)); - - assertThat(betResults.calculateDealerProfit().getAmount()).isEqualTo(-30000); - } -} From d59d08351ce5a458bf84a5f4f7fcb84c2f1c0fd3 Mon Sep 17 00:00:00 2001 From: libienz Date: Fri, 15 Mar 2024 17:40:16 +0900 Subject: [PATCH 70/91] =?UTF-8?q?refactor:=20=EC=82=AC=EC=9A=A9=ED=95=98?= =?UTF-8?q?=EC=A7=80=20=EC=95=8A=EB=8A=94=20=EB=A9=94=EC=84=9C=EB=93=9C,?= =?UTF-8?q?=20=ED=81=B4=EB=9E=98=EC=8A=A4=20=EC=A0=9C=EA=B1=B0=20=EA=B0=9C?= =?UTF-8?q?=EC=84=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/Judge.java | 8 ------- .../blackjack/domain/result/PlayerResult.java | 20 ---------------- .../domain/result/PlayerResults.java | 20 ---------------- .../domain/result/PlayerResultsTest.java | 23 ------------------- 4 files changed, 71 deletions(-) delete mode 100644 src/main/java/blackjack/domain/result/PlayerResult.java delete mode 100644 src/main/java/blackjack/domain/result/PlayerResults.java delete mode 100644 src/test/java/blackjack/domain/result/PlayerResultsTest.java diff --git a/src/main/java/blackjack/domain/Judge.java b/src/main/java/blackjack/domain/Judge.java index 7d59725b769..06076cc5976 100644 --- a/src/main/java/blackjack/domain/Judge.java +++ b/src/main/java/blackjack/domain/Judge.java @@ -10,18 +10,10 @@ import blackjack.domain.player.Players; import blackjack.domain.result.GameResult; import blackjack.domain.result.PlayerGameResult; -import blackjack.domain.result.PlayerResult; -import blackjack.domain.result.PlayerResults; import java.util.stream.Collectors; public class Judge { - public PlayerResults calculatePlayerResults(Dealer dealer, Players players) { - return new PlayerResults(players.getPlayers().stream() - .map(player -> new PlayerResult(player.getName(), calculatePlayerResult(dealer, player))) - .toList()); - } - public PlayerGameResult calculatePlayerGameResult(Dealer dealer, Players players) { return new PlayerGameResult(players.getPlayers().stream() .collect(Collectors.toMap(player -> player, player -> calculatePlayerResult(dealer, player)))); diff --git a/src/main/java/blackjack/domain/result/PlayerResult.java b/src/main/java/blackjack/domain/result/PlayerResult.java deleted file mode 100644 index cab2a38c74f..00000000000 --- a/src/main/java/blackjack/domain/result/PlayerResult.java +++ /dev/null @@ -1,20 +0,0 @@ -package blackjack.domain.result; - -public class PlayerResult { - - private final String playerName; - private final GameResult gameResult; - - public PlayerResult(String playerName, GameResult gameResult) { - this.playerName = playerName; - this.gameResult = gameResult; - } - - public String getPlayerName() { - return playerName; - } - - public GameResult getGameResult() { - return gameResult; - } -} diff --git a/src/main/java/blackjack/domain/result/PlayerResults.java b/src/main/java/blackjack/domain/result/PlayerResults.java deleted file mode 100644 index 1e3e1e48eff..00000000000 --- a/src/main/java/blackjack/domain/result/PlayerResults.java +++ /dev/null @@ -1,20 +0,0 @@ -package blackjack.domain.result; - -import java.util.List; - -public class PlayerResults { - - private final List results; - - public PlayerResults(List results) { - this.results = results; - } - - public GameResult findResultByName(String name) { - return results.stream() - .filter(result -> result.getPlayerName().equals(name)) - .findFirst() - .map(PlayerResult::getGameResult) - .orElseThrow(() -> new IllegalArgumentException("[INTERNAL ERROR] 이름으로 결과를 조회하는데에 실패했습니다")); - } -} diff --git a/src/test/java/blackjack/domain/result/PlayerResultsTest.java b/src/test/java/blackjack/domain/result/PlayerResultsTest.java deleted file mode 100644 index 67509797a33..00000000000 --- a/src/test/java/blackjack/domain/result/PlayerResultsTest.java +++ /dev/null @@ -1,23 +0,0 @@ -package blackjack.domain.result; - -import static blackjack.domain.result.GameResult.PLAYER_LOSE; -import static blackjack.domain.result.GameResult.PLAYER_WIN; -import static org.assertj.core.api.Assertions.assertThat; - -import java.util.List; -import org.junit.jupiter.api.DisplayName; -import org.junit.jupiter.api.Test; - -@DisplayName("플레이어 결과 도메인 테스트") -class PlayerResultsTest { - - @DisplayName("이름으로 결과를 조회할 수 있다") - @Test - void testFindGameResultByName() { - PlayerResult playerResult1 = new PlayerResult("리비", PLAYER_WIN); - PlayerResult playerResult2 = new PlayerResult("리비", PLAYER_LOSE); - PlayerResults playerResults = new PlayerResults(List.of(playerResult1, playerResult2)); - - assertThat(playerResults.findResultByName("리비")).isEqualTo(PLAYER_WIN); - } -} From 8a0c6045191f19b7a35cb874414be164afee1342 Mon Sep 17 00:00:00 2001 From: libienz Date: Fri, 15 Mar 2024 17:42:36 +0900 Subject: [PATCH 71/91] =?UTF-8?q?refactor:=20=EC=82=AC=EC=9A=A9=ED=95=98?= =?UTF-8?q?=EC=A7=80=20=EC=95=8A=EB=8A=94=20=EB=A9=94=EC=84=9C=EB=93=9C=20?= =?UTF-8?q?=EC=A0=9C=EA=B1=B0=20=EA=B0=9C=EC=84=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/result/PlayerGameResult.java | 4 ---- 1 file changed, 4 deletions(-) diff --git a/src/main/java/blackjack/domain/result/PlayerGameResult.java b/src/main/java/blackjack/domain/result/PlayerGameResult.java index 993a8c75b12..304d885dc78 100644 --- a/src/main/java/blackjack/domain/result/PlayerGameResult.java +++ b/src/main/java/blackjack/domain/result/PlayerGameResult.java @@ -11,10 +11,6 @@ public PlayerGameResult(Map playerGameResultMap) { this.playerGameResultMap = playerGameResultMap; } - public Map getPlayerGameResultMap() { - return playerGameResultMap; - } - public GameResult findGameResultOfPlayer(Player player) { return playerGameResultMap.get(player); } From 4dc150708ee97325cdb1a52deb100a100145fe1f Mon Sep 17 00:00:00 2001 From: libienz Date: Fri, 15 Mar 2024 17:45:36 +0900 Subject: [PATCH 72/91] =?UTF-8?q?fix:=20=EA=B2=80=EC=A6=9D=20=EB=A9=94?= =?UTF-8?q?=EC=84=9C=EB=93=9C=20=EC=A0=91=EA=B7=BC=20=EC=A0=9C=EC=96=B4?= =?UTF-8?q?=EC=9E=90=20=EC=88=98=EC=A0=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/bet/Money.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/blackjack/domain/bet/Money.java b/src/main/java/blackjack/domain/bet/Money.java index 5c569dffd92..5bcca6175ba 100644 --- a/src/main/java/blackjack/domain/bet/Money.java +++ b/src/main/java/blackjack/domain/bet/Money.java @@ -32,7 +32,7 @@ public int getAmount() { return amount; } - public void validateRange(int amount) { + private void validateRange(int amount) { if (amount < MIN || MAX < amount) { throw new IllegalArgumentException("[ERROR] 금액은 " + MIN + "부터 " + MAX + "이하까지 가능합니다."); } From 9f01f906ef415205bad04e2f0481809ddf7f9054 Mon Sep 17 00:00:00 2001 From: libienz Date: Fri, 15 Mar 2024 20:02:42 +0900 Subject: [PATCH 73/91] =?UTF-8?q?feat:=20=ED=95=B8=EB=93=9C=EC=97=90=20?= =?UTF-8?q?=EC=97=90=EC=9D=B4=EC=8A=A4=EA=B0=80=20=EC=A1=B4=EC=9E=AC?= =?UTF-8?q?=ED=95=98=EB=8A=94=EC=A7=80=20=ED=99=95=EC=9D=B8=ED=95=98?= =?UTF-8?q?=EB=8A=94=20=EA=B8=B0=EB=8A=A5=20=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/card/Hand.java | 5 +++++ src/test/java/blackjack/domain/card/HandTest.java | 14 ++++++++++++++ 2 files changed, 19 insertions(+) diff --git a/src/main/java/blackjack/domain/card/Hand.java b/src/main/java/blackjack/domain/card/Hand.java index c59798b6119..16c364c7af1 100644 --- a/src/main/java/blackjack/domain/card/Hand.java +++ b/src/main/java/blackjack/domain/card/Hand.java @@ -36,6 +36,11 @@ public int countAce() { .count(); } + public boolean hasAce() { + return cards.stream() + .anyMatch(Card::isAce); + } + public boolean isBlackJack() { return calculateScore().isMaxScore() && cards.size() == INITIAL_HAND_SIZE; } diff --git a/src/test/java/blackjack/domain/card/HandTest.java b/src/test/java/blackjack/domain/card/HandTest.java index 314a2f1d5f0..66cba216e1c 100644 --- a/src/test/java/blackjack/domain/card/HandTest.java +++ b/src/test/java/blackjack/domain/card/HandTest.java @@ -47,6 +47,20 @@ void testCountAceInHand() { assertThat(hand.countAce()).isEqualTo(3); } + @DisplayName("핸드에 에이스 카드가 존재하는지 확인할 수 있다") + @Test + void testHasAceInHand() { + Hand hand = TestHandCreator.of(1, 1, 1, 3, 4, 5); + assertThat(hand.hasAce()).isTrue(); + } + + @DisplayName("핸드에 에이스 카드가 없는 경우를 알 수 있다") + @Test + void testHasNoAceInHand() { + Hand hand = TestHandCreator.of(3, 4, 5); + assertThat(hand.hasAce()).isFalse(); + } + @DisplayName("적절한 점수를 계산할 수 있다 - Ace 카드 없음") @Test void testCalculateScoreWithNoAce() { From b0e72b857baa6436f803fc1e52c6669d5ce45200 Mon Sep 17 00:00:00 2001 From: libienz Date: Fri, 15 Mar 2024 20:07:57 +0900 Subject: [PATCH 74/91] =?UTF-8?q?refactor:=20=EC=86=90=ED=8C=A8=20Ace=20?= =?UTF-8?q?=ED=8F=AC=ED=95=A8=20=EC=A0=90=EC=88=98=20=EA=B3=84=EC=82=B0=20?= =?UTF-8?q?=EB=A1=9C=EC=A7=81=20=EB=8B=A8=EC=88=9C=ED=99=94=20=EA=B0=9C?= =?UTF-8?q?=EC=84=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/card/Hand.java | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/src/main/java/blackjack/domain/card/Hand.java b/src/main/java/blackjack/domain/card/Hand.java index 16c364c7af1..1028e89e1b0 100644 --- a/src/main/java/blackjack/domain/card/Hand.java +++ b/src/main/java/blackjack/domain/card/Hand.java @@ -46,11 +46,9 @@ public boolean isBlackJack() { } public Score calculateScore() { - int aceCount = countAce(); int sum = calculateCardSummation(); - while (aceCount > 0 && (sum + ACE_WEIGHT) <= BUST_THRESHOLD) { + if (hasAce() && (sum + ACE_WEIGHT) <= BUST_THRESHOLD) { sum += ACE_WEIGHT; - aceCount--; } return new Score(sum); } From da40b6eb3090645b71cb18ae4c3a3e778770df66 Mon Sep 17 00:00:00 2001 From: libienz Date: Fri, 15 Mar 2024 20:22:51 +0900 Subject: [PATCH 75/91] =?UTF-8?q?refactor:=20Money=20=EC=B1=85=EC=9E=84?= =?UTF-8?q?=EC=9D=B4=20=EC=9D=B4=EC=A0=84=EB=90=9C=20=EB=A9=94=EC=84=9C?= =?UTF-8?q?=EB=93=9C=20=EC=82=AD=EC=A0=9C=20=EA=B0=9C=EC=84=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/bet/Money.java | 18 +-------------- .../java/blackjack/domain/bet/MoneyTest.java | 22 ------------------- 2 files changed, 1 insertion(+), 39 deletions(-) diff --git a/src/main/java/blackjack/domain/bet/Money.java b/src/main/java/blackjack/domain/bet/Money.java index 5bcca6175ba..85dec60c005 100644 --- a/src/main/java/blackjack/domain/bet/Money.java +++ b/src/main/java/blackjack/domain/bet/Money.java @@ -3,7 +3,7 @@ public class Money { private static final int MAX = 1_000_000_000; - private static final int MIN = -1_000_000_000; + private static final int MIN = 0; private final int amount; @@ -12,26 +12,10 @@ public Money(int amount) { this.amount = amount; } - public Money multiply(double scope) { - return new Money((int) (amount * scope)); - } - public Profit calculateProfit(double leverage) { return new Profit((int) (amount * leverage)); } - public Money add(Money other) { - return new Money(amount + other.amount); - } - - public Money inverse() { - return new Money(-1 * amount); - } - - public int getAmount() { - return amount; - } - private void validateRange(int amount) { if (amount < MIN || MAX < amount) { throw new IllegalArgumentException("[ERROR] 금액은 " + MIN + "부터 " + MAX + "이하까지 가능합니다."); diff --git a/src/test/java/blackjack/domain/bet/MoneyTest.java b/src/test/java/blackjack/domain/bet/MoneyTest.java index 7b3a0bed9d0..54e9056e4c1 100644 --- a/src/test/java/blackjack/domain/bet/MoneyTest.java +++ b/src/test/java/blackjack/domain/bet/MoneyTest.java @@ -30,28 +30,6 @@ void testCreateMoneyWithValidData(int amount) { .doesNotThrowAnyException(); } - @DisplayName("돈에 특정 배율을 적용한 결과를 알 수 있다") - @Test - void testMultiply() { - Money money = new Money(1000); - assertThat(money.multiply(1.5).getAmount()).isEqualTo(1500); - } - - @DisplayName("돈에 돈을 더할 수 있다") - @Test - void testAddMoney() { - Money money = new Money(1000); - Money added = money.add(new Money(1000)); - assertThat(added.getAmount()).isEqualTo(2000); - } - - @DisplayName("부호를 반전한 돈을 계산할 수 있다") - @Test - void testInverseMoney() { - Money money = new Money(1000); - assertThat(money.inverse().getAmount()).isEqualTo(-1000); - } - @DisplayName("돈에 특정 이율을 적용한 Profit을 계산할 수 있다") @Test void testCalculateProfit() { From ebe1b7c06e3cac2bc33ca77a44d1fd284e9b281b Mon Sep 17 00:00:00 2001 From: libienz Date: Fri, 15 Mar 2024 20:24:24 +0900 Subject: [PATCH 76/91] =?UTF-8?q?style:=20Money=20->=20BetAmount=20?= =?UTF-8?q?=ED=81=B4=EB=9E=98=EC=8A=A4=20=EB=AA=85=20=EC=88=98=EC=A0=95=20?= =?UTF-8?q?=EA=B0=9C=EC=84=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../blackjack/domain/bet/{Money.java => BetAmout.java} | 8 ++++---- src/main/java/blackjack/domain/bet/BettingBank.java | 6 +++--- src/main/java/blackjack/view/InputView.java | 6 +++--- .../domain/bet/{MoneyTest.java => BetAmoutTest.java} | 10 +++++----- .../java/blackjack/domain/bet/BettingBankTest.java | 6 +++--- 5 files changed, 18 insertions(+), 18 deletions(-) rename src/main/java/blackjack/domain/bet/{Money.java => BetAmout.java} (63%) rename src/test/java/blackjack/domain/bet/{MoneyTest.java => BetAmoutTest.java} (82%) diff --git a/src/main/java/blackjack/domain/bet/Money.java b/src/main/java/blackjack/domain/bet/BetAmout.java similarity index 63% rename from src/main/java/blackjack/domain/bet/Money.java rename to src/main/java/blackjack/domain/bet/BetAmout.java index 85dec60c005..a66d4d871ca 100644 --- a/src/main/java/blackjack/domain/bet/Money.java +++ b/src/main/java/blackjack/domain/bet/BetAmout.java @@ -1,13 +1,13 @@ package blackjack.domain.bet; -public class Money { +public class BetAmout { private static final int MAX = 1_000_000_000; - private static final int MIN = 0; + private static final int MIN = 1_000; private final int amount; - public Money(int amount) { + public BetAmout(int amount) { validateRange(amount); this.amount = amount; } @@ -18,7 +18,7 @@ public Profit calculateProfit(double leverage) { private void validateRange(int amount) { if (amount < MIN || MAX < amount) { - throw new IllegalArgumentException("[ERROR] 금액은 " + MIN + "부터 " + MAX + "이하까지 가능합니다."); + throw new IllegalArgumentException("[ERROR] 베팅 금액은 " + MIN + "부터 " + MAX + "이하까지 가능합니다."); } } } diff --git a/src/main/java/blackjack/domain/bet/BettingBank.java b/src/main/java/blackjack/domain/bet/BettingBank.java index 1d08422eb90..3160d80a6d6 100644 --- a/src/main/java/blackjack/domain/bet/BettingBank.java +++ b/src/main/java/blackjack/domain/bet/BettingBank.java @@ -9,9 +9,9 @@ public class BettingBank { - private final Map playerMoneyMap; + private final Map playerMoneyMap; - public BettingBank(Map playerMoneyMap) { + public BettingBank(Map playerMoneyMap) { this.playerMoneyMap = playerMoneyMap; } @@ -24,7 +24,7 @@ public PlayerProfitResult calculateProfitResult(PlayerGameResult playerGameResul private Profit calculatePlayerProfit(Player player, PlayerGameResult playerGameResult) { GameResult gameResultOfPlayer = playerGameResult.findGameResultOfPlayer(player); - Money betOfPlayer = playerMoneyMap.get(player); + BetAmout betOfPlayer = playerMoneyMap.get(player); return betOfPlayer.calculateProfit(gameResultOfPlayer.getProfitLeverage()); } } diff --git a/src/main/java/blackjack/view/InputView.java b/src/main/java/blackjack/view/InputView.java index 85af8819a21..f6a5252b275 100644 --- a/src/main/java/blackjack/view/InputView.java +++ b/src/main/java/blackjack/view/InputView.java @@ -2,8 +2,8 @@ import blackjack.InputMapper; import blackjack.domain.DrawDecision; +import blackjack.domain.bet.BetAmout; import blackjack.domain.bet.BettingBank; -import blackjack.domain.bet.Money; import blackjack.domain.player.Player; import blackjack.domain.player.PlayerName; import blackjack.domain.player.Players; @@ -38,8 +38,8 @@ public BettingBank readBetInformation(Players players) { .collect(Collectors.toMap(player -> player, this::readBetAmount))); } - public Money readBetAmount(Player player) { + public BetAmout readBetAmount(Player player) { System.out.println(String.format("%s의 배팅 금액은?", player.getName())); - return new Money(Integer.parseInt(scanner.nextLine())); + return new BetAmout(Integer.parseInt(scanner.nextLine())); } } diff --git a/src/test/java/blackjack/domain/bet/MoneyTest.java b/src/test/java/blackjack/domain/bet/BetAmoutTest.java similarity index 82% rename from src/test/java/blackjack/domain/bet/MoneyTest.java rename to src/test/java/blackjack/domain/bet/BetAmoutTest.java index 54e9056e4c1..f8c1b719318 100644 --- a/src/test/java/blackjack/domain/bet/MoneyTest.java +++ b/src/test/java/blackjack/domain/bet/BetAmoutTest.java @@ -10,13 +10,13 @@ import org.junit.jupiter.params.provider.ValueSource; @DisplayName("돈 테스트") -class MoneyTest { +class BetAmoutTest { @DisplayName("생성 시 범위를 지키지 못하면 생성 검증에 실패한다") @ParameterizedTest @ValueSource(ints = {-1_000_000_001, 1_000_000_001}) void testCreateMoneyWithInvalidRange(int amount) { - assertThatThrownBy(() -> new Money(amount)) + assertThatThrownBy(() -> new BetAmout(amount)) .isInstanceOf(IllegalArgumentException.class) .hasMessage("[ERROR] 금액은 -1000000000부터 1000000000이하까지 가능합니다."); } @@ -26,14 +26,14 @@ void testCreateMoneyWithInvalidRange(int amount) { @ParameterizedTest @ValueSource(ints = {0, 1000, 2000, 30000}) void testCreateMoneyWithValidData(int amount) { - assertThatCode(() -> new Money(amount)) + assertThatCode(() -> new BetAmout(amount)) .doesNotThrowAnyException(); } @DisplayName("돈에 특정 이율을 적용한 Profit을 계산할 수 있다") @Test void testCalculateProfit() { - Money money = new Money(1000); - assertThat(money.calculateProfit(1.5).getValue()).isEqualTo(1500); + BetAmout betAmout = new BetAmout(1000); + assertThat(betAmout.calculateProfit(1.5).getValue()).isEqualTo(1500); } } diff --git a/src/test/java/blackjack/domain/bet/BettingBankTest.java b/src/test/java/blackjack/domain/bet/BettingBankTest.java index f41eb2bc14d..aa21ddf6f90 100644 --- a/src/test/java/blackjack/domain/bet/BettingBankTest.java +++ b/src/test/java/blackjack/domain/bet/BettingBankTest.java @@ -24,9 +24,9 @@ void testCalculatePlayerProfit() { Player player1 = TestPlayerCreator.of("리비", 1, 10); Player player2 = TestPlayerCreator.of("썬", 3, 4, 5, 6); - Map playerMoneyMap = new HashMap<>(); - playerMoneyMap.put(player1, new Money(1000)); - playerMoneyMap.put(player2, new Money(1000)); + Map playerMoneyMap = new HashMap<>(); + playerMoneyMap.put(player1, new BetAmout(1000)); + playerMoneyMap.put(player2, new BetAmout(1000)); BettingBank bettingBank = new BettingBank(playerMoneyMap); Map playerGameResultMap = new HashMap<>(); From b1e9891c5a5cca80af6171dfd11b564407bc9e68 Mon Sep 17 00:00:00 2001 From: libienz Date: Fri, 15 Mar 2024 20:28:00 +0900 Subject: [PATCH 77/91] =?UTF-8?q?fix:=20Money=20=EB=8F=84=EB=A9=94?= =?UTF-8?q?=EC=9D=B8=20=EB=AA=85=EC=84=B8=20=EB=B3=80=EA=B2=BD=EC=97=90=20?= =?UTF-8?q?=EB=94=B0=EB=A5=B8=20=ED=85=8C=EC=8A=A4=ED=8A=B8=20=EC=BD=94?= =?UTF-8?q?=EB=93=9C=20=EC=88=98=EC=A0=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/test/java/blackjack/domain/bet/BetAmoutTest.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/test/java/blackjack/domain/bet/BetAmoutTest.java b/src/test/java/blackjack/domain/bet/BetAmoutTest.java index f8c1b719318..931e5b48a0d 100644 --- a/src/test/java/blackjack/domain/bet/BetAmoutTest.java +++ b/src/test/java/blackjack/domain/bet/BetAmoutTest.java @@ -14,17 +14,17 @@ class BetAmoutTest { @DisplayName("생성 시 범위를 지키지 못하면 생성 검증에 실패한다") @ParameterizedTest - @ValueSource(ints = {-1_000_000_001, 1_000_000_001}) + @ValueSource(ints = {-1, -2, 998, 888, 1_000_000_001}) void testCreateMoneyWithInvalidRange(int amount) { assertThatThrownBy(() -> new BetAmout(amount)) .isInstanceOf(IllegalArgumentException.class) - .hasMessage("[ERROR] 금액은 -1000000000부터 1000000000이하까지 가능합니다."); + .hasMessage("[ERROR] 베팅 금액은 1000부터 1000000000이하까지 가능합니다."); } @DisplayName("생성 검증을 통과하면 생성에 성공한다") @ParameterizedTest - @ValueSource(ints = {0, 1000, 2000, 30000}) + @ValueSource(ints = {1000, 2000, 30000}) void testCreateMoneyWithValidData(int amount) { assertThatCode(() -> new BetAmout(amount)) .doesNotThrowAnyException(); From f68fde2f8998965f211285b54db0292c8a8c4778 Mon Sep 17 00:00:00 2001 From: libienz Date: Fri, 15 Mar 2024 20:34:48 +0900 Subject: [PATCH 78/91] =?UTF-8?q?refactor:=20=EC=86=90=ED=8C=A8=EC=97=90?= =?UTF-8?q?=EC=84=9C=20=EC=97=90=EC=9D=B4=EC=8A=A4=EA=B0=80=20=EB=AA=87?= =?UTF-8?q?=EA=B0=9C=EC=9D=B8=EC=A7=80=20=EC=84=B8=EB=8A=94=20=EA=B8=B0?= =?UTF-8?q?=EB=8A=A5=20=EC=82=AD=EC=A0=9C=20=EA=B0=9C=EC=84=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/card/Hand.java | 6 ------ src/test/java/blackjack/domain/card/HandTest.java | 7 ------- 2 files changed, 13 deletions(-) diff --git a/src/main/java/blackjack/domain/card/Hand.java b/src/main/java/blackjack/domain/card/Hand.java index 1028e89e1b0..67fbd0bb3d5 100644 --- a/src/main/java/blackjack/domain/card/Hand.java +++ b/src/main/java/blackjack/domain/card/Hand.java @@ -30,12 +30,6 @@ public void appendCard(Card card) { cards.add(card); } - public int countAce() { - return (int) cards.stream() - .filter(Card::isAce) - .count(); - } - public boolean hasAce() { return cards.stream() .anyMatch(Card::isAce); diff --git a/src/test/java/blackjack/domain/card/HandTest.java b/src/test/java/blackjack/domain/card/HandTest.java index 66cba216e1c..38978e5d438 100644 --- a/src/test/java/blackjack/domain/card/HandTest.java +++ b/src/test/java/blackjack/domain/card/HandTest.java @@ -40,13 +40,6 @@ void testCountPop() { assertThat(hand.countDraw()).isEqualTo(1); } - @DisplayName("핸드에 에이스 카드가 몇개 있는지 확인할 수 있다") - @Test - void testCountAceInHand() { - Hand hand = TestHandCreator.of(1, 1, 1, 3, 4, 5); - assertThat(hand.countAce()).isEqualTo(3); - } - @DisplayName("핸드에 에이스 카드가 존재하는지 확인할 수 있다") @Test void testHasAceInHand() { From 195c0fa7aae9b380c3b6e00a664b36b222c94ba8 Mon Sep 17 00:00:00 2001 From: libienz Date: Fri, 15 Mar 2024 20:36:54 +0900 Subject: [PATCH 79/91] =?UTF-8?q?refactor:=20Hand=20=EB=8F=84=EB=A9=94?= =?UTF-8?q?=EC=9D=B8=20=EB=A9=94=EC=84=9C=EB=93=9C=20=EB=B0=B0=EC=B9=98=20?= =?UTF-8?q?=EA=B0=9C=EC=84=A0=20=EB=B0=8F=20=EC=A0=91=EA=B7=BC=20=EC=A0=9C?= =?UTF-8?q?=EC=96=B4=EC=9E=90=20=EC=88=98=EC=A0=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/card/Hand.java | 26 +++++++++---------- .../java/blackjack/domain/card/HandTest.java | 14 ---------- 2 files changed, 13 insertions(+), 27 deletions(-) diff --git a/src/main/java/blackjack/domain/card/Hand.java b/src/main/java/blackjack/domain/card/Hand.java index 67fbd0bb3d5..77a499f5bd0 100644 --- a/src/main/java/blackjack/domain/card/Hand.java +++ b/src/main/java/blackjack/domain/card/Hand.java @@ -19,6 +19,14 @@ public static Hand createHandFrom(CardDeck cardDeck) { return new Hand(cardDeck.popCards(INITIAL_HAND_SIZE)); } + public Score calculateScore() { + int sum = calculateCardSummation(); + if (hasAce() && (sum + ACE_WEIGHT) <= BUST_THRESHOLD) { + sum += ACE_WEIGHT; + } + return new Score(sum); + } + public int calculateCardSummation() { return cards.stream() .map(Card::getCardNumber) @@ -26,25 +34,17 @@ public int calculateCardSummation() { .sum(); } - public void appendCard(Card card) { - cards.add(card); - } - - public boolean hasAce() { + private boolean hasAce() { return cards.stream() .anyMatch(Card::isAce); } - public boolean isBlackJack() { - return calculateScore().isMaxScore() && cards.size() == INITIAL_HAND_SIZE; + public void appendCard(Card card) { + cards.add(card); } - public Score calculateScore() { - int sum = calculateCardSummation(); - if (hasAce() && (sum + ACE_WEIGHT) <= BUST_THRESHOLD) { - sum += ACE_WEIGHT; - } - return new Score(sum); + public boolean isBlackJack() { + return calculateScore().isMaxScore() && cards.size() == INITIAL_HAND_SIZE; } public int countDraw() { diff --git a/src/test/java/blackjack/domain/card/HandTest.java b/src/test/java/blackjack/domain/card/HandTest.java index 38978e5d438..a624aefd1e1 100644 --- a/src/test/java/blackjack/domain/card/HandTest.java +++ b/src/test/java/blackjack/domain/card/HandTest.java @@ -40,20 +40,6 @@ void testCountPop() { assertThat(hand.countDraw()).isEqualTo(1); } - @DisplayName("핸드에 에이스 카드가 존재하는지 확인할 수 있다") - @Test - void testHasAceInHand() { - Hand hand = TestHandCreator.of(1, 1, 1, 3, 4, 5); - assertThat(hand.hasAce()).isTrue(); - } - - @DisplayName("핸드에 에이스 카드가 없는 경우를 알 수 있다") - @Test - void testHasNoAceInHand() { - Hand hand = TestHandCreator.of(3, 4, 5); - assertThat(hand.hasAce()).isFalse(); - } - @DisplayName("적절한 점수를 계산할 수 있다 - Ace 카드 없음") @Test void testCalculateScoreWithNoAce() { From bd391fd5ed7b7136bc2cd30ccf6f9f5beed3940a Mon Sep 17 00:00:00 2001 From: libienz Date: Fri, 15 Mar 2024 20:39:49 +0900 Subject: [PATCH 80/91] =?UTF-8?q?refactor:=20=EC=82=AC=EC=9A=A9=EB=90=98?= =?UTF-8?q?=EC=A7=80=20=EC=95=8A=EB=8A=94=20=EB=A9=94=EC=84=9C=EB=93=9C=20?= =?UTF-8?q?=EC=82=AD=EC=A0=9C=20=EA=B0=9C=EC=84=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/player/Players.java | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/src/main/java/blackjack/domain/player/Players.java b/src/main/java/blackjack/domain/player/Players.java index e472e114f3b..b76573739c3 100644 --- a/src/main/java/blackjack/domain/player/Players.java +++ b/src/main/java/blackjack/domain/player/Players.java @@ -13,16 +13,6 @@ public Players(List players) { this.players = players; } - public int countPlayer() { - return players.size(); - } - - public List getPlayerNames() { - return players.stream() - .map(Player::getName) - .toList(); - } - private void validate(List participants) { validateEachPlayerNameUnique(participants); validateEntryNotEmpty(participants); From e85556d342fb47d6c50ad82172242dd622ea6fb7 Mon Sep 17 00:00:00 2001 From: libienz Date: Fri, 15 Mar 2024 23:27:08 +0900 Subject: [PATCH 81/91] =?UTF-8?q?refactor:=20=EB=B7=B0=EB=A1=9C=EC=A7=81?= =?UTF-8?q?=20=EC=9D=B8=ED=85=8C=EA=B7=B8=EB=A0=88=EC=9D=B4=EC=85=98=20?= =?UTF-8?q?=EB=B7=B0=20=EB=A0=88=EC=9D=B4=EC=96=B4=EB=A1=9C=20=EC=9D=B4?= =?UTF-8?q?=EB=8F=99=20=EA=B0=9C=EC=84=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/BlackJackGame.java | 26 +----- .../java/blackjack/view/MessageResolver.java | 85 +++++++++++++------ src/main/java/blackjack/view/OutputView.java | 27 ++---- 3 files changed, 70 insertions(+), 68 deletions(-) diff --git a/src/main/java/blackjack/BlackJackGame.java b/src/main/java/blackjack/BlackJackGame.java index f26f1bb4a64..9e26509edc5 100644 --- a/src/main/java/blackjack/BlackJackGame.java +++ b/src/main/java/blackjack/BlackJackGame.java @@ -2,11 +2,9 @@ import blackjack.domain.Judge; import blackjack.domain.bet.BettingBank; -import blackjack.domain.bet.Profit; import blackjack.domain.card.CardDeck; import blackjack.domain.card.Hand; import blackjack.domain.player.Dealer; -import blackjack.domain.player.Participant; import blackjack.domain.player.Player; import blackjack.domain.player.PlayerName; import blackjack.domain.player.Players; @@ -32,19 +30,15 @@ public void run() { BettingBank bettingBank = inputView.readBetInformation(players); Dealer dealer = new Dealer(Hand.createHandFrom(cardDeck)); Judge judge = new Judge(); - printPlayersInformation(players, dealer); + outputView.printParticipantInitialHand(dealer, players); completePlayersHand(players, cardDeck); dealer.completeHand(cardDeck); - outputView.printDealerPopCount(Dealer.HIT_THRESHOLD, dealer.countDraw()); - - printParticipantScore(dealer); - printPlayersScore(players); + outputView.printCompletedHandsStatus(dealer, players); PlayerGameResult playerGameResult = judge.calculatePlayerGameResult(dealer, players); PlayerProfitResult playerProfitResult = bettingBank.calculateProfitResult(playerGameResult); - Profit profit = playerProfitResult.calculateDealerProfit(); - outputView.printProfitResults(playerProfitResult, profit); + outputView.printProfitResults(playerProfitResult); } private Players initPlayers(CardDeck cardDeck) { @@ -54,12 +48,6 @@ private Players initPlayers(CardDeck cardDeck) { .toList()); } - private void printPlayersInformation(Players players, Dealer dealer) { - outputView.printHandOutEvent(players, Hand.INITIAL_HAND_SIZE); - outputView.printDealerInitialHand(dealer); - players.getPlayers().forEach(outputView::printPlayerHand); - } - private void completePlayersHand(Players players, CardDeck cardDeck) { players.getPlayers().forEach(player -> completePlayerHand(player, cardDeck)); } @@ -70,12 +58,4 @@ private void completePlayerHand(Player participant, CardDeck cardDeck) { outputView.printPlayerHand(participant); } } - - private void printPlayersScore(Players players) { - players.getPlayers().forEach(this::printParticipantScore); - } - - private void printParticipantScore(Participant participant) { - outputView.printParticipantScore(participant, participant.calculateHandScore()); - } } diff --git a/src/main/java/blackjack/view/MessageResolver.java b/src/main/java/blackjack/view/MessageResolver.java index 27c0d4ee93e..3b1d4d0e973 100644 --- a/src/main/java/blackjack/view/MessageResolver.java +++ b/src/main/java/blackjack/view/MessageResolver.java @@ -1,9 +1,9 @@ package blackjack.view; +import static blackjack.domain.card.Hand.INITIAL_HAND_SIZE; import static blackjack.view.CardDescription.NUMBER_NAME; import static blackjack.view.CardDescription.SHAPE_NAME; -import blackjack.domain.Score; import blackjack.domain.bet.Profit; import blackjack.domain.card.Card; import blackjack.domain.card.CardNumber; @@ -22,9 +22,43 @@ public class MessageResolver { private static final String LINE_SEPARATOR = System.lineSeparator(); private static final String SEPARATOR = ", "; - public String resolveHandOutEventMessage(Players players, int handOutCount) { + public String resolvePlayerHandMessage(Participant participant) { + return String.format("%s 카드: %s", participant.getName(), resolveHandMessage(participant.getHand())); + } + + public String resolveInitialHandsMessage(Dealer dealer, Players players) { + return new StringBuilder() + .append(resolveHandOutEventMessage(players)) + .append(LINE_SEPARATOR) + .append(resolveDealerHandMessage(dealer)) + .append(LINE_SEPARATOR) + .append(resolvePlayersHandMessage(players)) + .toString(); + } + + public String resolveCompletedHandsMessage(Dealer dealer, Players players) { + return new StringBuilder() + .append(resolveDealerPopCountMessage(dealer)) + .append(resolvePlayerScore(dealer)) + .append(LINE_SEPARATOR) + .append(resolvePlayersScore(players)) + .toString(); + } + + public String resolveProfitResultMessage(PlayerProfitResult playerProfitResult) { + return new StringBuilder() + .append(LINE_SEPARATOR) + .append("##최종 수익") + .append(LINE_SEPARATOR) + .append(resolveParticipantProfitMessage(playerProfitResult.calculateDealerProfit())) + .append(LINE_SEPARATOR) + .append(resolvePlayerProfitMessage(playerProfitResult)) + .toString(); + } + + private String resolveHandOutEventMessage(Players players) { String namesMessage = resolveNamesMessage(players); - String message = String.format("딜러와 %s에게 %d장을 나누었습니다.", namesMessage, handOutCount); + String message = String.format("딜러와 %s에게 %d장을 나누었습니다.", namesMessage, INITIAL_HAND_SIZE); return String.join("", LINE_SEPARATOR, message); } @@ -34,8 +68,15 @@ private String resolveNamesMessage(Players players) { .collect(Collectors.joining(SEPARATOR)); } - public String resolvePlayerHandMessage(Participant participant) { - return String.format("%s 카드: %s", participant.getName(), resolveHandMessage(participant.getHand())); + private String resolveDealerHandMessage(Dealer dealer) { + Card card = dealer.getHand().getCards().get(0); + return String.format("%s: %s", dealer.getName(), resolveCardMessage(card)); + } + + private String resolvePlayersHandMessage(Players players) { + return players.getPlayers().stream() + .map(this::resolvePlayerHandMessage) + .collect(Collectors.joining(LINE_SEPARATOR)); } private String resolveHandMessage(Hand hand) { @@ -50,45 +91,37 @@ private String resolveCardMessage(Card card) { return String.format("%s%s", NUMBER_NAME.get(cardNumber), SHAPE_NAME.get(cardShape)); } - public String resolveDealerHandMessage(Dealer dealer) { - Card card = dealer.getHand().getCards().get(0); - return String.format("%s: %s", dealer.getName(), resolveCardMessage(card)); - } - - public String resolveDealerPopCountMessage(int dealerDrawThreshold, int popCount) { - if (popCount > 0) { - String message = String.format("딜러는 %d이하라 %d장의 카드를 더 받았습니다.", dealerDrawThreshold, popCount); + private String resolveDealerPopCountMessage(Dealer dealer) { + if (dealer.countDraw() > 0) { + String message = String.format("딜러는 %d이하라 %d장의 카드를 더 받았습니다.", Dealer.HIT_THRESHOLD, dealer.countDraw()); return String.join("", LINE_SEPARATOR, message, LINE_SEPARATOR); } return ""; } - public String resolveParticipantScoreMessage(Participant participant, Score score) { - String handMessage = resolvePlayerHandMessage(participant); - return String.format("%s - 결과: %d", handMessage, score.getValue()); + private String resolvePlayersScore(Players players) { + return players.getPlayers().stream() + .map(this::resolvePlayerScore) + .collect(Collectors.joining(LINE_SEPARATOR)); } - public String resolveProfitResultMessage(PlayerProfitResult playerProfitResult, Profit dealerProfit) { - return new StringBuilder(LINE_SEPARATOR) - .append("##최종 수익") - .append(LINE_SEPARATOR) - .append(resolveDealerProfitMessage(dealerProfit)) - .append(LINE_SEPARATOR) - .append(resolvePlayerProfitMessage(playerProfitResult)).toString(); + private String resolvePlayerScore(Participant participant) { + String handMessage = resolvePlayerHandMessage(participant); + return String.format("%s - 결과: %d", handMessage, participant.calculateHandScore().getValue()); } - public String resolveDealerProfitMessage(Profit dealerProfit) { + private String resolveParticipantProfitMessage(Profit dealerProfit) { return String.format("딜러: %d", dealerProfit.getValue()); } - public String resolvePlayerProfitMessage(PlayerProfitResult playerProfitResult) { + private String resolvePlayerProfitMessage(PlayerProfitResult playerProfitResult) { Map playerProfitMap = playerProfitResult.getPlayerProfitMap(); return playerProfitMap.entrySet().stream() .map(this::resolveSingleProfitMessage) .collect(Collectors.joining(LINE_SEPARATOR)); } - public String resolveSingleProfitMessage(Map.Entry playerProfit) { + private String resolveSingleProfitMessage(Map.Entry playerProfit) { String playerName = playerProfit.getKey().getName(); int profit = playerProfit.getValue().getValue(); return String.format("%s: %d", playerName, profit); diff --git a/src/main/java/blackjack/view/OutputView.java b/src/main/java/blackjack/view/OutputView.java index c68ef129830..09961a18dff 100644 --- a/src/main/java/blackjack/view/OutputView.java +++ b/src/main/java/blackjack/view/OutputView.java @@ -1,9 +1,6 @@ package blackjack.view; -import blackjack.domain.Score; -import blackjack.domain.bet.Profit; import blackjack.domain.player.Dealer; -import blackjack.domain.player.Participant; import blackjack.domain.player.Player; import blackjack.domain.player.Players; import blackjack.domain.result.PlayerProfitResult; @@ -16,27 +13,19 @@ public OutputView(MessageResolver messageResolver) { this.messageResolver = messageResolver; } - public void printHandOutEvent(Players players, int handedCount) { - System.out.println(messageResolver.resolveHandOutEventMessage(players, handedCount)); + public void printParticipantInitialHand(Dealer dealer, Players players) { + System.out.println(messageResolver.resolveInitialHandsMessage(dealer, players)); } - public void printPlayerHand(Player participant) { - System.out.println(messageResolver.resolvePlayerHandMessage(participant)); + public void printPlayerHand(Player player) { + System.out.println(messageResolver.resolvePlayerHandMessage(player)); } - public void printDealerPopCount(int dealerPopThreshold, int count) { - System.out.println(messageResolver.resolveDealerPopCountMessage(dealerPopThreshold, count)); + public void printCompletedHandsStatus(Dealer dealer, Players players) { + System.out.println(messageResolver.resolveCompletedHandsMessage(dealer, players)); } - public void printParticipantScore(Participant participant, Score score) { - System.out.println(messageResolver.resolveParticipantScoreMessage(participant, score)); - } - - public void printDealerInitialHand(Dealer dealer) { - System.out.println(messageResolver.resolveDealerHandMessage(dealer)); - } - - public void printProfitResults(PlayerProfitResult playerProfitResult, Profit dealerProfit) { - System.out.println(messageResolver.resolveProfitResultMessage(playerProfitResult, dealerProfit)); + public void printProfitResults(PlayerProfitResult playerProfitResult) { + System.out.println(messageResolver.resolveProfitResultMessage(playerProfitResult)); } } From 97604061da74845350e8da4cb15e72ccfda7fd58 Mon Sep 17 00:00:00 2001 From: libienz Date: Sat, 16 Mar 2024 01:49:16 +0900 Subject: [PATCH 82/91] =?UTF-8?q?feat:=20Participant=EC=9D=98=20=ED=95=B8?= =?UTF-8?q?=EB=93=9C=20=EA=B8=B0=EB=B0=98=20=EB=B9=84=EA=B5=90=20=EB=A9=94?= =?UTF-8?q?=EC=84=9C=EB=93=9C=20=EC=B6=94=EA=B0=80=20=20=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../blackjack/domain/player/Participant.java | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/src/main/java/blackjack/domain/player/Participant.java b/src/main/java/blackjack/domain/player/Participant.java index 39a4f8f5bbc..61c6d4457f7 100644 --- a/src/main/java/blackjack/domain/player/Participant.java +++ b/src/main/java/blackjack/domain/player/Participant.java @@ -33,10 +33,26 @@ public boolean isBusted() { return hand.calculateScore().isBustScore(); } + public boolean isNotBusted() { + return !hand.calculateScore().isBustScore(); + } + public boolean hasBlackJackHand() { return hand.isBlackJack(); } + public boolean hasNoBlackJackHand() { + return !hand.isBlackJack(); + } + + public boolean hasScoreAbove(Participant other) { + return this.calculateHandScore().isAbove(other.calculateHandScore()); + } + + public boolean hasSameScore(Participant other) { + return this.calculateHandScore().equals(other.calculateHandScore()); + } + @Override public boolean equals(Object o) { if (this == o) { From 274a28185106ab02ad9acb6b1dad7df8ec03c0d1 Mon Sep 17 00:00:00 2001 From: libienz Date: Sat, 16 Mar 2024 01:49:47 +0900 Subject: [PATCH 83/91] =?UTF-8?q?feat:=20GameResult=20=ED=8C=90=EC=A0=95?= =?UTF-8?q?=20=EC=B1=85=EC=9E=84=20GameResult=20=EB=8F=84=EB=A9=94?= =?UTF-8?q?=EC=9D=B8=EC=97=90=EC=84=9C=20=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../blackjack/domain/result/GameResult.java | 25 ++++++-- .../domain/result/GameResultTest.java | 58 +++++++++++++++++++ 2 files changed, 78 insertions(+), 5 deletions(-) create mode 100644 src/test/java/blackjack/domain/result/GameResultTest.java diff --git a/src/main/java/blackjack/domain/result/GameResult.java b/src/main/java/blackjack/domain/result/GameResult.java index 44471d6a9f5..25a6a61806f 100644 --- a/src/main/java/blackjack/domain/result/GameResult.java +++ b/src/main/java/blackjack/domain/result/GameResult.java @@ -1,16 +1,31 @@ package blackjack.domain.result; +import blackjack.domain.player.Dealer; +import blackjack.domain.player.Player; +import java.util.Arrays; +import java.util.function.BiPredicate; + public enum GameResult { - BLACKJACK_WIN(1.5), - PLAYER_WIN(1.0), - PLAYER_LOSE(-1.0), - PUSH(0.0); + BLACKJACK_WIN(1.5, (dealer, player) -> dealer.hasNoBlackJackHand() && player.hasBlackJackHand()), + PLAYER_LOSE(1.0, (dealer, player) -> player.isBusted() || dealer.hasScoreAbove(player)), + PLAYER_WIN(-1.0, (dealer, player) -> (player.isNotBusted() && (dealer.isBusted() || player.hasScoreAbove(dealer)))), + PUSH(0.0, (dealer, player) -> player.isNotBusted() && dealer.isNotBusted() && player.hasSameScore(dealer)); + private final double profitLeverage; + private final BiPredicate biPredicate; - GameResult(double profitLeverage) { + GameResult(double profitLeverage, BiPredicate biPredicate) { this.profitLeverage = profitLeverage; + this.biPredicate = biPredicate; + } + + public static GameResult of(Dealer dealer, Player player) { + return Arrays.stream(values()) + .filter(gameResult -> gameResult.biPredicate.test(dealer, player)) + .findFirst() + .orElseThrow(() -> new IllegalArgumentException("[INTERNAL ERROR] 게임 결과를 판정할 수 없습니다")); } public double getProfitLeverage() { diff --git a/src/test/java/blackjack/domain/result/GameResultTest.java b/src/test/java/blackjack/domain/result/GameResultTest.java new file mode 100644 index 00000000000..58d15049a72 --- /dev/null +++ b/src/test/java/blackjack/domain/result/GameResultTest.java @@ -0,0 +1,58 @@ +package blackjack.domain.result; + +import static blackjack.domain.result.GameResult.BLACKJACK_WIN; +import static blackjack.domain.result.GameResult.PLAYER_LOSE; +import static blackjack.domain.result.GameResult.PLAYER_WIN; +import static blackjack.domain.result.GameResult.PUSH; +import static org.assertj.core.api.Assertions.assertThat; + +import blackjack.domain.card.TestHandCreator; +import blackjack.domain.player.Dealer; +import blackjack.domain.player.Player; +import blackjack.domain.player.TestPlayerCreator; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +@DisplayName("게임 결과 테스트") +class GameResultTest { + + @DisplayName("플레이어 블랙잭이고 딜러가 블랙잭이 아니면 플레이어가 블랙잭 승리를 한다.") + @Test + void testPlayerBlackJackWin() { + Player player = TestPlayerCreator.of("리비", 1, 10); + Dealer dealer = new Dealer(TestHandCreator.of(3, 4)); + assertThat(GameResult.of(dealer, player)).isEqualTo(BLACKJACK_WIN); + } + + @DisplayName("딜러와 플레이어 모두 21점이더라도 블랙잭 핸드가 있다면 블랙잭쪽이 이긴다.") + @Test + void testPlayerBlackJackWinMaxScore() { + Player player = TestPlayerCreator.of("리비", 1, 10); + Dealer dealer = new Dealer(TestHandCreator.of(9, 2, 10)); + assertThat(GameResult.of(dealer, player)).isEqualTo(BLACKJACK_WIN); + } + + @DisplayName("딜러와 플레이어 모두 블랙잭인 경우 결과는 PUSH이다.") + @Test + void testPlayerAndDealerBlackJack() { + Player player = TestPlayerCreator.of("리비", 1, 10); + Dealer dealer = new Dealer(TestHandCreator.of(1, 10)); + assertThat(GameResult.of(dealer, player)).isEqualTo(PUSH); + } + + @DisplayName("딜러가 버스트 되고 플레이어가 살아있다면 플레이어가 승리한다") + @Test + void testPlayerWin() { + Player player = TestPlayerCreator.of("리비", 10, 10); + Dealer dealer = new Dealer(TestHandCreator.of(2, 10)); + assertThat(GameResult.of(dealer, player)).isEqualTo(PLAYER_WIN); + } + + @DisplayName("딜러 플레이어 모두 버스트 되지 않은 경우 딜러의 점수보다 플레이어의 점수가 낮다면 플레이어가 패한다") + @Test + void testPlayerLose() { + Player player = TestPlayerCreator.of("리비", 2, 10); + Dealer dealer = new Dealer(TestHandCreator.of(10, 10)); + assertThat(GameResult.of(dealer, player)).isEqualTo(PLAYER_LOSE); + } +} From a5cf7a0270a16e77c47f8cd66b66447b40603e5e Mon Sep 17 00:00:00 2001 From: libienz Date: Sat, 16 Mar 2024 02:12:19 +0900 Subject: [PATCH 84/91] =?UTF-8?q?fix:=20GameResult=20=EB=A0=88=EB=B2=84?= =?UTF-8?q?=EB=A6=AC=EC=A7=80=20=EC=88=98=EC=A0=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/Judge.java | 40 ------------ .../blackjack/domain/result/GameResult.java | 4 +- src/test/java/blackjack/domain/JudgeTest.java | 65 ------------------- 3 files changed, 2 insertions(+), 107 deletions(-) delete mode 100644 src/main/java/blackjack/domain/Judge.java delete mode 100644 src/test/java/blackjack/domain/JudgeTest.java diff --git a/src/main/java/blackjack/domain/Judge.java b/src/main/java/blackjack/domain/Judge.java deleted file mode 100644 index 06076cc5976..00000000000 --- a/src/main/java/blackjack/domain/Judge.java +++ /dev/null @@ -1,40 +0,0 @@ -package blackjack.domain; - -import static blackjack.domain.result.GameResult.BLACKJACK_WIN; -import static blackjack.domain.result.GameResult.PLAYER_LOSE; -import static blackjack.domain.result.GameResult.PLAYER_WIN; -import static blackjack.domain.result.GameResult.PUSH; - -import blackjack.domain.player.Dealer; -import blackjack.domain.player.Player; -import blackjack.domain.player.Players; -import blackjack.domain.result.GameResult; -import blackjack.domain.result.PlayerGameResult; -import java.util.stream.Collectors; - -public class Judge { - - public PlayerGameResult calculatePlayerGameResult(Dealer dealer, Players players) { - return new PlayerGameResult(players.getPlayers().stream() - .collect(Collectors.toMap(player -> player, player -> calculatePlayerResult(dealer, player)))); - } - - public GameResult calculatePlayerResult(Dealer dealer, Player player) { - Score playerScore = player.calculateHandScore(); - Score dealerScore = dealer.calculateHandScore(); - - if (player.hasBlackJackHand() && !dealer.hasBlackJackHand()) { - return BLACKJACK_WIN; - } - if (player.isBusted()) { - return PLAYER_LOSE; - } - if (dealer.isBusted() || playerScore.isAbove(dealerScore)) { - return PLAYER_WIN; - } - if (playerScore.equals(dealerScore)) { - return PUSH; - } - return PLAYER_LOSE; - } -} diff --git a/src/main/java/blackjack/domain/result/GameResult.java b/src/main/java/blackjack/domain/result/GameResult.java index 25a6a61806f..a854c886c9f 100644 --- a/src/main/java/blackjack/domain/result/GameResult.java +++ b/src/main/java/blackjack/domain/result/GameResult.java @@ -8,8 +8,8 @@ public enum GameResult { BLACKJACK_WIN(1.5, (dealer, player) -> dealer.hasNoBlackJackHand() && player.hasBlackJackHand()), - PLAYER_LOSE(1.0, (dealer, player) -> player.isBusted() || dealer.hasScoreAbove(player)), - PLAYER_WIN(-1.0, (dealer, player) -> (player.isNotBusted() && (dealer.isBusted() || player.hasScoreAbove(dealer)))), + PLAYER_LOSE(-1.0, (dealer, player) -> player.isBusted() || dealer.hasScoreAbove(player)), + PLAYER_WIN(1.0, (dealer, player) -> (player.isNotBusted() && (dealer.isBusted() || player.hasScoreAbove(dealer)))), PUSH(0.0, (dealer, player) -> player.isNotBusted() && dealer.isNotBusted() && player.hasSameScore(dealer)); diff --git a/src/test/java/blackjack/domain/JudgeTest.java b/src/test/java/blackjack/domain/JudgeTest.java deleted file mode 100644 index 9ebc404ccab..00000000000 --- a/src/test/java/blackjack/domain/JudgeTest.java +++ /dev/null @@ -1,65 +0,0 @@ -package blackjack.domain; - -import static blackjack.domain.result.GameResult.BLACKJACK_WIN; -import static blackjack.domain.result.GameResult.PLAYER_LOSE; -import static blackjack.domain.result.GameResult.PLAYER_WIN; -import static blackjack.domain.result.GameResult.PUSH; -import static org.assertj.core.api.Assertions.assertThat; - -import blackjack.domain.card.TestHandCreator; -import blackjack.domain.player.Dealer; -import blackjack.domain.player.Player; -import blackjack.domain.player.TestPlayerCreator; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.DisplayName; -import org.junit.jupiter.api.Test; - -class JudgeTest { - - private Judge judge; - - @BeforeEach - void setUp() { - judge = new Judge(); - } - - @DisplayName("플레이어 블랙잭이고 딜러가 블랙잭이 아니면 플레이어가 블랙잭 승리를 한다.") - @Test - void testPlayerBlackJackWin() { - Player player = TestPlayerCreator.of("리비", 1, 10); - Dealer dealer = new Dealer(TestHandCreator.of(3, 4)); - assertThat(judge.calculatePlayerResult(dealer, player)).isEqualTo(BLACKJACK_WIN); - } - - @DisplayName("딜러와 플레이어 모두 21점이더라도 블랙잭 핸드가 있다면 블랙잭쪽이 이긴다.") - @Test - void testPlayerBlackJackWinMaxScore() { - Player player = TestPlayerCreator.of("리비", 1, 10); - Dealer dealer = new Dealer(TestHandCreator.of(9, 2, 10)); - assertThat(judge.calculatePlayerResult(dealer, player)).isEqualTo(BLACKJACK_WIN); - } - - @DisplayName("딜러와 플레이어 모두 블랙잭인 경우 결과는 PUSH이다.") - @Test - void testPlayerAndDealerBlackJack() { - Player player = TestPlayerCreator.of("리비", 1, 10); - Dealer dealer = new Dealer(TestHandCreator.of(1, 10)); - assertThat(judge.calculatePlayerResult(dealer, player)).isEqualTo(PUSH); - } - - @DisplayName("딜러가 버스트 되고 플레이어가 살아있다면 플레이어가 승리한다") - @Test - void testPlayerWin() { - Player player = TestPlayerCreator.of("리비", 10, 10); - Dealer dealer = new Dealer(TestHandCreator.of(2, 10)); - assertThat(judge.calculatePlayerResult(dealer, player)).isEqualTo(PLAYER_WIN); - } - - @DisplayName("딜러 플레이어 모두 버스트 되지 않은 경우 딜러의 점수보다 플레이어의 점수가 낮다면 플레이어가 패한다") - @Test - void testPlayerLose() { - Player player = TestPlayerCreator.of("리비", 2, 10); - Dealer dealer = new Dealer(TestHandCreator.of(10, 10)); - assertThat(judge.calculatePlayerResult(dealer, player)).isEqualTo(PLAYER_LOSE); - } -} From 428842099f5f1bfe64a273b2e4de2d949f310971 Mon Sep 17 00:00:00 2001 From: libienz Date: Sat, 16 Mar 2024 02:13:03 +0900 Subject: [PATCH 85/91] =?UTF-8?q?refactor:=20ProfitResult=20=EC=83=9D?= =?UTF-8?q?=EC=84=B1=20=EC=8B=9C=20=EB=94=9C=EB=9F=AC=EB=A5=BC=20=EB=B0=9B?= =?UTF-8?q?=EB=8F=84=EB=A1=9D=20=EA=B0=9C=EC=84=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/blackjack/domain/bet/BettingBank.java | 14 +++++++------- .../blackjack/domain/bet/BettingBankTest.java | 15 ++++++--------- 2 files changed, 13 insertions(+), 16 deletions(-) diff --git a/src/main/java/blackjack/domain/bet/BettingBank.java b/src/main/java/blackjack/domain/bet/BettingBank.java index 3160d80a6d6..63399a47ca7 100644 --- a/src/main/java/blackjack/domain/bet/BettingBank.java +++ b/src/main/java/blackjack/domain/bet/BettingBank.java @@ -1,8 +1,8 @@ package blackjack.domain.bet; +import blackjack.domain.player.Dealer; import blackjack.domain.player.Player; import blackjack.domain.result.GameResult; -import blackjack.domain.result.PlayerGameResult; import blackjack.domain.result.PlayerProfitResult; import java.util.Map; import java.util.stream.Collectors; @@ -15,16 +15,16 @@ public BettingBank(Map playerMoneyMap) { this.playerMoneyMap = playerMoneyMap; } - public PlayerProfitResult calculateProfitResult(PlayerGameResult playerGameResult) { + public PlayerProfitResult calculateProfitResult(Dealer dealer) { return new PlayerProfitResult(playerMoneyMap.keySet().stream() .collect(Collectors.toMap( player -> player, - player -> calculatePlayerProfit(player, playerGameResult)))); + player -> (calculatePlayerProfit(player, dealer))))); } - private Profit calculatePlayerProfit(Player player, PlayerGameResult playerGameResult) { - GameResult gameResultOfPlayer = playerGameResult.findGameResultOfPlayer(player); - BetAmout betOfPlayer = playerMoneyMap.get(player); - return betOfPlayer.calculateProfit(gameResultOfPlayer.getProfitLeverage()); + private Profit calculatePlayerProfit(Player player, Dealer dealer) { + GameResult gameResult = GameResult.of(dealer, player); + BetAmout betAmout = playerMoneyMap.get(player); + return betAmout.calculateProfit(gameResult.getProfitLeverage()); } } diff --git a/src/test/java/blackjack/domain/bet/BettingBankTest.java b/src/test/java/blackjack/domain/bet/BettingBankTest.java index aa21ddf6f90..2a8947f707e 100644 --- a/src/test/java/blackjack/domain/bet/BettingBankTest.java +++ b/src/test/java/blackjack/domain/bet/BettingBankTest.java @@ -1,14 +1,13 @@ package blackjack.domain.bet; -import static blackjack.domain.result.GameResult.BLACKJACK_WIN; -import static blackjack.domain.result.GameResult.PLAYER_LOSE; import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.assertAll; +import blackjack.domain.card.TestHandCreator; +import blackjack.domain.player.Dealer; import blackjack.domain.player.Player; import blackjack.domain.player.TestPlayerCreator; import blackjack.domain.result.GameResult; -import blackjack.domain.result.PlayerGameResult; import blackjack.domain.result.PlayerProfitResult; import java.util.HashMap; import java.util.Map; @@ -22,19 +21,17 @@ class BettingBankTest { @Test void testCalculatePlayerProfit() { Player player1 = TestPlayerCreator.of("리비", 1, 10); - Player player2 = TestPlayerCreator.of("썬", 3, 4, 5, 6); + Player player2 = TestPlayerCreator.of("썬", 3, 4); + Dealer dealer = new Dealer(TestHandCreator.of(3, 4, 5)); Map playerMoneyMap = new HashMap<>(); playerMoneyMap.put(player1, new BetAmout(1000)); playerMoneyMap.put(player2, new BetAmout(1000)); BettingBank bettingBank = new BettingBank(playerMoneyMap); - Map playerGameResultMap = new HashMap<>(); - playerGameResultMap.put(player1, BLACKJACK_WIN); - playerGameResultMap.put(player2, PLAYER_LOSE); - PlayerGameResult playerGameResult = new PlayerGameResult(playerGameResultMap); + PlayerProfitResult playerProfitResult = bettingBank.calculateProfitResult(dealer); - PlayerProfitResult playerProfitResult = bettingBank.calculateProfitResult(playerGameResult); + assertThat(GameResult.of(dealer, player2)).isEqualTo(GameResult.PLAYER_LOSE); assertAll( () -> assertThat(playerProfitResult.findProfitOfPlayer(player1).getValue()).isEqualTo(1500), () -> assertThat(playerProfitResult.findProfitOfPlayer(player2).getValue()).isEqualTo(-1000) From 44b2c55df8b9bb556ce09b2f0722e1f854ac7a6d Mon Sep 17 00:00:00 2001 From: libienz Date: Sat, 16 Mar 2024 02:14:14 +0900 Subject: [PATCH 86/91] =?UTF-8?q?refactor:=20=EA=B0=9C=EC=84=A0=EB=90=9C?= =?UTF-8?q?=20=EB=B2=84=EC=A0=84=EC=9C=BC=EB=A1=9C=20=EC=88=98=EC=9D=B5=20?= =?UTF-8?q?=EA=B3=84=EC=82=B0=ED=95=98=EB=8F=84=EB=A1=9D=20=EA=B0=9C?= =?UTF-8?q?=EC=84=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/BlackJackGame.java | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/src/main/java/blackjack/BlackJackGame.java b/src/main/java/blackjack/BlackJackGame.java index 9e26509edc5..53451e5fb68 100644 --- a/src/main/java/blackjack/BlackJackGame.java +++ b/src/main/java/blackjack/BlackJackGame.java @@ -1,6 +1,5 @@ package blackjack; -import blackjack.domain.Judge; import blackjack.domain.bet.BettingBank; import blackjack.domain.card.CardDeck; import blackjack.domain.card.Hand; @@ -8,7 +7,6 @@ import blackjack.domain.player.Player; import blackjack.domain.player.PlayerName; import blackjack.domain.player.Players; -import blackjack.domain.result.PlayerGameResult; import blackjack.domain.result.PlayerProfitResult; import blackjack.view.InputView; import blackjack.view.OutputView; @@ -29,15 +27,13 @@ public void run() { Players players = initPlayers(cardDeck); BettingBank bettingBank = inputView.readBetInformation(players); Dealer dealer = new Dealer(Hand.createHandFrom(cardDeck)); - Judge judge = new Judge(); outputView.printParticipantInitialHand(dealer, players); completePlayersHand(players, cardDeck); dealer.completeHand(cardDeck); outputView.printCompletedHandsStatus(dealer, players); - PlayerGameResult playerGameResult = judge.calculatePlayerGameResult(dealer, players); - PlayerProfitResult playerProfitResult = bettingBank.calculateProfitResult(playerGameResult); + PlayerProfitResult playerProfitResult = bettingBank.calculateProfitResult(dealer); outputView.printProfitResults(playerProfitResult); } From d6b7005d84c7c5a605277bbb2934a7846d1b8b05 Mon Sep 17 00:00:00 2001 From: libienz Date: Sat, 16 Mar 2024 02:15:20 +0900 Subject: [PATCH 87/91] =?UTF-8?q?refactor:=20=EC=82=AC=EC=9A=A9=EB=90=98?= =?UTF-8?q?=EC=A7=80=20=EC=95=8A=EB=8A=94=20=ED=81=B4=EB=9E=98=EC=8A=A4=20?= =?UTF-8?q?=EC=82=AD=EC=A0=9C=20=EA=B0=9C=EC=84=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../domain/result/PlayerGameResult.java | 17 ----------- .../domain/result/PlayerGameResultTest.java | 28 ------------------- 2 files changed, 45 deletions(-) delete mode 100644 src/main/java/blackjack/domain/result/PlayerGameResult.java delete mode 100644 src/test/java/blackjack/domain/result/PlayerGameResultTest.java diff --git a/src/main/java/blackjack/domain/result/PlayerGameResult.java b/src/main/java/blackjack/domain/result/PlayerGameResult.java deleted file mode 100644 index 304d885dc78..00000000000 --- a/src/main/java/blackjack/domain/result/PlayerGameResult.java +++ /dev/null @@ -1,17 +0,0 @@ -package blackjack.domain.result; - -import blackjack.domain.player.Player; -import java.util.Map; - -public class PlayerGameResult { - - private final Map playerGameResultMap; - - public PlayerGameResult(Map playerGameResultMap) { - this.playerGameResultMap = playerGameResultMap; - } - - public GameResult findGameResultOfPlayer(Player player) { - return playerGameResultMap.get(player); - } -} diff --git a/src/test/java/blackjack/domain/result/PlayerGameResultTest.java b/src/test/java/blackjack/domain/result/PlayerGameResultTest.java deleted file mode 100644 index 5f51c8df8ad..00000000000 --- a/src/test/java/blackjack/domain/result/PlayerGameResultTest.java +++ /dev/null @@ -1,28 +0,0 @@ -package blackjack.domain.result; - -import static org.assertj.core.api.Assertions.assertThat; - -import blackjack.domain.player.Player; -import blackjack.domain.player.TestPlayerCreator; -import java.util.HashMap; -import java.util.Map; -import org.junit.jupiter.api.DisplayName; -import org.junit.jupiter.api.Test; - -@DisplayName("플레이어들 게임 결과 도메인 테스트") -class PlayerGameResultTest { - - @DisplayName("특정 플레이어의 결과를 조회할 수 있다") - @Test - void testFindPlayerResult() { - Player player1 = TestPlayerCreator.of("리비", 3, 4, 5); - Player player2 = TestPlayerCreator.of("썬", 3, 4); - - Map playerResultMap = new HashMap<>(); - playerResultMap.put(player1, GameResult.PLAYER_WIN); - playerResultMap.put(player2, GameResult.PLAYER_LOSE); - - PlayerGameResult playerGameResult = new PlayerGameResult(playerResultMap); - assertThat(playerGameResult.findGameResultOfPlayer(player1)).isEqualTo(GameResult.PLAYER_WIN); - } -} From 996c3133bb9ff43f7b73add8a3ad0b349cc2c21c Mon Sep 17 00:00:00 2001 From: libienz Date: Sat, 16 Mar 2024 02:17:17 +0900 Subject: [PATCH 88/91] =?UTF-8?q?style:=20=ED=81=B4=EB=9E=98=EC=8A=A4=20?= =?UTF-8?q?=EB=AA=85=20=EC=88=98=EC=A0=95=20=EA=B0=9C=EC=84=A0=20BettingBa?= =?UTF-8?q?nk=20->=20PlayerBets,=20PlayerProfitResult=20->=20PlayerProfits?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/BlackJackGame.java | 10 +++++----- .../bet/{BettingBank.java => PlayerBets.java} | 10 +++++----- ...{PlayerProfitResult.java => PlayerProfits.java} | 4 ++-- src/main/java/blackjack/view/InputView.java | 6 +++--- src/main/java/blackjack/view/MessageResolver.java | 12 ++++++------ src/main/java/blackjack/view/OutputView.java | 6 +++--- .../{BettingBankTest.java => PlayerBetsTest.java} | 12 ++++++------ ...rofitResultTest.java => PlayerProfitsTest.java} | 14 +++++++------- 8 files changed, 37 insertions(+), 37 deletions(-) rename src/main/java/blackjack/domain/bet/{BettingBank.java => PlayerBets.java} (73%) rename src/main/java/blackjack/domain/result/{PlayerProfitResult.java => PlayerProfits.java} (87%) rename src/test/java/blackjack/domain/bet/{BettingBankTest.java => PlayerBetsTest.java} (72%) rename src/test/java/blackjack/domain/result/{PlayerProfitResultTest.java => PlayerProfitsTest.java} (74%) diff --git a/src/main/java/blackjack/BlackJackGame.java b/src/main/java/blackjack/BlackJackGame.java index 53451e5fb68..c3f3788f57a 100644 --- a/src/main/java/blackjack/BlackJackGame.java +++ b/src/main/java/blackjack/BlackJackGame.java @@ -1,13 +1,13 @@ package blackjack; -import blackjack.domain.bet.BettingBank; +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.PlayerProfitResult; +import blackjack.domain.result.PlayerProfits; import blackjack.view.InputView; import blackjack.view.OutputView; import java.util.List; @@ -25,7 +25,7 @@ public BlackJackGame(InputView inputView, OutputView outputView) { public void run() { CardDeck cardDeck = CardDeck.createShuffledDeck(); Players players = initPlayers(cardDeck); - BettingBank bettingBank = inputView.readBetInformation(players); + PlayerBets playerBets = inputView.readBetInformation(players); Dealer dealer = new Dealer(Hand.createHandFrom(cardDeck)); outputView.printParticipantInitialHand(dealer, players); @@ -33,8 +33,8 @@ public void run() { dealer.completeHand(cardDeck); outputView.printCompletedHandsStatus(dealer, players); - PlayerProfitResult playerProfitResult = bettingBank.calculateProfitResult(dealer); - outputView.printProfitResults(playerProfitResult); + PlayerProfits playerProfits = playerBets.calculateProfitResult(dealer); + outputView.printProfitResults(playerProfits); } private Players initPlayers(CardDeck cardDeck) { diff --git a/src/main/java/blackjack/domain/bet/BettingBank.java b/src/main/java/blackjack/domain/bet/PlayerBets.java similarity index 73% rename from src/main/java/blackjack/domain/bet/BettingBank.java rename to src/main/java/blackjack/domain/bet/PlayerBets.java index 63399a47ca7..7c1fef5abed 100644 --- a/src/main/java/blackjack/domain/bet/BettingBank.java +++ b/src/main/java/blackjack/domain/bet/PlayerBets.java @@ -3,20 +3,20 @@ import blackjack.domain.player.Dealer; import blackjack.domain.player.Player; import blackjack.domain.result.GameResult; -import blackjack.domain.result.PlayerProfitResult; +import blackjack.domain.result.PlayerProfits; import java.util.Map; import java.util.stream.Collectors; -public class BettingBank { +public class PlayerBets { private final Map playerMoneyMap; - public BettingBank(Map playerMoneyMap) { + public PlayerBets(Map playerMoneyMap) { this.playerMoneyMap = playerMoneyMap; } - public PlayerProfitResult calculateProfitResult(Dealer dealer) { - return new PlayerProfitResult(playerMoneyMap.keySet().stream() + public PlayerProfits calculateProfitResult(Dealer dealer) { + return new PlayerProfits(playerMoneyMap.keySet().stream() .collect(Collectors.toMap( player -> player, player -> (calculatePlayerProfit(player, dealer))))); diff --git a/src/main/java/blackjack/domain/result/PlayerProfitResult.java b/src/main/java/blackjack/domain/result/PlayerProfits.java similarity index 87% rename from src/main/java/blackjack/domain/result/PlayerProfitResult.java rename to src/main/java/blackjack/domain/result/PlayerProfits.java index e9f31a46192..dce1b22ccca 100644 --- a/src/main/java/blackjack/domain/result/PlayerProfitResult.java +++ b/src/main/java/blackjack/domain/result/PlayerProfits.java @@ -4,11 +4,11 @@ import blackjack.domain.player.Player; import java.util.Map; -public class PlayerProfitResult { +public class PlayerProfits { private final Map playerProfitMap; - public PlayerProfitResult(Map playerProfitMap) { + public PlayerProfits(Map playerProfitMap) { this.playerProfitMap = playerProfitMap; } diff --git a/src/main/java/blackjack/view/InputView.java b/src/main/java/blackjack/view/InputView.java index f6a5252b275..9e080f342f6 100644 --- a/src/main/java/blackjack/view/InputView.java +++ b/src/main/java/blackjack/view/InputView.java @@ -3,7 +3,7 @@ import blackjack.InputMapper; import blackjack.domain.DrawDecision; import blackjack.domain.bet.BetAmout; -import blackjack.domain.bet.BettingBank; +import blackjack.domain.bet.PlayerBets; import blackjack.domain.player.Player; import blackjack.domain.player.PlayerName; import blackjack.domain.player.Players; @@ -33,8 +33,8 @@ public DrawDecision readDrawDecision(String name) { return inputMapper.mapToDrawDecision(scanner.nextLine()); } - public BettingBank readBetInformation(Players players) { - return new BettingBank(players.getPlayers().stream() + public PlayerBets readBetInformation(Players players) { + return new PlayerBets(players.getPlayers().stream() .collect(Collectors.toMap(player -> player, this::readBetAmount))); } diff --git a/src/main/java/blackjack/view/MessageResolver.java b/src/main/java/blackjack/view/MessageResolver.java index 3b1d4d0e973..b51d47f6ccc 100644 --- a/src/main/java/blackjack/view/MessageResolver.java +++ b/src/main/java/blackjack/view/MessageResolver.java @@ -13,7 +13,7 @@ import blackjack.domain.player.Participant; import blackjack.domain.player.Player; import blackjack.domain.player.Players; -import blackjack.domain.result.PlayerProfitResult; +import blackjack.domain.result.PlayerProfits; import java.util.Map; import java.util.stream.Collectors; @@ -45,14 +45,14 @@ public String resolveCompletedHandsMessage(Dealer dealer, Players players) { .toString(); } - public String resolveProfitResultMessage(PlayerProfitResult playerProfitResult) { + public String resolveProfitResultMessage(PlayerProfits playerProfits) { return new StringBuilder() .append(LINE_SEPARATOR) .append("##최종 수익") .append(LINE_SEPARATOR) - .append(resolveParticipantProfitMessage(playerProfitResult.calculateDealerProfit())) + .append(resolveParticipantProfitMessage(playerProfits.calculateDealerProfit())) .append(LINE_SEPARATOR) - .append(resolvePlayerProfitMessage(playerProfitResult)) + .append(resolvePlayerProfitMessage(playerProfits)) .toString(); } @@ -114,8 +114,8 @@ private String resolveParticipantProfitMessage(Profit dealerProfit) { return String.format("딜러: %d", dealerProfit.getValue()); } - private String resolvePlayerProfitMessage(PlayerProfitResult playerProfitResult) { - Map playerProfitMap = playerProfitResult.getPlayerProfitMap(); + private String resolvePlayerProfitMessage(PlayerProfits playerProfits) { + Map playerProfitMap = playerProfits.getPlayerProfitMap(); return playerProfitMap.entrySet().stream() .map(this::resolveSingleProfitMessage) .collect(Collectors.joining(LINE_SEPARATOR)); diff --git a/src/main/java/blackjack/view/OutputView.java b/src/main/java/blackjack/view/OutputView.java index 09961a18dff..56635caa9e9 100644 --- a/src/main/java/blackjack/view/OutputView.java +++ b/src/main/java/blackjack/view/OutputView.java @@ -3,7 +3,7 @@ import blackjack.domain.player.Dealer; import blackjack.domain.player.Player; import blackjack.domain.player.Players; -import blackjack.domain.result.PlayerProfitResult; +import blackjack.domain.result.PlayerProfits; public class OutputView { @@ -25,7 +25,7 @@ public void printCompletedHandsStatus(Dealer dealer, Players players) { System.out.println(messageResolver.resolveCompletedHandsMessage(dealer, players)); } - public void printProfitResults(PlayerProfitResult playerProfitResult) { - System.out.println(messageResolver.resolveProfitResultMessage(playerProfitResult)); + public void printProfitResults(PlayerProfits playerProfits) { + System.out.println(messageResolver.resolveProfitResultMessage(playerProfits)); } } diff --git a/src/test/java/blackjack/domain/bet/BettingBankTest.java b/src/test/java/blackjack/domain/bet/PlayerBetsTest.java similarity index 72% rename from src/test/java/blackjack/domain/bet/BettingBankTest.java rename to src/test/java/blackjack/domain/bet/PlayerBetsTest.java index 2a8947f707e..680a1f6572c 100644 --- a/src/test/java/blackjack/domain/bet/BettingBankTest.java +++ b/src/test/java/blackjack/domain/bet/PlayerBetsTest.java @@ -8,14 +8,14 @@ import blackjack.domain.player.Player; import blackjack.domain.player.TestPlayerCreator; import blackjack.domain.result.GameResult; -import blackjack.domain.result.PlayerProfitResult; +import blackjack.domain.result.PlayerProfits; import java.util.HashMap; import java.util.Map; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; @DisplayName("베팅 관리자 도메인 테스트") -class BettingBankTest { +class PlayerBetsTest { @DisplayName("플레이어들의 통합 수익을 계산할 수 있다") @Test @@ -27,14 +27,14 @@ void testCalculatePlayerProfit() { Map playerMoneyMap = new HashMap<>(); playerMoneyMap.put(player1, new BetAmout(1000)); playerMoneyMap.put(player2, new BetAmout(1000)); - BettingBank bettingBank = new BettingBank(playerMoneyMap); + PlayerBets playerBets = new PlayerBets(playerMoneyMap); - PlayerProfitResult playerProfitResult = bettingBank.calculateProfitResult(dealer); + PlayerProfits playerProfits = playerBets.calculateProfitResult(dealer); assertThat(GameResult.of(dealer, player2)).isEqualTo(GameResult.PLAYER_LOSE); assertAll( - () -> assertThat(playerProfitResult.findProfitOfPlayer(player1).getValue()).isEqualTo(1500), - () -> assertThat(playerProfitResult.findProfitOfPlayer(player2).getValue()).isEqualTo(-1000) + () -> assertThat(playerProfits.findProfitOfPlayer(player1).getValue()).isEqualTo(1500), + () -> assertThat(playerProfits.findProfitOfPlayer(player2).getValue()).isEqualTo(-1000) ); } } diff --git a/src/test/java/blackjack/domain/result/PlayerProfitResultTest.java b/src/test/java/blackjack/domain/result/PlayerProfitsTest.java similarity index 74% rename from src/test/java/blackjack/domain/result/PlayerProfitResultTest.java rename to src/test/java/blackjack/domain/result/PlayerProfitsTest.java index e2fb7b66619..32a621ffbc3 100644 --- a/src/test/java/blackjack/domain/result/PlayerProfitResultTest.java +++ b/src/test/java/blackjack/domain/result/PlayerProfitsTest.java @@ -11,7 +11,7 @@ import org.junit.jupiter.api.Test; @DisplayName("플레이어의 수익 도메인 테스트") -class PlayerProfitResultTest { +class PlayerProfitsTest { @DisplayName("특정 플레이어의 수익을 조회할 수 있다") @Test @@ -22,9 +22,9 @@ void testFindProfitOfPlayer() { Map playerProfitMap = new HashMap<>(); playerProfitMap.put(player1, new Profit(30)); playerProfitMap.put(player2, new Profit(40)); - PlayerProfitResult playerProfitResult = new PlayerProfitResult(playerProfitMap); + PlayerProfits playerProfits = new PlayerProfits(playerProfitMap); - assertThat(playerProfitResult.findProfitOfPlayer(player1)).isEqualTo(new Profit(30)); + assertThat(playerProfits.findProfitOfPlayer(player1)).isEqualTo(new Profit(30)); } @DisplayName("전체 플레이어들의 수익을 총합계산할 수 있다") @@ -36,9 +36,9 @@ void testCalculateTotalProfit() { Map playerProfitMap = new HashMap<>(); playerProfitMap.put(player1, new Profit(-30000)); playerProfitMap.put(player2, new Profit(40000)); - PlayerProfitResult playerProfitResult = new PlayerProfitResult(playerProfitMap); + PlayerProfits playerProfits = new PlayerProfits(playerProfitMap); - assertThat(playerProfitResult.calculateTotalProfit().getValue()).isEqualTo(10000); + assertThat(playerProfits.calculateTotalProfit().getValue()).isEqualTo(10000); } @DisplayName("딜러의 수익을 계산할 수 있다") @@ -50,8 +50,8 @@ void testCalculateDealerProfit() { Map playerProfitMap = new HashMap<>(); playerProfitMap.put(player1, new Profit(-30000)); playerProfitMap.put(player2, new Profit(40000)); - PlayerProfitResult playerProfitResult = new PlayerProfitResult(playerProfitMap); + PlayerProfits playerProfits = new PlayerProfits(playerProfitMap); - assertThat(playerProfitResult.calculateDealerProfit().getValue()).isEqualTo(-10000); + assertThat(playerProfits.calculateDealerProfit().getValue()).isEqualTo(-10000); } } From 15aa17c878d560340b2b89238c3a7172d14faad4 Mon Sep 17 00:00:00 2001 From: libienz Date: Sat, 16 Mar 2024 02:21:24 +0900 Subject: [PATCH 89/91] =?UTF-8?q?style:=20=EB=B3=80=EA=B2=BD=EB=90=9C=20?= =?UTF-8?q?=ED=81=B4=EB=9E=98=EC=8A=A4=20=EB=AA=85=EC=97=90=20=EB=94=B0?= =?UTF-8?q?=EB=A5=B8=20=EB=B3=80=EC=88=98=EB=AA=85=20=EA=B0=9C=EC=84=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/bet/PlayerBets.java | 10 +++++----- .../blackjack/domain/result/PlayerProfits.java | 14 +++++++------- src/main/java/blackjack/view/MessageResolver.java | 2 +- 3 files changed, 13 insertions(+), 13 deletions(-) diff --git a/src/main/java/blackjack/domain/bet/PlayerBets.java b/src/main/java/blackjack/domain/bet/PlayerBets.java index 7c1fef5abed..f57787b2dc8 100644 --- a/src/main/java/blackjack/domain/bet/PlayerBets.java +++ b/src/main/java/blackjack/domain/bet/PlayerBets.java @@ -9,14 +9,14 @@ public class PlayerBets { - private final Map playerMoneyMap; + private final Map playerBets; - public PlayerBets(Map playerMoneyMap) { - this.playerMoneyMap = playerMoneyMap; + public PlayerBets(Map playerBets) { + this.playerBets = playerBets; } public PlayerProfits calculateProfitResult(Dealer dealer) { - return new PlayerProfits(playerMoneyMap.keySet().stream() + return new PlayerProfits(playerBets.keySet().stream() .collect(Collectors.toMap( player -> player, player -> (calculatePlayerProfit(player, dealer))))); @@ -24,7 +24,7 @@ public PlayerProfits calculateProfitResult(Dealer dealer) { private Profit calculatePlayerProfit(Player player, Dealer dealer) { GameResult gameResult = GameResult.of(dealer, player); - BetAmout betAmout = playerMoneyMap.get(player); + BetAmout betAmout = playerBets.get(player); return betAmout.calculateProfit(gameResult.getProfitLeverage()); } } diff --git a/src/main/java/blackjack/domain/result/PlayerProfits.java b/src/main/java/blackjack/domain/result/PlayerProfits.java index dce1b22ccca..7120ac26ec9 100644 --- a/src/main/java/blackjack/domain/result/PlayerProfits.java +++ b/src/main/java/blackjack/domain/result/PlayerProfits.java @@ -6,18 +6,18 @@ public class PlayerProfits { - private final Map playerProfitMap; + private final Map playerProfits; - public PlayerProfits(Map playerProfitMap) { - this.playerProfitMap = playerProfitMap; + public PlayerProfits(Map playerProfits) { + this.playerProfits = playerProfits; } public Profit findProfitOfPlayer(Player player) { - return playerProfitMap.get(player); + return playerProfits.get(player); } public Profit calculateTotalProfit() { - return playerProfitMap.values().stream() + return playerProfits.values().stream() .reduce(new Profit(0), Profit::add); } @@ -25,7 +25,7 @@ public Profit calculateDealerProfit() { return calculateTotalProfit().inverse(); } - public Map getPlayerProfitMap() { - return playerProfitMap; + public Map getPlayerProfits() { + return playerProfits; } } diff --git a/src/main/java/blackjack/view/MessageResolver.java b/src/main/java/blackjack/view/MessageResolver.java index b51d47f6ccc..896964d0e94 100644 --- a/src/main/java/blackjack/view/MessageResolver.java +++ b/src/main/java/blackjack/view/MessageResolver.java @@ -115,7 +115,7 @@ private String resolveParticipantProfitMessage(Profit dealerProfit) { } private String resolvePlayerProfitMessage(PlayerProfits playerProfits) { - Map playerProfitMap = playerProfits.getPlayerProfitMap(); + Map playerProfitMap = playerProfits.getPlayerProfits(); return playerProfitMap.entrySet().stream() .map(this::resolveSingleProfitMessage) .collect(Collectors.joining(LINE_SEPARATOR)); From 04f05f8d12bc4e1130cdfc8a8f6a49920c87a628 Mon Sep 17 00:00:00 2001 From: libienz Date: Sat, 16 Mar 2024 05:04:56 +0900 Subject: [PATCH 90/91] =?UTF-8?q?style:=20=EA=B0=9C=ED=96=89=20=EC=BB=A8?= =?UTF-8?q?=EB=B2=A4=EC=85=98=20=EC=A0=81=EC=9A=A9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/bet/Profit.java | 1 - 1 file changed, 1 deletion(-) diff --git a/src/main/java/blackjack/domain/bet/Profit.java b/src/main/java/blackjack/domain/bet/Profit.java index 508b4230b21..9632aacee6a 100644 --- a/src/main/java/blackjack/domain/bet/Profit.java +++ b/src/main/java/blackjack/domain/bet/Profit.java @@ -24,7 +24,6 @@ public int getValue() { @Override public boolean equals(Object o) { - if (this == o) { return true; } From 7473ac1e4cf300b42d1e99b7c76e8a4c79755e94 Mon Sep 17 00:00:00 2001 From: libienz Date: Sat, 16 Mar 2024 05:29:50 +0900 Subject: [PATCH 91/91] =?UTF-8?q?style:=20equals,=20hash=20=EC=B5=9C?= =?UTF-8?q?=ED=95=98=EB=8B=A8=20=EB=B0=B0=EC=B9=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/blackjack/domain/Score.java | 8 ++++---- src/main/java/blackjack/domain/card/Card.java | 16 ++++++++-------- .../blackjack/domain/player/Participant.java | 16 ++++++++-------- .../java/blackjack/domain/player/PlayerName.java | 8 ++++---- 4 files changed, 24 insertions(+), 24 deletions(-) diff --git a/src/main/java/blackjack/domain/Score.java b/src/main/java/blackjack/domain/Score.java index 6197fa9e01f..d3d63e4e495 100644 --- a/src/main/java/blackjack/domain/Score.java +++ b/src/main/java/blackjack/domain/Score.java @@ -24,6 +24,10 @@ public boolean isBustScore() { return value > MAX_SCORE; } + public int getValue() { + return value; + } + @Override public boolean equals(Object o) { if (this == o) { @@ -40,8 +44,4 @@ public boolean equals(Object o) { public int hashCode() { return Objects.hash(value); } - - public int getValue() { - return value; - } } diff --git a/src/main/java/blackjack/domain/card/Card.java b/src/main/java/blackjack/domain/card/Card.java index 6b4f0b8cd90..9d6b960bcbf 100644 --- a/src/main/java/blackjack/domain/card/Card.java +++ b/src/main/java/blackjack/domain/card/Card.java @@ -16,6 +16,14 @@ 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) { @@ -32,12 +40,4 @@ public boolean equals(Object o) { public int hashCode() { return Objects.hash(cardShape, cardNumber); } - - public CardNumber getCardNumber() { - return cardNumber; - } - - public CardShape getCardShape() { - return cardShape; - } } diff --git a/src/main/java/blackjack/domain/player/Participant.java b/src/main/java/blackjack/domain/player/Participant.java index 61c6d4457f7..9ffb9d06f04 100644 --- a/src/main/java/blackjack/domain/player/Participant.java +++ b/src/main/java/blackjack/domain/player/Participant.java @@ -53,6 +53,14 @@ public boolean hasSameScore(Participant other) { return this.calculateHandScore().equals(other.calculateHandScore()); } + public String getName() { + return name.getValue(); + } + + public Hand getHand() { + return hand; + } + @Override public boolean equals(Object o) { if (this == o) { @@ -69,12 +77,4 @@ public boolean equals(Object o) { public int hashCode() { return Objects.hash(name); } - - public String getName() { - return name.getValue(); - } - - public Hand getHand() { - return hand; - } } diff --git a/src/main/java/blackjack/domain/player/PlayerName.java b/src/main/java/blackjack/domain/player/PlayerName.java index 675d9d6d1bd..fa868c3da22 100644 --- a/src/main/java/blackjack/domain/player/PlayerName.java +++ b/src/main/java/blackjack/domain/player/PlayerName.java @@ -17,6 +17,10 @@ private void validateNotEmpty(String value) { } } + public String getValue() { + return value; + } + @Override public boolean equals(Object o) { if (this == o) { @@ -33,8 +37,4 @@ public boolean equals(Object o) { public int hashCode() { return Objects.hash(value); } - - public String getValue() { - return value; - } }