[블랙잭] 레몽(이규명) 미션 제출합니다.

docs/README.md

@@ -0,0 +1,11 @@
+## 기능 요구사항
+* 사용자에게 블랙잭 게임에 참여할 플레이어를 입력받는다.
+  * 블랙잭 게임의 참가자는 딜러 + 플레이어이다.
+* 게임 처음에는 게임의 참가자들은 카드덱에서 무작위로 카드 2장을 받는다.
+  * 카드덱은 하트, 클로버, 스페이드, 다이아몬드 4개의 모양이 있고 각각 ACE, 2~9, KING, QUEEN, JACK이 있다.
+  * ACE는 1또는 11로 계산할 수 있고 (합계가 21이 넘으면 1로 계산, 아니면 11), KING, QUEEN, JACK은 각각 10으로 계산한다.
+* 플레이어는 처음에 받은 두 장의 카드의 숫자 합계가 21을 넘지 않으면 얼마든지 카드를 더 받을 수 있다.
+* 딜러는 처음에 받은 카드 2장의 합계가 16이하라면 반드시 1장의 카드를 추가로 받아야 하고, 17점 이상이면 추가로 받을 수 없다.
+* 21이 초과된 플레이어는 무조건 패배한다.
+* 21에 가장 가까운 플레이어가 승리한다.
+* 게임을 완료한 후 각 플레이어별로 승패를 출력한다.

src/main/java/Application.java

@@ -0,0 +1,10 @@
+import game.controller.GameController;
+import view.InputView;
+import view.OutputView;
+
+public class Application {
+	public static void main(String[] args) {
+		GameController gameController = new GameController(new InputView(), new OutputView());
+		gameController.run();
+	}
+}

src/main/java/card/controller/DrawCard.java

@@ -0,0 +1,10 @@
+package card.controller;
+
+public enum DrawCard {
+	y,
+	n;
+
+	public boolean isY() {
+		return this == y;
+	}
+}

src/main/java/card/controller/DrawCardRequest.java

@@ -0,0 +1,31 @@
+package card.controller;
+
+import card.validator.DrawCardInputValidator;
+
+import java.util.List;
+
+public class DrawCardRequest {
+	private static final List<String> DRAW_YES = List.of("y", "Y");
+	public final DrawCard drawCard;
+
+	private DrawCardRequest(final DrawCard drawCard) {
+		this.drawCard = drawCard;
+	}
+
+	public static DrawCardRequest from(final String input) {
+		DrawCardInputValidator.validate(input);
+		return new DrawCardRequest(formattedDrawCardInput(input));
+	}
+
+	private static DrawCard formattedDrawCardInput(final String input) {
+		if (DRAW_YES.contains(input)) {
+			return DrawCard.y;
+		}
+
+		return DrawCard.n;
+	}
+
+	public boolean isNotDrawCard() {
+		return !this.drawCard.isY();
+	}
+}

src/main/java/card/model/Card.java

@@ -0,0 +1,11 @@
+package card.model;
+
+public record Card (
+	CardSuit suit,
+	CardRank rank
+) {
+	@Override
+	public String toString() {
+		return "%s%s".formatted(rank.getRank(), suit.getName());
+	}
+}

src/main/java/card/model/CardDeck.java

@@ -0,0 +1,25 @@
+package card.model;
+
+import java.util.*;
+
+public class CardDeck {
+	private static final List<CardSuit> CARD_EMBLEMS = List.of(CardSuit.CLOVER, CardSuit.HEART, CardSuit.SPADE, CardSuit.DIAMOND);
+	private static final List<CardRank> CARD_NUMBER = List.of(CardRank.ACE, CardRank.TWO, CardRank.THREE, CardRank.FOUR, CardRank.FIVE, CardRank.SIX, CardRank.SEVEN, CardRank.EIGHT, CardRank.NINE, CardRank.JACK, CardRank.QUEEN, CardRank.KING);
+
+	private final Deque<Card> cards;
+
+	public CardDeck() {
+		List<Card> cardList = new ArrayList<>();
+		for (CardSuit emblem : CARD_EMBLEMS) {
+			cardList.addAll(CARD_NUMBER.stream()
+				.map(cardRank -> new Card(emblem, cardRank))
+				.toList());
+		}
+		Collections.shuffle(cardList);
+		this.cards = new ArrayDeque<>(cardList);
+	}
+
+	public Card pickCard() {
+		return this.cards.pollFirst();
+	}
+}

src/main/java/card/model/CardRank.java

