[블랙잭 게임 미션] 김지혜 1단계 리퀘스트

src/main/java/blackjack/Application.java

@@ -0,0 +1,53 @@
+package blackjack;
+
+import blackjack.view.InputView;
+import blackjack.rule.*;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.Collections;
+
+public class Application {
+
+    public static void main(String[] args) {
+        // initializing card_dictionary
+        Map<String, List<Integer>> Cards = CardDictionary.createCardDictionary();
+
+        // initializing participant, dealer
+        List<String> Dealer = Arrays.asList("딜러");
+        List<String> participants = InputView.getInput("게임에 참여할 사람의 이름을 입력하세요.(쉼표 기준으로 분리)", s -> Arrays.asList(s.split(",")));
+        ParticipantSize(participants); //예외 처리
+
+        Collections.shuffle(participants);
+
+        // adding two card
+        Map<String, Participant.ParticipantState> participantStates = BlackJackGame.simulateCardGame(participants, Cards);
+        Map<String, Participant.ParticipantState> dealerState = BlackJackGame.simulateCardGame(Dealer, Cards);
+        int DealerSum = 0;
+
+        // evaluate between 16 and 21 (participant)
+        for (String participant : participants) {
+            for (Map.Entry<String, Participant.ParticipantState> entry : participantStates.entrySet()) {
+                entry.getValue().getName(participant);
+                canReceiveCard.ParticipantBetween16And21(participant, entry, Cards);
+            }
+        }
+
+        // evaluate between 16 and 21 (dealer)
+        for (Map.Entry<String, Participant.ParticipantState> entry : dealerState.entrySet()) {
+            canReceiveCard.DealerBetween16And21(Dealer.get(0), entry, Cards);
+            DealerSum = entry.getValue().printsum();
+        }
+
+        // Comparing
+        DecideResult.CompareWithDealer(participants, DealerSum, participantStates);
+    }
+
+    private static void ParticipantSize(List<String> participants) {
+        if (participants.size() > 25) {
+            throw new IllegalArgumentException("가능한 참가 인원을 초과하였습니다.");
+        }
+    }
+}
+

src/main/java/blackjack/CardDictionary.java

@@ -0,0 +1,39 @@
+package blackjack;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.ArrayList;
+
+public class CardDictionary {
+    public static Map<String, List<Integer>> createCardDictionary() {
+        Map<String, List<Integer>> Cards = new HashMap<>();
+
+        for (int i = 2; i <= 10; i++) {
+            for (String suit : new String[]{"하트", "스페이드", "클로버", "다이아몬드"}) {
+                String cardName = i + suit;
+                List<Integer> values = new ArrayList<>();
+                values.add(i);
+                Cards.put(cardName, values);
+            }
+        }
+
+        for (String suit : new String[]{"하트", "스페이드", "클로버", "다이아몬드"}) {
+            for (String face : new String[]{"J", "Q", "K"}) {
+                String cardName = face + suit;
+                List<Integer> values = new ArrayList<>();
+                values.add(10);
+                Cards.put(cardName, values);
+            }
+        }
+
+        for (String suit : new String[]{"하트", "스페이드", "클로버", "다이아몬드"}) {
+            String cardName = suit + "Ace";
+            List<Integer> values = new ArrayList<>();
+            values.add(1);
+            values.add(11);
+            Cards.put(cardName, values);
+        }
+        return Cards; //HashMap [[key: 카드 이름, value = 카드 숫자]]
+    }
+}

src/main/java/blackjack/Participant.java

@@ -0,0 +1,70 @@
+package blackjack;
+
+import java.util.*;
+import blackjack.rule.*;
+
+public class Participant {
+    public static class ParticipantState {
+        private int sum;
+        private List<String> cardlist;
+        private String name;
+        private List<String> WinOrLoss = new ArrayList<>();
+
+        public ParticipantState() {
+            this.sum = 0;
+            this.cardlist = new ArrayList<>();
+            this.name = "";
+        }
+
+        public int printsum() {
+            return this.sum;
+        }
+
+        public List<String> printcardlist() {
+            return this.cardlist;
+        }
+
+        public String printname() {
+            return this.name;
+        }
+
+        public String printwinorloss() {
+            return this.WinOrLoss.get(0);
+        }
+
+        public int getSum(Map<String, List<Integer>> Cards) {
+
+            OperationWithCard.CardOperation sumOperation = shuffledCard -> {
+                int value = shuffledCard.getValue();
+                this.sum += value;
+            };
+
+            OperationWithCard.performCardOperation(Cards, sumOperation);
+
+            return this.sum;
+        }
+
+        public String getName(String participant) {
+            this.name = participant;
+            return this.name;
+        }
+
+
+        public void WinOrLoss(int winorloss) {
+
+            if (winorloss == 0) {
+                this.WinOrLoss.add("승");
+            }
+            if (winorloss == 1) {
+                this.WinOrLoss.add("패");
+            }
+        }
+
+        public void updateSumAndNameList(int value, String cardNames) {
+            this.sum += value;
+            this.cardlist.add(cardNames);
+        }
+    }
+
+
+}

