[2단계 - 블랙잭 베팅] 재즈(함석명) 미션 제출합니다.

README.md

@@ -2,6 +2,50 @@
 
 블랙잭 미션 저장소
 
-## 우아한테크코스 코드리뷰
+## 기능 요구 사항
 
-- [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md)
+### 게임
+
+- [x] 딜러와 플레이어 중 카드의 합이 21 또는 21에 가장 가까운 쪽이 승리한다.
+- [x]  게임을 시작하면 플레이어는 두 장의 카드를 지급 받는다.
+    - [x] 이후 플레이어와 딜러의 카드를 출력한다.
+    - [x] 단, 딜러의 카드는 하나만 출력한다.
+- [x] 플레이어는 게임을 시작할 때 원하는 금액을 배팅한다.
+- [x] 플레이어는 카드의 숫자 합이 21을 초과하지 않는다면 카드를 원하는 만큼 다시 뽑을 수 있다.
+    - [x] 새로 받을 때 마다 해당 플레이어의 카드를 출력한다.
+- [x] 플레이어가 카드를 다 받으면 딜러의 카드를 확인한다.
+- [x] 딜러의 카드 합이 17 이상이 될 때 까지 카드를 받는다.
+- [x] 플레이어의 게임 결과로부터 수익을 계산한다.
+    - [x] 블랙잭으로 승리 할 경우 배팅 금액의 1.5배를 딜러로부터 받는다.
+    - [x] 무승부인 경우 플레이어는 베팅한 금액을 돌려받는다.
+    - [x] 승리할 경우 베팅 금액만큼 받는다.
+    - [x] 패배할 경우 배팅 금액을 모두 잃는다.
+- [x] 딜러와 플레이어의 카드, 결과와 최종 수익 결과를 출력한다.
+
+### 카드
+
+- [x] 클로버, 스페이드, 하트, 다이아몬드 모양을 가진다.
+- [x] 카드는 2부터 10까지의 숫자와 Ace, King, Queen, Jack으로 이루어져 있다.
+- [x] King, Queen, Jack은 10으로 계산한다.
+- [x] ACE는 1 또는 11로 계산할 수 있다.
+
+### 딜러, 플레이어 공통
+
+- [x] 최소 1글자, 최대 5글자의 이름을 가진다.
+- [x] ACE 카드를 가지는 경우, 일단 11로 계산한 뒤, 합이 21을 초과하면 1로 계산한다.
+- [x] 현재 가진 카드 숫자의 합을 기준으로 카드를 더 받을 수 있는지 결정한다.
+    - [x] 딜러는 숫자의 합이 16 이하이면 카드를 더 받을 수 있다.
+    - [x] 플레이어는 숫자의 합이 21 이하이면 카드를 더 받을 수 있다.
+
+### 플레이어
+
+- [x] 플레이어의 이름은 중복될 수 없다.
+- [x] 플레이어는 최소 2명부터 최대 8명까지 가능하다.
+- [x] 딜러의 점수를 입력받아 승,무,패를 결정한다.
+    - [x] (블랙잭) 처음 두 장의 카드 합이 21일 경우 블랙잭.
+    - [x] (무승부) 딜러와 플레이어가 동시에 블랙잭인 경우.
+    - [x] (무승부) 플레이어의 점수가 21 이하이고, 딜러와 동점인 경우.
+    - [x] (승리) 플레이어의 점수가 21 이하이고, 딜러의 점수가 21을 초과하는 경우.
+    - [x] (승리) 플레이어와 딜러의 점수가 모두 21 이하이고, 딜러의 점수보다 큰 경우.
+    - [x] (패배) 플레이어의 점수가 21을 초과하면 딜러의 점수와 무관.
+    - [x] (패배) 플레이어와 딜러의 점수가 모두 21 이하이고, 딜러의 점수보다 작은 경우.

src/main/java/blackjack/Application.java

@@ -0,0 +1,11 @@
+package blackjack;
+
+import blackjack.controller.BlackjackController;
+
+public class Application {
+
+	public static void main(String[] args) {
+		BlackjackController blackjackController = new BlackjackController();
+		blackjackController.run();
+	}
+}

src/main/java/blackjack/controller/BlackjackController.java