@@ -0,0 +1,36 @@
+package card.model;
+
+public enum CardRank {
+	ACE(1, "A"),
+	TWO(2, "2"),
+	THREE(3, "3"),
+	FOUR(4, "4"),
+	FIVE(5, "5"),
+	SIX(6, "6"),
+	SEVEN(7, "7"),
+	EIGHT(8, "8"),
+	NINE(9, "9"),
+	JACK(10, "J"),
+	QUEEN(10, "Q"),
+	KING(10, "K");
+
+	private final int score;
+	private final String rank;
+
+	CardRank(final int score, final String rank) {
+		this.score = score;
+		this.rank = rank;
+	}
+
+	public int getScore() {
+		return this.score;
+	}
+
+	public String getRank() {
+		return this.rank;
+	}
+
+	public boolean isAce() {
+		return this == ACE;
+	}
+}

src/main/java/card/model/CardSuit.java

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

src/main/java/card/validator/DrawCardInputValidator.java

@@ -0,0 +1,9 @@
+package card.validator;
+
+public class DrawCardInputValidator {
+	public static void validate(final String drawCardInput) {
+		if (drawCardInput == null || drawCardInput.isBlank()) {
+			throw new IllegalArgumentException("카드를 더 뽑을지 y 또는 n을 입력해주세요.");
+		}
+	}
+}

src/main/java/game/controller/GameController.java

@@ -0,0 +1,83 @@
+package game.controller;
+
+import card.model.CardDeck;
+import card.controller.DrawCardRequest;
+import game.domain.GameJudgement;
+import participant.controller.ParticipantRequest;
+import participant.domain.ParticipantRegister;
+import participant.model.Participant;
+import view.InputView;
+import view.OutputView;
+
+import java.util.List;
+import java.util.stream.IntStream;
+
+public class GameController {
+	private static final int FIRST_CARD_COUNT = 2;
+	private static final int DEALER_DRAW_CARD_SCORE = 16;
+
+	private final InputView inputView;
+	private final OutputView outputView;
+
+	private final CardDeck cardDeck = new CardDeck();
+
+	public GameController(final InputView inputView, final OutputView outputView) {
+		this.inputView = inputView;
+		this.outputView = outputView;
+	}
+
+	public void run() {
+		List<Participant> participants = fetchParticipants();
+		firstDrawCards(participants);
+		drawCardsWithoutDealer(participants);
+		drawCardDealer(participants.stream()
+			.filter(Participant::isDealer)
+			.findAny()
+			.orElseThrow(() -> new IllegalArgumentException("게임에 딜러가 존재하지 않습니다."))
+		);
+
+		this.outputView.printFinalResult(participants);
+		this.outputView.printGameJudgement(new GameJudgement(participants));
+	}
+
+	private List<Participant> fetchParticipants() {
+		ParticipantRequest participantRequest = this.inputView.inputParticipants();
+		ParticipantRegister participantRegister = new ParticipantRegister(participantRequest);
+		return participantRegister.registerParticipants();
+	}
+
+	private void firstDrawCards(List<Participant> participants) {
+		this.outputView.firstDistributeCard(participants);
+		for (Participant participant : participants) {
+			IntStream.range(0, FIRST_CARD_COUNT).forEach(it -> {
+				participant.addCard(this.cardDeck.pickCard());
+			});
+		}
+		this.outputView.printParticipantsCard(participants);
+	}
+
+	private void drawCardsWithoutDealer(List<Participant> participants) {
+		for (Participant participant : participants.stream()
+			.filter(participant -> !participant.isDealer())
+			.toList()) {
+			choiceDrawCard(participant);
+		}
+	}
+
+	private void choiceDrawCard(Participant participant) {
+		while (true) {
+			DrawCardRequest drawCardRequest = this.inputView.inputDrawCard(participant);
+			if (drawCardRequest.isNotDrawCard()) break;
+
+			participant.addCard(this.cardDeck.pickCard());
+			this.outputView.printParticipantCard(participant);
+		}
+	}
+
+	private void drawCardDealer(Participant participant) {
+		if (participant.calculateCurrentScore() <= DEALER_DRAW_CARD_SCORE) {
+			this.outputView.printDealerDrawCard();
+			participant.addCard(this.cardDeck.pickCard());
+		}
+	}
+}

src/main/java/game/domain/GameJudgement.java