src/main/java/blackjack/rule/BlackJackGame.java

@@ -0,0 +1,34 @@
+package blackjack.rule;
+
+import java.util.*;
+import blackjack.Participant;
+
+
+public class BlackJackGame {
+    public static Map<String, blackjack.Participant.ParticipantState> simulateCardGame(List<String> participants, Map<String, List<Integer>> Cards) {
+        Map<String, blackjack.Participant.ParticipantState> participantStates = new HashMap<>();
+
+        for (String participant : participants) {
+            participantStates.put(participant, new blackjack.Participant.ParticipantState());
+        }
+
+        for (String participant : participants) {
+            blackjack.Participant.ParticipantState participantState = participantStates.get(participant);
+            OperationWithCard.performCardOperation(Cards, shuffledCard -> {
+                int value = shuffledCard.getValue();
+                String cardName = shuffledCard.getKey();
+                participantState.updateSumAndNameList(value, cardName);
+            });
+        }
+        return participantStates;
+
+    }
+
+}
+
+
+
+
+
+
+

src/main/java/blackjack/rule/CardGameParticipant.java

@@ -0,0 +1,11 @@
+package blackjack.rule;
+
+import java.util.List;
+import java.util.Map;
+import blackjack.Participant;
+
+public interface CardGameParticipant {
+        void playTurn(String participant, Map.Entry<String, Participant.ParticipantState> participantEntry, Map<String, List<Integer>> Cards);
+
+        boolean shouldContinue();
+}

src/main/java/blackjack/rule/DecideResult.java

@@ -0,0 +1,32 @@
+package blackjack.rule;
+
+import blackjack.view.OutView;
+import blackjack.Participant;
+
+import java.util.List;
+import java.util.Map;
+
+public class DecideResult {
+    public static void CompareWithDealer(List<String> participants, int DealerSum, Map<String, Participant.ParticipantState> participantStates) {
+
+        int win = 0;
+        int loss = 0;
+
+        for (Map.Entry<String, Participant.ParticipantState> entry : participantStates.entrySet()) {
+            int participantSum = entry.getValue().printsum();
+            if (participantSum <= 21) {
+                if (DealerSum > participantSum) {
+                    win += 1;
+                    entry.getValue().WinOrLoss(1);
+                }
+                if (DealerSum < participantSum) {
+                    loss += 1;
+                    entry.getValue().WinOrLoss(0);
+                }
+            } else {
+                win += 1;
+            }
+        }
+        OutView.printFinalResults(win, loss, participantStates);
+    }
+}

src/main/java/blackjack/rule/OperationWithCard.java

@@ -0,0 +1,38 @@
+package blackjack.rule;
+
+import java.util.*;
+
+public class OperationWithCard {
+    public interface CardOperation {
+        void operate(Map.Entry<String, Integer> shuffledCard);
+    }
+
+    public static void performCardOperation(Map<String, List<Integer>> Cards, CardOperation operation) {
+        for (int i = 0; i < 2; i++) {
+            Map.Entry<String, Integer> shuffledCard = getRandomCard(Cards);
+            operation.operate(shuffledCard);
+        }
+    }
+
+    public static Map.Entry<String, Integer> getRandomCard(Map<String, List<Integer>> Cards) {
+        String randomCardName = getRandomCardName(Cards.keySet());
+
+        List<Integer> cardValues = Cards.get(randomCardName);
+
+        int cardvalue = cardValues.get(0);
+
+        Cards.remove(randomCardName);
+
+        return new AbstractMap.SimpleEntry<>(randomCardName, cardvalue);
+    }
+
+    public static <T> T getRandomCardName(Set<T> keySet) {
+        int randomIndex = new Random().nextInt(keySet.size());
+        Iterator<T> iterator = keySet.iterator();
+        for (int i = 0; i < randomIndex; i++) {
+            iterator.next();
+
+        }
+        return iterator.next();
+    }
+}

