🃏블랙잭 게임 # 2022.03.13~2022.04.09

🚀 블랙잭 1단계

기능 요구사항

• 블랙잭 게임을 변형한 프로그램을 구현한다. 블랙잭 게임은 딜러와 플레이어 중 카드의 합이 21 또는 21에 가장 가까운 숫자를 가지는 쪽이 이기는 게임이다.
• 플레이어는 게임을 시작할 때 배팅 금액을 정해야 한다. 카드의 숫자 계산은 카드 숫자를 기본으로 하며, 예외로 Ace는 1 또는 11로 계산할 수 있으며, King, Queen, Jack은 각각 10으로 계산한다.
• 게임을 시작하면 플레이어는 두 장의 카드를 지급 받으며, 두 장의 카드 숫자를 합쳐 21을 초과하지 않으면서 21에 가깝게 만들면 이긴다. 21을 넘지 않을 경우 원한다면 얼마든지 카드를 계속 뽑을 수 있다. 단, 카드를 추가로 뽑아 21을 초과할 경우 배팅 금액을 모두 잃게 된다.
• 딜러는 처음에 받은 2장의 합계가 16이하이면 반드시 1장의 카드를 추가로 받아야 하고, 17점 이상이면 추가로 받을 수 없다.
• 게임을 완료한 후 각 플레이어별로 승패를 출력한다.

구현할 기능 목록

- 참가자 이름 받아 딜러와 참가자 객체 생성- 참가자와 딜러가 가질 카드 객체 생성- 더 받을 지 말지 입력에 따라 추가적인 카드 객체 생성- 딜러의 추가적인 카드 객체 생성- 딜러와 비교하여 승패 구하기- 게임 결과 출력

출력

게임에 참여할 사람의 이름을 입력하세요.(쉼표 기준으로 분리)
halim,jinhee

딜러와 halim, jinhee에게 2장의 카드를 나누었습니다.
딜러 카드: 3다이아몬드, 9클로버
halim 카드: 2하트, 8스페이드
jinhee 카드: 7클로버, K스페이드

halim는 한장의 카드를 더 받겠습니까?(예는 y, 아니오는 n)
y
halim 카드: 2하트, 8스페이드, A클로버
halim는 한장의 카드를 더 받겠습니까?(예는 y, 아니오는 n)
n
jinhee은 한장의 카드를 더 받겠습니까?(예는 y, 아니오는 n)
n
jinhee 카드: 7클로버, K스페이드

딜러는 16이하라 한장의 카드를 더 받았습니다.

딜러 카드: 3다이아몬드, 9클로버, 8다이아몬드 - 결과: 20
halim 카드: 2하트, 8스페이드, A클로버 - 결과: 21
jinhee 카드: 7클로버, K스페이드 - 결과: 17

## 최종 승패
딜러: 1승 1패
halim: 승 
jinhee: 패

### 

- 인스턴스 변수 private 선언 

- card number, shapes Enum 관리 -> Enum 변수명 한글 x, 영어 사용 

- controller끼리 호출 x 

 

main controller 

public class Controller {
    public static final int DEALER_ONE_MORE_CARD_STANDARD_NUMBER = 16;
    public static final String DEALER = "딜러";
    public static final String NO = "n";

    public void play() {
        List<String> names = inputParticipantsNames();
        List<Player> players = Participants.create(names);

        Participants participants = new Participants(players);
        Player dealer = new Player(DEALER, Cards.getInitialCards());

        printPlayersInitialCards(dealer, participants);
        GameResult gameResult = getGameResult(getFinalParticipants(participants), getFinalDealer(dealer));
        printGameResult(gameResult);
    }

    private List<String> inputParticipantsNames() {
        String names = InputView.inputPlayerNames();
        String[] participantsNames = Convert.splitNames(names);
        System.out.println("");

        return new ArrayList<>(Arrays.asList(participantsNames));
    }

    private void printPlayersInitialCards(Player dealer, Participants participants) {
        printPlayersInitialMessage(participants);
        System.out.println("");

        printPlayerCards(dealer);
        for (Player user : participants.getParticipants())
            printPlayerCards(user);

        System.out.println("");
    }