@@ -0,0 +1,82 @@
+package game.domain;
+
+import participant.model.Participant;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class GameJudgement {
+	private static final String WIN_PARTICIPANT_MESSAGE = "%s: 승";
+	private static final String LOSE_PARTICIPANT_MESSAGE = "%s: 패";
+
+	private final Participant dealer;
+	private final List<Participant> participantWithoutDealers = new ArrayList<>();
+
+	public GameJudgement(final List<Participant> participants) {
+		this.dealer = participants.stream()
+			.filter(Participant::isDealer)
+			.findAny()
+			.orElseThrow(() -> new IllegalArgumentException("게임에 딜러가 존재하지 않습니다."));
+		this.participantWithoutDealers.addAll(participants.stream()
+			.filter(participant -> !participant.isDealer())
+			.toList()
+		);
+	}
+
+	public String fetchDealerJudge() {
+		final int dealerScore = this.dealer.calculateCurrentScore();
+		final String dealerJudgeMessage = "딜러: %d승 %d패";
+		int winCount = 0;
+		int loseCount = 0;
+
+		// 21점이 넘어가면 무조건 패배 - 참여자 수만큼 패배한 수로 세팅
+		if (this.dealer.isOverWinningMaxScore()) {
+			loseCount = participantWithoutDealers.size();
+			return dealerJudgeMessage.formatted(winCount, loseCount);
+		}
+
+		winCount = fetchDealerWinningCount(dealerScore);
+		loseCount = fetchDealerLoseCount(dealerScore);
+
+		return dealerJudgeMessage.formatted(winCount, loseCount);
+	}
+
+	private int fetchDealerWinningCount(final int dealerScore) {
+		int winCount;
+		winCount = participantWithoutDealers.stream()
+			.map(Participant::calculateCurrentScore)
+			.filter(participantScore -> dealerScore > participantScore)
+			.toList()
+			.size();
+		return winCount;
+	}
+
+	private int fetchDealerLoseCount(final int dealerScore) {
+		return participantWithoutDealers.stream()
+			.map(Participant::calculateCurrentScore)
+			.filter(participantScore -> dealerScore < participantScore)
+			.toList()
+			.size();
+	}
+
+	public List<String> fetchParticipantJudge() {
+		return participantWithoutDealers.stream()
+			.map(participant -> {
+				String loseMessage = LOSE_PARTICIPANT_MESSAGE.formatted(participant.getName());
+				if (participant.isOverWinningMaxScore()) {
+					return loseMessage;
+				}
+
+				int participantScore = participant.calculateCurrentScore();
+				if (participantWithoutDealers.stream()
+					.filter(p -> !(p.getName().equals(participant.getName()) ||
+						p.isOverWinningMaxScore()))
+					.allMatch(innerParticipant -> participantScore > innerParticipant.calculateCurrentScore())) {
+					return WIN_PARTICIPANT_MESSAGE.formatted(participant.getName());
+				}
+
+				return loseMessage;
+			})
+			.toList();
+	}
+}

src/main/java/participant/controller/ParticipantRequest.java

@@ -0,0 +1,28 @@
+package participant.controller;
+
+import participant.validator.ParticipantInputValidator;
+import utils.SplitUtils;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class ParticipantRequest {
+	private static final String SPLIT_DELIMITER = ",";
+
+	private final List<String> participantNames;
+
+	private ParticipantRequest(final List<String> participantNames) {
+		this.participantNames = participantNames;
+	}
+
+	public static ParticipantRequest from(final String participantInput) {
+		String trimmedInput = participantInput.replaceAll(" ", "");
+		ParticipantInputValidator.validate(trimmedInput, SPLIT_DELIMITER);
+		final String[] splitInput = SplitUtils.split(trimmedInput, SPLIT_DELIMITER);
+		return new ParticipantRequest(Arrays.asList(splitInput));
+	}
+
+	public List<String> getParticipantNames() {
+		return List.copyOf(participantNames);
+	}
+}

src/main/java/participant/domain/ParticipantRegister.java

@@ -0,0 +1,31 @@
+package participant.domain;
+
+import participant.controller.ParticipantRequest;
+import participant.model.Participant;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class ParticipantRegister {
+	private static final String DEALER = "딜러";
+
+	private final ParticipantRequest participantRequest;
+
+	public ParticipantRegister(final ParticipantRequest participantRequest) {
+		this.participantRequest = participantRequest;
+	}
+
+	public List<Participant> registerParticipants() {
+		List<Participant> participants = participantRequest.getParticipantNames().stream()
+			.map(Participant::new)
+			.collect(Collectors.toList());
+
+		participants.add(new Participant(DEALER));
+
+		// 참여자 리스트 순서 정렬 - 딜러가 앞에 오도록 정렬
+		return participants.stream()
+			.sorted(Comparator.comparing(Participant::getName).reversed())
+			.collect(Collectors.toList());
+	}
+}