[손민철] 연료주입, 블랙잭 - 1단계

README.md

@@ -1 +1,33 @@
-# java-blackjack
+# java-blackjack
+
+## 연료 주입
+
+### 기능 요구사항
+
+- [X] 각 보유 차량 (5대) 렌트할 때 대략적인 이동거리를 입력
+  - [X] 자동차 객체 생성 시 생성자에 이동거리 주입
+    - [X] 연료량 계산
+- [X] 연료 주입에 필요한 연료량 보고서 생성
+
+### 프로그래밍 요구사항 
+
+- [X] 상속 / 추상 메서드 활용
+- [X] 조건문 X
+
+### 블랙잭 
+
+- [x] 카드계산
+  - [x] 카드의 숫자 계산은 카드 숫자를 기본으로 하며, 예외로 Ace는 1 또는 11로 계산할 수 있으며, King, Queen, Jack은 각각 10으로 계산
+- [x] 카드지급 기준 
+  - [x] 게임을 시작하면 플레이어는 두 장의 카드를 지급 받음 
+    - [x] 21을 넘지 않을 경우 원한다면 얼마든지 카드를 계속 뽑을 수 있음
+  -[x] 딜러는 처음에 받은 2장의 합계가 16이하이면 반드시 1장의 카드를 추가로 받아야 하고, 17점 이상이면 추가로 받을 수 없음
+- [x] 승자 결정 기준 
+  - [x] 두 장의 카드 숫자를 합쳐 21을 초과하지 않으면서 21에 가깝게 만들면 이김
+  - [x] 게임을 완료한 후 각 플레이어별로 승패를 출력
+
+### 프로그래밍 요구사항
+
+- [x] 모든 엔티티를 작게 유지
+- [x] 3개 이상의 인스턴스 변수를 가진 클래스를 쓰지 않음
+- [x] 딜러와 플레이어에서 발생하는 중복 코드를 제거해야 함

src/main/java/blackjack/Application.java

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

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

@@ -0,0 +1,82 @@
+package blackjack.controller;
+
+import static blackjack.domain.Dealer.DEALER_DRAW_LIMIT;
+
+import blackjack.domain.Dealer;
+import blackjack.domain.Deck;
+import blackjack.domain.Players;
+import blackjack.domain.ScoreBoard;
+import blackjack.view.InputView;
+import blackjack.view.ResultView;
+
+public class GameController {
+
+    private final Players players;
+    private final Dealer dealer;
+
+    public GameController() {
+        this.players = Players.create(InputView.getNames());
+        this.dealer = new Dealer();
+    }
+
+    public void run() {
+        final Deck deck = Deck.create();
+
+        setUpPerson(deck);
+        play(deck);
+        showGameResult();
+    }
+
+    private void setUpPerson(final Deck deck) {
+        ResultView.margin();
+
+        players.initializeDeck(deck);
+        dealer.initializeDeck(deck);
+
+        ResultView.shareCards(dealer.nameInfo().getPersonName(), players.nameInfos());
+        ResultView.openCardInfo(dealer.openCards(), players.openCards());
+    }
+
+    private void play(final Deck deck) {
+        ResultView.margin();
+
+        playersJudgment(deck);
+        dealerJudgment(deck);
+
+        ResultView.scoreboard(dealer.scoreInfo());
+        ResultView.scoreboard(players.scoreInfos());
+    }
+
+    private void showGameResult() {
+        ScoreBoard scoreBoard = players.match(dealer);
+        ResultView.matchResult(scoreBoard.dealerMatches(dealer),
+            scoreBoard.playerMatches());
+    }
+
+    private void playersJudgment(final Deck deck) {
+        while (players.hasActivePlayer()) {
+            activePlayerJudgement(deck);
+        }
+    }
+
+    private void activePlayerJudgement(final Deck deck) {
+        while (players.checkActivePlayerCanDrawCard() && InputView.drawChoice(
+            players.getActivePlayerNameInfo())) {
+            players.drawCardToActivePlayer(deck);
+            ResultView.playerCardsInfo(players.getActivePlayerCardInfo());
+        }
+        players.nextActivePlayer();
+    }
+
+    private void dealerJudgment(final Deck deck) {
+        ResultView.margin();
+
+        while (dealer.canDrawCard()) {
+            dealer.drawCard(deck);
+            ResultView.dealerDrawDecision(dealer.nameInfo(), DEALER_DRAW_LIMIT);
+        }
+
+        ResultView.margin();
+    }
+
+}

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