    // 최종 참여자 카드
    private Participants getFinalParticipants(Participants participants) {
        List<Player> players = new ArrayList<>();

        for (Player player : participants.getParticipants()) {
            Player finalUserCard = checkOneMoreCard(player);
            printPlayerCards(finalUserCard);
            players.add(finalUserCard);
        }

        System.out.println("");

        return new Participants(players);
    }

    // 최종 딜러 카드
    private Player getFinalDealer(Player dealer) {
        Cards cards = dealer.getCards();

        if (Cards.getSum(cards) <= DEALER_ONE_MORE_CARD_STANDARD_NUMBER) {
            Card randomCard = Card.getRandomCard();
            cards.addCard(randomCard);
            printDealerOneMoreCardMessage();
        }

        return dealer;
    }

    private Player checkOneMoreCard(Player participant) {
        Cards cards = participant.getCards();

        while (!isNoAnswer(participant)) {
            Card card = Card.getRandomCard();
            cards.addCard(card);
            printPlayerCards(participant);
        }

        return participant;
    }

    private boolean isNoAnswer(Player participant) {
        String name = participant.getName();
        String answer = InputView.inputYesOrNoOneMoreCard(name);

        return answer.equals(NO);
    }

    private void printDealerOneMoreCardMessage() {
        OutputView.printDealerOneMoreCardMessage();
        System.out.println("");
    }

    private void printPlayerCards(Player participant) {
        OutputView.printPlayerCards(participant);
        System.out.println("");
    }

    private void printPlayersInitialMessage(Participants participants) {
        String names = Convert.getNamesWithComma(participants.getParticipants());

        OutputView.printPlayersInitialMessage(names);
        System.out.println("");
    }

    private void printPlayersCardsResult(Player dealer, Participants participants) {
        printPlayerCardsResult(dealer);

        for (Player participant : participants.getParticipants())
            printPlayerCardsResult(participant);

        System.out.println("");
    }

    private void printPlayerCardsResult(Player player) {
        Cards cards = player.getCards();

        int playersResult = Cards.getSum(cards);
        OutputView.printPlayerCardsSumResult(player, playersResult);
    }

    private GameResult getGameResult(Participants participants, Player dealer) {
        printPlayersCardsResult(dealer, participants);

        Map<String, String> participantsResult = GameResultCreator.getParticipantsResult(dealer, participants);
        Map<String, Integer> dealerResult = GameResultCreator.getDealerResult(participantsResult);

        return new GameResult(participantsResult, dealerResult);
    }

    private void printGameResult(GameResult gameResult) {
        OutputView.printDealerGameResult(gameResult.getDealerResult());
        OutputView.printParticipantsGameResult(gameResult.getParticipantsResult());
    }
}

model.Card 

public class Card {
    private static final int MAX_ACE_NUMBER = 11;
    private static final int STANDARD_NUMBER = 21;
    private static final int NUMBERS_COUNT = 12;
    private static final int SHAPES_COUNT = 4;
    private static final char ACE = 'A';
    private static final char JACK = 'J';
    private static final char QUEEN = 'Q';
    private static final char KING = 'K';

    private final CardNumbers number;
    private final CardShapes shape;

    public Card(CardNumbers number, CardShapes shape) {
        this.number = number;
        this.shape = shape;
    }

    public static Card getRandomCard() {
        Random random = new Random();

        int randomNumberIdx = random.nextInt(NUMBERS_COUNT);
        int randomShapeIdx = random.nextInt(SHAPES_COUNT);

        CardNumbers number = CardNumbers.getCardNumber(randomNumberIdx);
        CardShapes shape = CardShapes.getCardShape(randomShapeIdx);

        return new Card(number, shape);
    }

    public static boolean isMinAceNumber(int cardsNumberSum) {
        return cardsNumberSum + MAX_ACE_NUMBER > STANDARD_NUMBER;
    }

    public static boolean isSpecialCard(char number) {
        return isJackCard(number) || isQueenCard(number) || isKingCard(number);
    }

    public static boolean isAceCard(char number) {
        return number == ACE;
    }

    public String getCard() {
        return number.getNumber() + shape.getShape();
    }

    private static boolean isJackCard(char number) {
        return number == JACK;
    }