@@ -0,0 +1,98 @@
+package blackjack.controller;
+
+import blackjack.domain.game.BlackjackGame;
+import blackjack.domain.game.Money;
+import blackjack.domain.gamer.Dealer;
+import blackjack.domain.gamer.Player;
+import blackjack.domain.gamer.Players;
+import blackjack.dto.DealerInitialHandDto;
+import blackjack.dto.HandDto;
+import blackjack.dto.PlayerGameResultsDto;
+import blackjack.dto.PlayerHandDto;
+import blackjack.dto.PlayersHandDto;
+import blackjack.view.InputView;
+import blackjack.view.OutputView;
+import blackjack.view.object.Command;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class BlackjackController {
+
+    private final InputView inputView;
+    private final OutputView outputView;
+    private final BlackjackGame blackjackGame;
+
+    public BlackjackController() {
+        this.inputView = new InputView();
+        this.outputView = new OutputView();
+        this.blackjackGame = new BlackjackGame();
+    }
+
+    public void run() {
+        Players players = getPlayers();
+        Dealer dealer = new Dealer();
+        blackjackGame.distributeInitialHand(players, dealer);
+        blackjackGame.betPlayerMoney(receivePlayersBetMoney(players));
+        printInitialHands(players, dealer);
+
+        distributeCardToPlayers(players);
+        blackjackGame.distributeCardToDealer(dealer);
+
+        printDealerCanReceiveCardMessage(dealer);
+        printAllGamerScores(dealer, players);
+        printResult(players, dealer);
+    }
+
+    private Players getPlayers() {
+        List<String> playerNames = inputView.receivePlayerNames();
+        return new Players(playerNames);
+    }
+
+    private Map<Player, Money> receivePlayersBetMoney(Players players) {
+        Map<Player, Money> playerBetMoney = new HashMap<>();
+        for (Player player : players.getPlayers()) {
+            int betMoney = inputView.receivePlayerMoney(player.getName().value());
+            playerBetMoney.put(player, new Money(betMoney));
+        }
+        return playerBetMoney;
+    }
+
+    private void printInitialHands(Players players, Dealer dealer) {
+        outputView.printInitialHands(DealerInitialHandDto.fromDealer(dealer), PlayersHandDto.fromPlayers(players));
+    }
+
+    private void distributeCardToPlayers(Players players) {
+        for (Player player : players.getPlayers()) {
+            distributeCardToPlayer(player);
+        }
+    }
+
+    private void distributeCardToPlayer(Player player) {
+        while (player.canReceiveCard() && Command.isHit(getCommand(player))) {
+            blackjackGame.addCardToPlayer(player);
+            outputView.printPlayerHand(PlayerHandDto.fromPlayer(player));
+        }
+    }
+
+    private Command getCommand(Player player) {
+        return inputView.receiveCommand(player.getName().value());
+    }
+
+    private void printDealerCanReceiveCardMessage(Dealer dealer) {
+        if (dealer.canReceiveCard()) {
+            outputView.printDealerMessage();
+        }
+    }
+
+    private void printAllGamerScores(Dealer dealer, Players players) {
+        outputView.printDealerHandScore(HandDto.fromHand(dealer.getHand()));
+        outputView.printPlayersHandScore(PlayersHandDto.fromPlayers(players));
+    }
+
+    private void printResult(Players players, Dealer dealer) {
+        Money dealerIncome = blackjackGame.calculateDealerIncome(players, dealer);
+        PlayerGameResultsDto playerGameResultsDto = PlayerGameResultsDto.fromPlayerBetResults(blackjackGame.getStore());
+        outputView.printResult(dealerIncome.value(), playerGameResultsDto);
+    }
+}

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

@@ -0,0 +1,47 @@
+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 == CardNumber.ACE;
+    }
+
+    public int getNumberValue() {
+        return cardNumber.getValue();
+    }
+
+    public CardShape getCardShape() {
+        return cardShape;
+    }
+
+    public CardNumber getCardNumber() {
+        return cardNumber;
+    }
+
+    @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);
+    }
+}

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

@@ -0,0 +1,28 @@
+package blackjack.domain.card;
+
+public enum CardNumber {
+
+	ACE(11),
+	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 int getValue() {
+		return value;
+	}
+}

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

