[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.view.object.Command;
+import java.util.ArrayList;
+import java.util.List;
+
+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 blackjack.dto.DealerInitialHandDto;
+import blackjack.dto.DealerResultDto;
+import blackjack.dto.GamerHandDto;
+import blackjack.dto.PlayerResultsDto;
+import blackjack.view.InputView;
+import blackjack.view.OutputView;
+
+public class BlackjackController {
+
+	private static final String HIT_COMMAND = "y";
+	private static final String STAND_COMMAND = "n";
+
+	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 = dealer.convertDealerToInitialHandDto();
+		List<GamerHandDto> playersInitialHandDto = players.convertPlayersToDto();
+
+		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(player.convertGamerToDto());
+		}
+	}
+
+	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(dealer.convertGamerToDto(), dealer.getScore());
+		printPlayersScores(players);
+	}
+
+	private void printPlayersScores(Players players) {
+		for (Player player : players.getPlayers()) {
+			outputView.printScore(player.convertGamerToDto(), player.getScore());
+		}
+	}
+
+	private void printResult(Dealer dealer, Players players) {
+		PlayerResultsDto playerResultsDto = players.convertPlayersToResultDto(dealer.getScore());
+		List<GameResult> playerResults = new ArrayList<>(playerResultsDto.resultMap().values());
+		DealerResultDto dealerResultDto = dealer.convertDealerToResultDto(playerResults);
+
+		outputView.printResult(dealerResultDto, playerResultsDto);
+	}
+}

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

@@ -0,0 +1,43 @@
+package blackjack.domain.card;
+
+import java.util.Objects;
+
+import blackjack.dto.CardDto;
+
+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 getNumber() {
+		return cardNumber.getValue();
+	}
+
+	public CardDto convertCardToDto() {
+		return new CardDto(cardNumber.getName(), cardShape.getName());
+	}
+
+	@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,34 @@
+package blackjack.domain.card;
+
+public enum CardNumber {
+
+	ACE("A", 11),
+	TWO("2", 2),
+	THREE("3", 3),
+	FOUR("4", 4),
+	FIVE("5", 5),
+	SIX("6", 6),
+	SEVEN("7", 7),
+	EIGHT("8", 8),
+	NINE("9", 9),
+	TEN("10", 10),
+	JACK("J", 10),
+	QUEEN("Q", 10),
+	KING("K", 10);
+
+	private final String name;
+	private final int value;
+
+	CardNumber(String name, int value) {
+		this.name = name;
+		this.value = value;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public int getValue() {
+		return value;
+	}
+}

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

@@ -0,0 +1,19 @@
+package blackjack.domain.card;
+
+public enum CardShape {
+
+	HEART("하트"),
+	CLOVER("클로버"),
+	SPADE("스페이드"),
+	DIAMOND("다이아몬드");
+
+	private final String name;
+
+	CardShape(String name) {
+		this.name = name;
+	}
+
+	public String getName() {
+		return name;
+	}
+}

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

@@ -0,0 +1,32 @@
+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 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,50 @@
+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 GamerHandDto convertGamerToDto() {
+		String playerName = name.value();
+		List<CardDto> gamerHand = hand.convertHandToDto();
+
+		return new GamerHandDto(playerName, gamerHand);
+	}
+}

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

@@ -0,0 +1,39 @@
+package blackjack.domain.gamer;
+
+import java.util.List;
+
+import blackjack.domain.card.Card;
+import blackjack.dto.DealerInitialHandDto;
+import blackjack.dto.DealerResultDto;
+
+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;
+	}
+
+	public DealerResultDto convertDealerToResultDto(List<GameResult> playerResults) {
+		Name name = getName();
+		int winCount = (int)playerResults.stream()
+			.filter(GameResult::isLose)
+			.count();
+		int loseCount = playerResults.size() - winCount;
+
+		return new DealerResultDto(name.value(), winCount, loseCount);
+	}
+
+	public DealerInitialHandDto convertDealerToInitialHandDto() {
+		String dealerName = getName().value();
+		Card first = getFirstCard();
+
+		return new DealerInitialHandDto(dealerName, first.convertCardToDto());
+	}
+}