[0] 블랙잭

src/main/java/Application.java

@@ -0,0 +1,12 @@
+import blackjack.game.GameStarter;
+
+public class Application {
+    public static void main(String[] args) {
+        GameStarter gameStarter = new GameStarter();
+        gameStarter.start()
+                .proceedBattingStep()
+                .proceedDealingStep()
+                .proceedPlayStep()
+                .proceedCalculate();
+    }
+}

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

@@ -0,0 +1,47 @@
+package blackjack.card;
+
+public class Card {
+    private final Rank rank;
+    private final Suit suit;
+
+    public Card(Rank rank, Suit suit) {
+        this.rank = rank;
+        this.suit = suit;
+    }
+
+    public String getCardName() {
+        return this.rank.getMark() + this.suit.getName();
+    }
+
+    public boolean isAce() {
+        return this.rank == Rank.ACE;
+    }
+
+    public int getNumber() {
+        return this.rank.getNumber();
+    }
+
+    @Override
+    public int hashCode() {
+        int result = 17;
+        result = 37 * result * rank.hashCode();
+        result = 37 * result * suit.hashCode();
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null) {
+            return false;
+        }
+
+        if (obj.getClass() != this.getClass()) {
+            return false;
+        }
+
+        Card compare = (Card) obj;
+
+        return this.suit == compare.suit
+                && this.rank == compare.rank;
+    }
+}

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

@@ -0,0 +1,34 @@
+package blackjack.card;
+
+import java.util.*;
+
+public class Deck {
+    private final List<Card> cards;
+
+    public Deck() {
+        OrderedDeck orderedDeck = OrderedDeck.getInstance();
+        this.cards = shuffle(orderedDeck.getDeck());
+    }
+
+    private List<Card> shuffle(List<Card> cards) {
+        Random random = new Random();
+        List<Card> shuffledDeck = new LinkedList<>();
+        for (int i = cards.size(); i > 0; i--) {
+            int pick = random.nextInt(cards.size());
+            Card picked = cards.remove(pick);
+            shuffledDeck.add(picked);
+        }
+
+        return shuffledDeck;
+    }
+
+    public Card draw() {
+        if (cards.isEmpty()) {
+            throw new IllegalArgumentException("덱에 남은 카드가 없습니다.");
+        }
+
+        Card top = cards.get(0);
+        cards.remove(0);
+        return top;
+    }
+}

src/main/java/blackjack/card/Hand.java

@@ -0,0 +1,58 @@
+package blackjack.card;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Hand {
+    private final List<Card> cards;
+
+    private static final int BLACK_JACK_NUMBER = 21;
+
+    public Hand() {
+        cards = new ArrayList<>();
+    }
+
+    public void addCard(Card card) {
+        cards.add(card);
+    }
+
+    public int calculateHand() {
+        int sum = 0;
+        for (Card card : cards) {
+            sum = addNumber(card, sum);
+        }
+
+        return sum;
+    }
+
+    private int addNumber(Card card, int sum) {
+        int number = card.getNumber();
+        if (card.isAce() && sum + number > BLACK_JACK_NUMBER) {
+            return sum + 1;
+        }
+
+        return sum + number;
+    }
+
+    public boolean isBust() {
+        int result = calculateHand();
+        return result > BLACK_JACK_NUMBER;
+    }
+
+    public boolean isBlackJack() {
+        if (cards.size() != 2) {
+            return false;
+        }
+
+        int result = calculateHand();
+        return result == BLACK_JACK_NUMBER;
+    }
+
+    public int size() {
+        return this.cards.size();
+    }
+
+    public Card get(int i) {
+        return this.cards.get(i);
+    }
+}

src/main/java/blackjack/card/OrderedDeck.java

@@ -0,0 +1,42 @@
+package blackjack.card;
+
+import java.util.*;
+
+/**
+ * 섞기 전의 덱을 캐싱
+ */
+public class OrderedDeck {
+    private static OrderedDeck instance;
+    private final List<Card> cards;
+
+    private OrderedDeck() {
+        cards = new ArrayList<>();
+        for (Suit suit : Suit.values()) {
+            Set<Card> suitCardSet = makeSuitCards(suit);
+            cards.addAll(suitCardSet);
+        }
+    }
+
+    private Set<Card> makeSuitCards(Suit suit) {
+        Set<Card> suitCardSet = new LinkedHashSet<>();
+
+        for (Rank rank : Rank.values()) {
+            Card card = new Card(rank, suit);
+            suitCardSet.add(card);
+        }
+
+        return suitCardSet;
+    }
+
+    public static OrderedDeck getInstance() {
+        if (instance == null) {
+            instance = new OrderedDeck();
+        }
+
+        return instance;
+    }
+
+    public List<Card> getDeck() {
+        return new ArrayList<>(this.cards);
+    }
+}

