[김성현] 연료 주입 및 블랙잭(1단계)

README.md

@@ -1 +1,50 @@
-# java-blackjack
+# java-blackjack
+
+## 기능
+
+### Car
+- [X] 이동거리로 주입해야할 연료량을 계산한다.
+- [X] 차종을 리턴한다.
+- [X] 연료량을 리턴한다.
+
+### RentCompany
+- [X] InputView를 생성한다.
+- [X] InputView로 부터 받은 이동거리로 Car를 생성한다.
+- [X] ReportView를 생성한다.
+- [X] Car로부터 받은 연료량으로 ReportView를 생성한다.
+
+### InputView
+- [X] 이동거리 입력 받는다.
+
+### ReportView
+- [X] 차량별 주입해야할 연료량을 출력한다.
+
+
+## 블랙잭 기능 요구사항
+
+### 입력
+- [x] 게임에 참여할 사람의 이름을 입력한다.
+  - [x] 쉼표 기준으로 분리한다
+
+### 출력
+- [ ]
+
+### 카드
+- [x] Ace는 1 또는 11로 계산한다.
+- [x] King, Queen, Jack은 10으로 계산한다.
+- [x] 나머지 카드는 카드숫자를 기본으로 계산한다.
+
+### 게임
+- [x] 게임시작 시 2장의 카드를 지급 받는다. 
+- [x] 21을 초과하지 않으면 카드를 계속 받을 수 있다.
+- [x] 21을 초과하면 패배로 처리한다.
+- [x] 21을 초과하지 않으면서 21에 가까운 사람이 이긴다.
+#### 딜러
+- [x] 처음에 받은 2장의 합계가 16이하면 1장을 추가로 지급받는다. 
+
+# TODO
+- [x] 플레이어를 추상클래스 혹은 인터페이스로 구현하기
+- [x] 딜러가 한장 더 받는다는 메시지를 맨 마지막에 위치
+- [x] 딜러의 상대적 최종 승패 구현
+- [x] 단위 테스트 보완하기
+- [x] 최종승패 딜러 로직 버그 수정

src/main/java/blackjack/Application.java

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

src/main/java/blackjack/controller/GameController.java

@@ -0,0 +1,97 @@
+package blackjack.controller;
+
+import blackjack.domain.card.CardPack;
+import blackjack.domain.gameplayer.GamePlayer;
+import blackjack.domain.gameplayer.GamePlayers;
+import blackjack.domain.gameplayer.Names;
+import blackjack.view.InputView;
+import blackjack.view.OutputView;
+import java.util.List;
+
+public class GameController {
+
+    public void start() {
+        final CardPack cardPack = new CardPack();
+        final GamePlayers gamePlayers = new GamePlayers(getConsoleNames());
+
+        initializeGame(gamePlayers, cardPack);
+        printInitialStatus(gamePlayers);
+
+        playGame(gamePlayers, cardPack);
+        printFinalStatus(gamePlayers);
+    }
+
+    private Names getConsoleNames() {
+        try {
+            return convertStringToNames(InputView.getPlayerName());
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+            return getConsoleNames();
+        }
+    }
+
+    private Names convertStringToNames(String names) {
+        return new Names(names);
+    }
+
+    public void initializeGame(final GamePlayers gamePlayers, final CardPack cardPack) {
+        List<GamePlayer> players = gamePlayers.getAllPlayers();
+
+        players.forEach(player -> {
+            player.receiveCard(cardPack.pick());
+            player.receiveCard(cardPack.pick());
+        });
+    }
+
+    private void printInitialStatus(GamePlayers gamePlayers) {
+        printInitialMessage(gamePlayers);
+        printCardAllStatus(gamePlayers);
+    }
+
+    private void printInitialMessage(GamePlayers gamePlayers) {
+        OutputView.printInitialMessage(gamePlayers);
+    }
+
+    private void printCardAllStatus(GamePlayers gamePlayers) {
+        OutputView.printCardAllStatus(gamePlayers);
+    }
+
+    public void playGame(GamePlayers gamePlayers, CardPack cardPack) {
+        final List<GamePlayer> players = gamePlayers.getPlayers();
+        final GamePlayer dealer = gamePlayers.getDealer();
+
+        for (final GamePlayer player : players) {
+            playerGameProcess(player, cardPack);
+        }
+        dealerGameProcess(dealer, cardPack);
+    }
+
+    private void playerGameProcess(final GamePlayer player, CardPack cardPack) {
+        while (player.isContinue() && InputView.getPlayerChoice(player)) {
+            player.receiveCard(cardPack.pick());
+            OutputView.printCardStatus(player);
+        }
+
+        OutputView.printCardStatus(player);
+    }
+
+    private void dealerGameProcess(final GamePlayer dealer, CardPack cardPack) {
+        while (dealer.isLowerThanBound()) {
+            dealer.receiveCard(cardPack.pick());
+            OutputView.printDealerAcceptCard();
+        }
+    }
+
+    private void printFinalStatus(GamePlayers gamePlayers) {
+        printCardResult(gamePlayers);
+        printGameResult(gamePlayers);
+    }
+
+    private void printCardResult(GamePlayers gamePlayers) {
+        OutputView.printCardResult(gamePlayers);
+    }
+
+    private void printGameResult(GamePlayers gamePlayers) {
+        OutputView.printGameResult(gamePlayers);
+    }
+}

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