@@ -0,0 +1,45 @@
+package blackjack.domain;
+
+import java.util.Objects;
+
+public class Card {
+
+    private static final String CARD_NAME_FORMAT = "%s%s";
+
+    private final CardNumber cardNumber;
+    private final Suit suit;
+
+    public Card(final CardNumber cardNumber, final Suit suit) {
+        this.cardNumber = cardNumber;
+        this.suit = suit;
+    }
+
+    public boolean isAce() {
+        return cardNumber.isAce();
+    }
+
+    public String getCardName() {
+        return String.format(CARD_NAME_FORMAT, cardNumber.getInitial(), suit.getName());
+    }
+
+    public int getCardScore() {
+        return cardNumber.getScore();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        Card card = (Card) o;
+        return suit == card.suit && cardNumber == card.cardNumber;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(suit, cardNumber);
+    }
+}

src/main/java/blackjack/domain/CardNumber.java

@@ -0,0 +1,39 @@
+package blackjack.domain;
+
+public enum CardNumber {
+
+    ACE("A", 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 initial;
+    private final int score;
+
+    CardNumber(final String initial, final int score) {
+        this.initial = initial;
+        this.score = score;
+    }
+
+    public boolean isAce() {
+        return this == ACE;
+    }
+
+    public int getScore() {
+        return this.score;
+    }
+
+    public String getInitial() {
+        return this.initial;
+    }
+
+}

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

@@ -0,0 +1,64 @@
+package blackjack.domain;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class Cards {
+
+    private static final int ADDITION_ACE_SCORE = 10;
+    private static final int LIMITED_ACE_SCORE = 11;
+    private static final int REFERENCE_POINT = 21;
+    private static final String CARD_SIZE_ZERO_ERROR = "카드가 존재하지 않습니다.";
+    private static final int FRONT = 0;
+
+    private final List<Card> cards;
+
+    public Cards(final List<Card> cards) {
+        this.cards = cards;
+    }
+
+    public int size() {
+        return cards.size();
+    }
+
+    public int totalScore() {
+        final int score = cards.stream()
+            .mapToInt(Card::getCardScore)
+            .sum();
+
+        if (hasAce() && score <= LIMITED_ACE_SCORE) {
+            return score + ADDITION_ACE_SCORE;
+        }
+        return score;
+    }
+
+    public void add(final Card drawCard) {
+        cards.add(drawCard);
+    }
+
+    private boolean hasAce() {
+        return cards.stream().anyMatch(Card::isAce);
+    }
+
+    public List<String> openCardOne() {
+        if (cards.isEmpty()) {
+            throw new RuntimeException(CARD_SIZE_ZERO_ERROR);
+        }
+        return Arrays.asList(cards.get(FRONT).getCardName());
+    }
+
+    public List<String> openCardAll() {
+        return cards.stream()
+            .map(Card::getCardName)
+            .collect(Collectors.toList());
+    }
+
+    public boolean isBust() {
+        return totalScore() > REFERENCE_POINT;
+    }
+
+    public boolean blackjack() {
+        return totalScore() == REFERENCE_POINT;
+    }
+}

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

@@ -0,0 +1,30 @@
+package blackjack.domain;
+
+import blackjack.dto.CardInfo;
+import blackjack.dto.MatchInfo;
+import java.util.ArrayList;
+
+public class Dealer extends Person {
+
+    public static final int DEALER_DRAW_LIMIT = 16;
+    private static final String DEALER_NAME = "딜러";
+
+    public Dealer(final String userName, final Cards cards) {
+        super(userName, cards);
+    }
+
+    public Dealer() {
+        this(DEALER_NAME, new Cards(new ArrayList<>()));
+    }
+
+    @Override
+    public boolean canDrawCard() {
+        return cards.totalScore() <= DEALER_DRAW_LIMIT;
+    }
+
+    @Override
+    public CardInfo openCards() {
+        return new CardInfo(userName, cards.openCardOne());
+    }
+
+}

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

@@ -0,0 +1,46 @@
+package blackjack.domain;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class Deck {
+
+    private static final int REMOVE_INDEX = 0;
+    private final List<Card> cards;
+
+    public Deck(final List<Card> cards) {
+        this.cards = cards;
+    }
+
+    public static Deck create() {
+        final List<Card> cards = createEntireCards();
+        Collections.shuffle(cards);
+        return new Deck(cards);
+    }
+
+    public Card drawCard() {
+        if (cards.isEmpty()) {
+            throw new RuntimeException("더 이상 카드를 뽑을 수 없습니다.");
+        }
+        return cards.remove(REMOVE_INDEX);
+    }
+
+    public int deckSize() {
+        return cards.size();
+    }
+
+    private static List<Card> createEntireCards() {
+        return Arrays.stream(CardNumber.values())
+            .flatMap(Deck::createEntireSuitCards)
+            .collect(Collectors.toCollection(LinkedList::new));
+    }
+
+    private static Stream<Card> createEntireSuitCards(final CardNumber cardNumber) {
+        return Arrays.stream(Suit.values())
+            .map(suit -> new Card(cardNumber, suit));
+    }
+}