@@ -0,0 +1,9 @@
+package blackjack.domain.card;
+
+public enum CardShape {
+
+	HEART,
+	CLOVER,
+	SPADE,
+	DIAMOND
+}

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

@@ -0,0 +1,36 @@
+package blackjack.domain.card;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+
+public class Deck {
+
+    private static final List<Card> CACHE = Arrays.stream(CardShape.values())
+            .flatMap(cardShape -> Arrays.stream(CardNumber.values())
+                    .map(number -> new Card(cardShape, number))).toList();
+
+    private final LinkedList<Card> cards;
+
+    public Deck() {
+        this.cards = new LinkedList<>(CACHE);
+    }
+
+    Deck(LinkedList<Card> cards) {
+        this.cards = cards;
+    }
+
+    public void shuffle() {
+        Collections.shuffle(cards);
+    }
+
+    public Card draw() {
+        return cards.poll();
+    }
+
+    public List<Card> getCards() {
+        return new ArrayList<>(cards);
+    }
+}

src/main/java/blackjack/domain/game/BlackjackGame.java

@@ -0,0 +1,60 @@
+package blackjack.domain.game;
+
+import blackjack.domain.card.Deck;
+import blackjack.domain.gamer.Dealer;
+import blackjack.domain.gamer.GameResult;
+import blackjack.domain.gamer.Player;
+import blackjack.domain.gamer.Players;
+import java.util.Map;
+
+public class BlackjackGame {
+
+    private final GameAccount gameAccount;
+    private final Deck deck;
+
+    public BlackjackGame() {
+        this.gameAccount = new GameAccount();
+        this.deck = new Deck();
+    }
+
+    public void distributeInitialHand(Players players, Dealer dealer) {
+        deck.shuffle();
+        setUpInitialHands(players, dealer);
+    }
+
+
+    private void setUpInitialHands(Players players, Dealer dealer) {
+        players.initAllPlayersCard(deck);
+        dealer.initCard(deck);
+    }
+
+    public void betPlayerMoney(Map<Player, Money> playersBetMoney) {
+        for (Player player : playersBetMoney.keySet()) {
+            gameAccount.betMoney(player, playersBetMoney.get(player));
+        }
+    }
+
+    public void addCardToPlayer(Player player) {
+        player.addCard(deck.draw());
+    }
+
+    public void distributeCardToDealer(Dealer dealer) {
+        while (dealer.canReceiveCard()) {
+            dealer.addCard(deck.draw());
+        }
+    }
+
+    public Money calculateDealerIncome(Players players, Dealer dealer) {
+        applyResultToBetMoney(players, dealer);
+        return gameAccount.calculateDealerIncome();
+    }
+
+    private void applyResultToBetMoney(Players players, Dealer dealer) {
+        Map<Player, GameResult> playerGameResults = players.collectPlayerGameResults(dealer.getHandValue());
+        gameAccount.applyGameResults(playerGameResults);
+    }
+
+    public Map<Player, Money> getStore() {
+        return gameAccount.getStore();
+    }
+}

src/main/java/blackjack/domain/game/GameAccount.java

@@ -0,0 +1,44 @@
+package blackjack.domain.game;
+
+import blackjack.domain.gamer.GameResult;
+import blackjack.domain.gamer.Player;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public class GameAccount {
+
+    private static final Map<Player, Money> store = new LinkedHashMap<>();
+
+    public void betMoney(Player player, Money money) {
+        store.put(player, money);
+    }
+
+    public Money findMoney(Player player) {
+        return store.get(player);
+    }
+
+    public void applyGameResults(Map<Player, GameResult> gameResults) {
+        for (Player player : gameResults.keySet()) {
+            Money money = store.get(player);
+            GameResult gameResult = gameResults.get(player);
+            Money gameResultMoney = money.multipleRatio(gameResult.getRatio());
+            store.put(player, gameResultMoney);
+        }
+    }
+
+    public Money calculateDealerIncome() {
+        int dealerIncome = 0;
+        for (Money money : store.values()) {
+            dealerIncome += money.value();
+        }
+        return new Money(-dealerIncome);
+    }
+
+    public Map<Player, Money> getStore() {
+        return new LinkedHashMap<>(store);
+    }
+
+    public void clearStore() {
+        store.clear();
+    }
+}