[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,117 @@
+package blackjack.controller;
+
+import java.util.List;
+
+import blackjack.domain.card.Deck;
+import blackjack.domain.gamer.Dealer;
+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();
+		outputView.printEmptyLine();
+
+		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);
+		List<GamerHandDto> playerInitialHandDto = players.getPlayers().stream()
+			.map(GamerHandDto::fromGamer)
+			.toList();
+
+		outputView.printInitialHands(dealerInitialHandDto, playerInitialHandDto);
+		outputView.printEmptyLine();
+	}
+
+	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.printGamerNameAndHand(GamerHandDto.fromGamer(player));
+		}
+		outputView.printEmptyLine();
+	}
+
+	private boolean canDistribute(Player player) {
+		return player.canReceiveCard() && HIT_COMMAND.equals(getCommand(player));
+	}
+
+	private String getCommand(Player player) {
+		String command = inputView.receiveCommand(player.getName().value());
+		if (HIT_COMMAND.equals(command) || STAND_COMMAND.equals(command)) {
+			return command;
+		}
+		throw new IllegalArgumentException(HIT_COMMAND + " 또는 " + STAND_COMMAND + "만 입력 가능합니다.");
+	}
+
+	private void distributeCardToDealer(Dealer dealer, Deck deck) {
+		while (dealer.canReceiveCard()) {
+			dealer.addCard(deck.draw());
+			outputView.printDealerMessage(dealer.getName().value());
+		}
+		outputView.printEmptyLine();
+	}
+
+	private void printAllGamerScores(Dealer dealer, Players players) {
+		outputView.printScore(GamerHandDto.fromGamer(dealer), dealer.getScore());
+		printPlayersScores(players);
+		outputView.printEmptyLine();
+	}
+
+	private void printPlayersScores(Players players) {
+		players.getPlayers().forEach(player -> outputView.printScore(
+			GamerHandDto.fromGamer(player), player.getScore()
+		));
+	}
+
+	private void printResult(Dealer dealer, Players players) {
+		PlayerResultsDto playerResultsDto = PlayerResultsDto.ofPlayersAndDealerScore(players, dealer.getScore());
+		DealerResultDto dealerResultDto = DealerResultDto.ofDealerAndPlayers(dealer, players);
+
+		outputView.printFinalResult(dealerResultDto, playerResultsDto);
+	}
+}

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

@@ -0,0 +1,12 @@
+package blackjack.domain.card;
+
+public record Card(CardShape cardShape, CardNumber cardNumber) {
+
+	public boolean isAce() {
+		return cardNumber == CardNumber.ACE;
+	}
+
+	public int getNumber() {
+		return cardNumber.getValue();
+	}
+}

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,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 = initAllCards();
+	}
+
+	private static LinkedList<Card> initAllCards() {
+		return 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,44 @@
+package blackjack.domain.gamer;
+
+import java.util.ArrayList;
+
+import blackjack.domain.card.Card;
+import blackjack.domain.card.Deck;
+
+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,30 @@
+package blackjack.domain.gamer;
+
+import java.util.List;
+
+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 int calculateWinCount(List<GameResult> playerResults) {
+		return (int)playerResults.stream()
+			.filter(GameResult::isLose)
+			.count();
+	}
+
+	public int calculateLoseCount(List<GameResult> playerResults) {
+		return (int)playerResults.stream()
+			.filter(GameResult::isWin)
+			.count();
+	}
+}

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

@@ -0,0 +1,25 @@
+package blackjack.domain.gamer;
+
+public enum GameResult {
+
+	WIN("승"),
+	LOSE("패");
+
+	private final String name;
+
+	GameResult(String name) {
+		this.name = name;
+	}
+
+	public boolean isWin() {
+		return this == WIN;
+	}
+
+	public boolean isLose() {
+		return this == LOSE;
+	}
+
+	public String getName() {
+		return name;
+	}
+}