src/main/java/blackjack/card/Rank.java

@@ -0,0 +1,32 @@
+package blackjack.card;
+
+public enum Rank {
+    ACE(11, "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 number;
+    private final String mark;
+
+    Rank(int number, String mark) {
+        this.number = number;
+        this.mark = mark;
+    }
+
+    public int getNumber() {
+        return this.number;
+    }
+
+    public String getMark() {
+        return this.mark;
+    }
+}

src/main/java/blackjack/card/Suit.java

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

src/main/java/blackjack/game/BattingStep.java

@@ -0,0 +1,38 @@
+package blackjack.game;
+
+import blackjack.player.Gambler;
+import view.GameInputView;
+
+import java.util.Optional;
+
+public class BattingStep {
+
+    private final GameStarter gameStarter;
+
+    protected BattingStep(GameStarter gameStarter) {
+        this.gameStarter = gameStarter;
+    }
+
+    public DealingStep proceedDealingStep() {
+        DealingStep dealingStep = new DealingStep(this.gameStarter);
+        dealingStep.deal();
+        return dealingStep;
+    }
+
+    protected void bat() {
+        for (Gambler gambler : gameStarter.getGamblers()) {
+            bat(gambler);
+        }
+    }
+
+    private void bat(Gambler gambler) {
+        Optional<Integer> in = GameInputView.askBatAmount(gambler.getName());
+        if (!in.isPresent()) {
+            bat(gambler);
+            return;
+        }
+
+        Integer batAmount = in.get();
+        gambler.setBatAmount(batAmount);
+    }
+}

src/main/java/blackjack/game/CalculateStep.java

@@ -0,0 +1,76 @@
+package blackjack.game;
+
+import blackjack.player.Dealer;
+import blackjack.player.Gambler;
+import view.GameOutputView;
+
+public class CalculateStep {
+    private final GameStarter gameStarter;
+
+    public CalculateStep(GameStarter gameStarter) {
+        this.gameStarter = gameStarter;
+    }
+
+    public void calculate() {
+        Dealer dealer = gameStarter.getDealer();
+
+        for (Gambler gambler : gameStarter.getGamblers()) {
+            doCalculateChain(gambler);
+            dealer.addChip(-gambler.getChip());
+        }
+
+        GameOutputView.announceFinalProfit(dealer, gameStarter.getGamblers());
+    }
+
+    private void doCalculateChain(Gambler gambler) {
+        calculateGamblerIsBust(gambler);
+    }
+
+    private void calculateGamblerIsBust(Gambler gambler) {
+        if (gambler.getHand().isBust()) {
+            gambler.loss();
+            return;
+        }
+
+        calculateGamblerIsBlackJack(gambler);
+    }
+
+    private void calculateGamblerIsBlackJack(Gambler gambler) {
+        if (gambler.getHand().isBlackJack()) {
+            calculateDealerIsBlackJack(gambler);
+            return;
+        }
+
+        calculateDealerIsBust(gambler);
+    }
+
+    private void calculateDealerIsBlackJack(Gambler gambler) {
+        if (gameStarter.getDealer().getHand().isBlackJack()) {
+            return;
+        }
+
+        gambler.gainWithBlackJack();
+    }
+
+    private void calculateDealerIsBust(Gambler gambler) {
+        if (gameStarter.getDealer().getHand().isBlackJack()) {
+            gambler.gain();
+            return;
+        }
+
+        compareDealerAndGamblerNumber(gambler);
+    }
+
+    private void compareDealerAndGamblerNumber(Gambler gambler) {
+        int playerNumber = gambler.getHand().calculateHand();
+        int dealerNumber = gameStarter.getDealer().getHand().calculateHand();
+        if (playerNumber > dealerNumber) {
+            gambler.gain();
+            return;
+        }
+
+        if (playerNumber < dealerNumber) {
+            gambler.loss();
+        }
+    }
+}