[1단계 - 블랙잭 게임 실행] 재즈(함석명) 미션 제출합니다.

README.md

@@ -2,6 +2,41 @@
 
 블랙잭 미션 저장소
 
-## 우아한테크코스 코드리뷰
+## 기능 요구 사항
 
-- [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md)
+### 게임
+
+- [x] 딜러와 플레이어 중 카드의 합이 21 또는 21에 가장 가까운 쪽이 승리한다.
+- [x]  게임을 시작하면 플레이어는 두 장의 카드를 지급 받는다.
+    - [x] 이후 플레이어와 딜러의 카드를 출력한다.
+    - [x] 단, 딜러의 카드는 하나만 출력한다.
+- [x] 플레이어는 카드의 숫자 합이 21을 초과하지 않는다면 카드를 원하는 만큼 다시 뽑을 수 있다.
+    - [x] 새로 받을 때 마다 해당 플레이어의 카드를 출력한다.
+- [x] 플레이어가 카드를 다 받으면 딜러의 카드를 확인한다.
+- [x] 딜러의 카드 합이 17 이상이 될 때 까지 카드를 받는다.
+- [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] 플레이어의 점수가 21 이하이고, 딜러와 동점인 경우 패배한다.
+    - [x] 플레이어의 점수가 21 이하이고, 딜러의 점수가 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,111 @@
+package blackjack.controller;
+
+import blackjack.domain.card.Deck;
+import blackjack.domain.gamer.Dealer;
+import blackjack.domain.gamer.GameResult;
+import blackjack.domain.gamer.Name;
+import blackjack.domain.gamer.Player;
+import blackjack.domain.gamer.Players;
+import blackjack.dto.DealerInitialHandDto;
+import blackjack.dto.DealerResultDto;
+import blackjack.dto.GamerHandDto;
+import blackjack.dto.GamersHandDto;
+import blackjack.dto.PlayerGameResultsDto;
+import blackjack.view.InputView;
+import blackjack.view.OutputView;
+import blackjack.view.object.Command;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class BlackjackController {
+
+    private final InputView inputView;
+    private final OutputView outputView;
+
+    public BlackjackController() {
+        this.inputView = new InputView();
+        this.outputView = new OutputView();
+    }
+
+    public void run() {
+        Players players = getPlayers();
+        Dealer dealer = new Dealer();
+        Deck deck = new Deck();
+        deck.shuffle();
+
+        setUpInitialHands(players, deck, dealer);
+        distributeCardToPlayers(players, deck);
+        distributeCardToDealer(dealer, deck);
+        printAllGamerScores(dealer, players);
+        printResult(dealer, players);
+    }
+
+    private Players getPlayers() {
+        List<String> playerNames = inputView.receivePlayerNames();
+
+        return new Players(playerNames);
+    }
+
+    private void setUpInitialHands(Players players, Deck deck, Dealer dealer) {
+        players.initAllPlayersCard(deck);
+        dealer.initCard(deck);
+        printInitialHands(players, dealer);
+    }
+
+    private void printInitialHands(Players players, Dealer dealer) {
+        DealerInitialHandDto dealerInitialHandDto = DealerInitialHandDto.fromDealer(dealer);
+        GamersHandDto playersInitialHandDto = GamersHandDto.fromPlayers(players);
+
+        outputView.printInitialHands(dealerInitialHandDto, playersInitialHandDto);
+    }
+
+    private void distributeCardToPlayers(Players players, Deck deck) {
+        for (Player player : players.getPlayers()) {
+            distributeCardToPlayer(deck, player);
+        }
+    }
+
+    private void distributeCardToPlayer(Deck deck, Player player) {
+        while (canDistribute(player)) {
+            player.addCard(deck.draw());
+            outputView.printPlayerHand(GamerHandDto.fromBlackjackGamer(player));
+        }
+    }
+
+    private boolean canDistribute(Player player) {
+        return player.canReceiveCard() && Command.isHit(getCommand(player));
+    }
+
+    private Command getCommand(Player player) {
+        return inputView.receiveCommand(player.getName().value());
+    }
+
+    private void distributeCardToDealer(Dealer dealer, Deck deck) {
+        while (dealer.canReceiveCard()) {
+            dealer.addCard(deck.draw());
+            outputView.printDealerMessage(dealer.getName().value());
+        }
+    }
+
+    private void printAllGamerScores(Dealer dealer, Players players) {
+        outputView.printEmptyLine();
+        outputView.printScore(GamerHandDto.fromBlackjackGamer(dealer), dealer.getScore());
+        printPlayersScores(players);
+    }
+
+    private void printPlayersScores(Players players) {
+        for (Player player : players.getPlayers()) {
+            outputView.printScore(GamerHandDto.fromBlackjackGamer(player), player.getScore());
+        }
+    }
+
+    private void printResult(Dealer dealer, Players players) {
+        Map<Name, GameResult> playerGameResults = players.collectPlayerGameResults(dealer.getScore());
+        PlayerGameResultsDto playerGameResultsDto = PlayerGameResultsDto.fromPlayerGameResults(playerGameResults);
+        List<GameResult> playerResults = new ArrayList<>(playerGameResultsDto.resultMap().values());
+        DealerResultDto dealerResultDto = DealerResultDto.fromPlayerResults(playerResults);
+
+        outputView.printResult(dealerResultDto, 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;
+import java.util.stream.Collectors;
+
+public class Deck {
+
+    private final LinkedList<Card> cards;
+
+    public Deck() {
+        this.cards = Arrays.stream(CardShape.values())
+                .flatMap(cardShape -> Arrays.stream(CardNumber.values())
+                        .map(number -> new Card(cardShape, number)))
+                .collect(Collectors.toCollection(LinkedList::new));
+    }
+
+    public 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/gamer/BlackjackGamer.java

@@ -0,0 +1,47 @@
+package blackjack.domain.gamer;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import blackjack.domain.card.Card;
+import blackjack.domain.card.Deck;
+import blackjack.dto.CardDto;
+import blackjack.dto.GamerHandDto;
+
+public abstract class BlackjackGamer {
+
+	private final Name name;
+	private final Hand hand;
+
+	public BlackjackGamer(Name name) {
+		this.name = name;
+		this.hand = new Hand(new ArrayList<>());
+	}
+
+	public abstract boolean canReceiveCard();
+
+	public void initCard(Deck deck) {
+		addCard(deck.draw());
+		addCard(deck.draw());
+	}
+
+	public void addCard(Card card) {
+		hand.add(card);
+	}
+
+	public Card getFirstCard() {
+		return hand.getFirstCard();
+	}
+
+	public int getScore() {
+		return hand.calculateScore();
+	}
+
+	public Name getName() {
+		return name;
+	}
+
+	public Hand getHand() {
+		return hand;
+	}
+}

src/main/java/blackjack/domain/gamer/Dealer.java

@@ -0,0 +1,16 @@
+package blackjack.domain.gamer;
+
+public class Dealer extends BlackjackGamer {
+
+    private static final String DEFAULT_DEALER_NAME = "딜러";
+    private static final int DEALER_DRAW_THRESHOLD = 16;
+
+    public Dealer() {
+        super(new Name(DEFAULT_DEALER_NAME));
+    }
+
+    @Override
+    public boolean canReceiveCard() {
+        return getScore() <= DEALER_DRAW_THRESHOLD;
+    }
+}

src/main/java/blackjack/domain/gamer/GameResult.java

@@ -0,0 +1,11 @@
+package blackjack.domain.gamer;
+
+public enum GameResult {
+
+    WIN,
+    LOSE;
+
+    public static boolean isLose(GameResult gameResult) {
+        return LOSE == gameResult;
+    }
+}