    private static boolean isQueenCard(char number) {
        return number == QUEEN;
    }

    private static boolean isKingCard(char number) {
        return number == KING;
    }
}

model.CardNumbers

Enum

public enum CardNumbers {
    TWO(0, '2'),
    THREE(1, '3'),
    FOUR(2, '4'),
    FIVE(3, '5'),
    SIX(4, '6'),
    SEVEN(5, '7'),
    EIGHT(6, '8'),
    NINE(7, '9'),
    ACE(8, 'A'),
    JACK(9, 'J'),
    KING(10, 'K'),
    QUEEN(11, 'Q');

    private final int idx;
    private final char number;

    CardNumbers(int cardIdx, char cardNumber) {
        this.idx = cardIdx;
        this.number = cardNumber;
    }

    public static CardNumbers getCardNumber(int cardIdx) {
        return Arrays.stream(CardNumbers.values())
                .filter(num -> num.idx == cardIdx)
                .findAny()
                .orElse(null);
    }

    public char getNumber() {
        return this.number;
    }
}

model.Cards

public class Cards {
    private static final int MIN_ACE_NUMBER = 1;
    private static final int MAX_ACE_NUMBER = 11;
    private static final int TEN = 10;
    private static final int INITIAL_CARD_COUNT = 2;

    private final List<Card> cards;

    public Cards(List<Card> cards) {
        this.cards = cards;
    }

    public List<Card> getCards() {
        return this.cards;
    }

    public void addCard(Card card) {
        cards.add(card);
    }

    public static Cards getInitialCards() {
        List<Card> cards = new ArrayList<>();

        for (int i = 0; i < INITIAL_CARD_COUNT; i++)
            cards.add(Card.getRandomCard());

        return new Cards(cards);
    }

    public static int getSum(Cards cards) {
        int sum = 0;

        for (Card card : cards.getCards()) {
            char number = card.getCard().charAt(0);

            if (Card.isMinAceNumber(sum) && Card.isAceCard(number)) {
                sum += MIN_ACE_NUMBER;
                continue;
            }

            if (!Card.isMinAceNumber(sum) && Card.isAceCard(number)) {
                sum += MAX_ACE_NUMBER;
                continue;
            }

            if (Card.isSpecialCard(number)) {
                sum += TEN;
                continue;
            }

            sum += Character.getNumericValue(number);
        }

        return sum;
    }
}

model.CardShapes

Enum

public enum CardShapes {
    CLOVER(0, "클로버"),
    HEART(1, "하트"),
    DIAMOND(2, "다이아몬드"),
    SPADE(3, "스페이드");

    private final int idx;
    private final String shape;

    CardShapes(int idx, String shape) {
        this.shape = shape;
        this.idx = idx;
    }

    public static CardShapes getCardShape(int cardIdx) {
        return Arrays.stream(CardShapes.values())
                .filter(shape -> shape.idx == cardIdx)
                .findAny()
                .orElse(null);
    }

    public String getShape() {
        return this.shape;
    }
}

model.GameResultCreator

public class GameResultCreator {
    public static Map<String, Integer> getDealerResult(Map<String, String> participantsResult) {
        Map<String, Integer> dealerResult = new HashMap<String, Integer>() {
            {
                put(ResultTypes.WIN.getResultType(), 0);
                put(ResultTypes.LOSE.getResultType(), 0);
                put(ResultTypes.TIE.getResultType(), 0);
            }
        };

        List<String> result = new ArrayList<>();
        for (String userName : participantsResult.keySet())
            result.add(participantsResult.get(userName));

        for (String str : result)
            dealerResult.put(str, dealerResult.getOrDefault(str, 0) + 1);

        return dealerResult;
    }

    public static Map<String, String> getParticipantsResult(Player dealer, Participants participants) {
        Map<String, String> participantsResult = new HashMap<>();

        for (Player user : participants.getParticipants())
            Validator.checkParticipantResult(participantsResult, dealer, user);

        return participantsResult;
    }
}

model.ResultTypes

Enum

public enum ResultTypes {
    WIN("승"),
    LOSE("패"),
    TIE("무");

    private final String type;

    ResultTypes(String type) {
        this.type = type;
    }

    public String getResultType() {
        return type;
    }
}