@@ -0,0 +1,20 @@
+package blackjack.domain.card;
+
+public class Card {
+
+    private final CardSymbol cardSymbol;
+    private final CardType cardType;
+
+    public Card(final CardSymbol cardSymbol, final CardType cardType) {
+        this.cardSymbol = cardSymbol;
+        this.cardType = cardType;
+    }
+
+    public CardSymbol getCardSymbol() {
+        return cardSymbol;
+    }
+
+    public CardType getCardType() {
+        return cardType;
+    }
+}

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

@@ -0,0 +1,35 @@
+package blackjack.domain.card;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public class CardPack {
+
+    private static final int FRONT = 0;
+
+    private final List<Card> cardPack;
+
+    public CardPack() {
+        this.cardPack = create();
+    }
+
+    private List<Card> create() {
+        final List<Card> cards = new ArrayList<>();
+        for (final CardSymbol symbol : CardSymbol.values()) {
+            Arrays.stream(CardType.values())
+                .forEach(type -> cards.add(new Card(symbol, type)));
+        }
+        Collections.shuffle(cards);
+        return new ArrayList<>(cards);
+    }
+
+    public List<Card> getCardPack() {
+        return Collections.unmodifiableList(cardPack);
+    }
+
+    public Card pick() {
+        return cardPack.remove(FRONT);
+    }
+}

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

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

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

@@ -0,0 +1,48 @@
+package blackjack.domain.card;
+
+public enum CardType {
+    ACE("A", 11, 1),
+    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 point;
+    private int lowerAcePoint;
+
+    CardType(String name, int point) {
+        this.name = name;
+        this.point = point;
+    }
+
+    CardType(String name, int point, int lowerAcePoint) {
+        this.name = name;
+        this.point = point;
+        this.lowerAcePoint = lowerAcePoint;
+    }
+
+    public String getName() {
+        return this.name;
+    }
+
+    public int getPoint() {
+        return this.point;
+    }
+
+    public int getLowerAcePoint() {
+        return this.lowerAcePoint;
+    }
+
+    public boolean isAce() {
+        return this == CardType.ACE;
+    }
+}

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

@@ -0,0 +1,61 @@
+package blackjack.domain.card;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class Cards {
+
+    private static final int BLACK_JACK = 21;
+
+    private final List<Card> cards;
+
+    public Cards() {
+        this.cards = new ArrayList<>();
+    }
+
+    public void receiveCard(final Card card) {
+        cards.add(card);
+    }
+
+    public List<Card> toList() {
+        return Collections.unmodifiableList(cards);
+    }
+
+    public int calculateCards() {
+        final int sumOfCards = getSumOfCards();
+        final int aceCount = getAceCount();
+
+        if (sumOfCards > BLACK_JACK && aceCount > 0) {
+            return getBestSumWithAce(sumOfCards);
+        }
+        return sumOfCards;
+    }
+
+    private int getAceCount() {
+        return (int) cards.stream()
+            .filter(card -> card.getCardType().isAce())
+            .count();
+    }
+
+    private int getSumOfCards() {
+        return cards.stream()
+            .map(Card::getCardType)
+            .mapToInt(CardType::getPoint)
+            .sum();
+    }
+
+    private int getBestSumWithAce(final int sum) {
+        final int lowerAcePoint = CardType.ACE.getLowerAcePoint();
+        final int higherAcePoint = CardType.ACE.getPoint();
+
+        int aceCount = getAceCount();
+        int totalPoint = sum;
+
+        while (aceCount > 0 && totalPoint > BLACK_JACK) {
+            totalPoint = totalPoint - higherAcePoint + lowerAcePoint;
+            aceCount--;
+        }
+        return totalPoint;
+    }
+}

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

@@ -0,0 +1,40 @@
+package blackjack.domain.gameplayer;
+
+import java.util.List;
+
+public class Dealer extends GamePlayer {
+
+    private static final String DEALER = "딜러";
+    private static final int DEALER_BOUND = 16;
+    private static final String DealerResult = "%d승 %d패";
+
+    public Dealer() {
+        this(new Name(DEALER));
+    }
+
+    public Dealer(final Name name) {
+        super(name);
+    }
+
+    @Override
+    public boolean isLowerThanBound() {
+        return getScore() <= DEALER_BOUND;
+    }
+
+    @Override
+    public String getGameResult(List<GamePlayer> players) {
+        int winCount = 0;
+        if (isContinue()) {
+            winCount = findWinCount(getScore(), players);
+        }
+        int loseCount = players.size() - winCount;
+
+        return String.format(DealerResult, winCount, loseCount);
+    }
+
+    private int findWinCount(int dealerScore, List<GamePlayer> players) {
+        return (int) players.stream()
+            .filter(player -> player.isContinue() && player.getScore() < dealerScore)
+            .count();
+    }
+}