src/main/java/blackjack/rule/canReceiveCard.java

@@ -0,0 +1,75 @@
+package blackjack.rule;
+
+import blackjack.view.InputView;
+import java.util.List;
+import java.util.Map;
+import blackjack.Participant;
+
+public class canReceiveCard {
+    public static void ParticipantBetween16And21(String participant, Map.Entry<String, blackjack.Participant.ParticipantState> participantEntry, Map<String, List<Integer>> Cards) {
+        playTurn(new Participant(), participant, participantEntry, Cards);
+    }
+
+    public static void DealerBetween16And21(String Dealer, Map.Entry<String, blackjack.Participant.ParticipantState> DealerEntry, Map<String, List<Integer>> Cards) {
+        playTurn(new Dealer(), Dealer, DealerEntry, Cards);
+    }
+
+    public static void playTurn(CardGameParticipant participant, String name, Map.Entry<String, blackjack.Participant.ParticipantState> entry, Map<String, List<Integer>> Cards) {
+        while (true) {
+            int sum = entry.getValue().getSum(Cards);
+
+            if (sum < 16 || sum >= 21) {
+                break;
+            }
+
+            if (sum > 16 && sum < 21) {
+                System.out.println(name + "는 한장의 카드를 더 받겠습니까?(예는 y, 아니오는 n)");
+                String answer = InputView.getInput("", String::valueOf);
+
+
+                if ("y".equalsIgnoreCase(answer)) {
+                    Map.Entry<String, Integer> extraCard = OperationWithCard.getRandomCard(Cards);
+                    int extraCardValue = extraCard.getValue();
+                    String extraCardName = extraCard.getKey();
+                    entry.getValue().updateSumAndNameList(extraCardValue, extraCardName);
+
+                    System.out.println(name + "카드: " + entry.getValue().printcardlist());
+
+                    if (participant.shouldContinue()) {
+                        continue;
+                    } else {
+                        break;
+                    }
+                } else if ("n".equalsIgnoreCase(answer)) {
+                    System.out.println(name + "카드: " + entry.getValue().printcardlist());
+                    break;
+
+                }
+            }
+        }
+    }
+
+    static class Participant implements CardGameParticipant {
+        @Override
+        public void playTurn(String participant, Map.Entry<String, blackjack.Participant.ParticipantState> participantEntry, Map<String, List<Integer>> Cards) {
+
+        }
+
+        @Override
+        public boolean shouldContinue() {
+            return true;
+        }
+    }
+
+    static class Dealer implements CardGameParticipant {
+        @Override
+        public void playTurn(String participant, Map.Entry<String, blackjack.Participant.ParticipantState> participantEntry, Map<String, List<Integer>> Cards) {
+
+        }
+
+        @Override
+        public boolean shouldContinue() {
+            return false;
+        }
+    }
+}

src/main/java/blackjack/view/InputView.java

@@ -0,0 +1,17 @@
+package blackjack.view;
+
+import java.util.Scanner;
+import java.util.function.Function;
+
+public class InputView {
+    public static <T> T getInput(String prompt, Function<String, T> parser) {
+        T result;
+
+        Scanner scanner = new Scanner(System.in);
+        System.out.println(prompt);
+
+        String userinput = scanner.nextLine();
+        result = parser.apply(userinput);
+        return result;
+    }
+}

src/main/java/blackjack/view/OutView.java

@@ -0,0 +1,18 @@
+package blackjack.view;
+
+import blackjack.Participant;
+
+import java.util.Map;
+
+public class OutView {
+    public static void printFinalResults(int win, int loss, Map<String, Participant.ParticipantState> participantStates) {
+        System.out.println("## 최종 승패");
+        System.out.println("딜러: " + win + "승 " + loss + "패");
+
+        for (Map.Entry<String, Participant.ParticipantState> entry : participantStates.entrySet()) {
+            String name = entry.getValue().printname();
+            System.out.println(name + ": " + entry.getValue().printwinorloss());
+
+        }
+    }
+}