마스터즈 테스트 구현

Readme.md

구현 환경

• Java 17, Gradle 8.2, IntelliJ 2023.2.2
• 3 단계에서는 resources 디렉터리 밑에 0~8.png 파일을 추가하여 카드 이미지로 사용하였음.

1단계: 카드 뒤집기 게임

기능 구현

• Controller
  • 다른 클래스들을 적절하게 기능하도록 돕는 클래스
• CardManager
  • List 형태로 카드를 초기화하여 반환: 카드 섞기/카드 뽑기
  • static 메서드로 구현
• Card
  • 필드
    • number(카드에 적힌 숫자)
    • status(상태): 초기화 상태는 active(true), 게임에서 풀렸다면 deactive(false).
• GameManager
  • 초기화
    • CardManager로 카드패를 뽑는다. - checker라는 뽑은 카드패와 동일한 크기의 인덱스를 가지는 불리언 리스트를 초기화(TRUE)한다.
    • Card 클래스에서 해당 카드가 활성화 되어있는지 아닌지를 판단하는 필드(필드명: status) 추가. 이를 가지고 카드 객체의 상태를 확인하도록 구현하였음.
    • checkCard 메서드: index1과 index2의 위치의 값을 비교하여 checker의 불리언 값을 FALSE로 바꾼다.
  • 수시로 상태를 체크하여 뿌려주어야 하므로 getStatus 메서드 (checker를 리턴함)
  • 수시로 게임이 끝났는지 판단하는 isItOver 메서드
    • 카드 덱을 돌며 status가 active한 카드들 중 자신과 동일한 값과 상태를 갖는 카드가 하나라도 있다면 false를 리턴한다.
    • card 리스트에 동일한 값을 가지지만 같은 객체는 포함하지 말아야 함: contains 메서드는 동일한 객체가 있는 경우도 true를 반환함.
    • 이를 의도대로 사용하기 위해 isEqual 메서드를 overlapping하여 status와 값이 같은 원본 객체와 다른 객체 가 있는 경우에만 true를 반환하도록 하였음.
• InputManager
  • Scanner를 통해 입력 받음
  • 입력 시에는 예외 처리를 통해 잘못 입력된 경우 반복적으로 입력 받음
    • 범위가 벗어난 경우 / "("로 시작하지 않거나, ")"로 끝나지 않는 경우 / 숫자를 입력하지 않은 경우
    • 에러 메세지: "ERROR: 잘못된 입력입니다. (1, 3)과 같이 입력해 주세요. 범위: (1, 1) ~ (3, 6)"
• OutputManager
  • 현재 덱의 상태를 검사하여 출력하는 printDeck 메서드
  • 입력받은 두 개의 요소를 보여주면서 현재 덱을 출력하는 printResult 메서드

입출력 예시

안녕하세요. 카드 맞추기 게임을 시작하겠습니다.
좌표를 입력할 때에는 반드시 괄호안에 쉼표/띄어쓰기로 구분하여 입력해주세요. 예시: (3, 1)
좌표의 범위는 (1, 1)부터 (3, 6) 입니다.
X X X X X X 
X X X X X X 
X X X X X X 

<시도 0, 남은 카드: 18> 좌표를 두 번 입력하세요.
입력 1? (1, 2)
입력 2? (3, 1)
X 1 X X X X 
X X X X X X 
3 X X X X X 

X X X X X X 
X X X X X X 
X X X X X X 
<시도 1, 남은 카드: 18> 좌표를 두 번 입력하세요.
입력 1? 

2 단계: 2인 게임 만들기

기능 구현

• 필드 및 메서드 추가: GameManager 클래스
  • player1, player2: 초기화 시 이름 입력받음
  • whosTurn: player1과 player2 중 하나를 가르킴
  • consecutive: 이 턴의 플레이어가 연속으로 문제를 맞추고 있는지 여부-boolean
  • GameManager는 whosTurn을 통하여 문제를 맞추면 턴을 바꾸지않고 consecutive를 켬
  • 문제를 맞추지 못하면 whosTurn을 바꾸고 consecutive를 끈다.
• 신규 추가: Player 클래스
  • name: 게이머 이름
  • score: 점수
  • combo: 콤보
  • 문제를 맞추면 GameManager가 Player의 메서드로 consecutive 여부를 전달하면 콤보에 반영하여 곱하거나 1로 되돌린다.
  • 업데이트된 combo를 사용하여 플레이어의 score를 업데이트 한다.
• 예외 처리 보완: InputManager 클래스
  • 이미 입력한 카드를 중복하여 입력시
  • 이미 비활성화 된 카드 입력시
  • 두번째 입력 에서 빈 칸 입력시 발생하는 StringIndexOutOfBoundsException에 대한 예외 처리 추가
• 메서드 추가: Controller의 processInput()메서드
  • InputManager에 넣는게 나을거라고 생각하였지만 카드가 비활성화되어있는지 확인하는 과정에서 GameManager를 사용해 정보조회가 필요하여 GameManager에 넣을 수 밖에 없었다.
• dto 추가: InputSet(입력 받은 숫자들을 전달), Result(결과를 GameManager에게서 OutputManager로 전달)

입출력 예시

• 게임 시작 시 출력

안녕하세요. 카드 맞추기 게임을 시작하기 전에 참가자 두명의 이름을 입력해 주세요.
게이머 1의 이름을 입력하세요.
맛집투어
게이머 2의 이름을 입력하세요.
카페투어
좌표를 입력할 때에는 반드시 괄호안에 쉼표/띄어쓰기로 구분하여 입력해주세요. 예시: (3, 1)
좌표의 범위는 (1, 1)부터 (3, 6) 입니다.
X X X X X X 
X X X X X X 
X X X X X X 

맛집투어의 차례입니다. 현재 점수: 0, 콤보: x1
<시도 0, 남은 카드: 18> 좌표를 두 번 입력하세요.
입력 1? 

• 콤보 시 출력

맛집투어의 차례입니다. 현재 점수: 0, 콤보: x1
<시도 7, 남은 카드: 12> 좌표를 두 번 입력하세요.
입력 1? (2, 5)
입력 2? (2, 6)
X   X       
    X X 5 5 
X X X X X X 

X   X       
    X X     
X X X X X X 
맛집투어의 차례입니다. 현재 점수: 10, 콤보: x1
<시도 8, 남은 카드: 10> 좌표를 두 번 입력하세요.
입력 1? (3, 1)
입력 2? (3, 2)
X   X       
    X X     
7 7 X X X X 

X   X       
    X X     
    X X X X 
맛집투어의 차례입니다. 현재 점수: 30, 콤보: x2
<시도 9, 남은 카드: 8> 좌표를 두 번 입력하세요.

• 게임 종료 시 출력

13번 시도 만에 완료하였습니다: 게임 종료

<결과 출력>
축하합니다! 승자는 카페투어 입니다.
카페투어: 70 점
맛집투어: 60 점

3 단계: GUI 구현

기능 구현

• 게임 로직은 이미 구현되어 있으므로 화면을 어떻게 보여주어야 하고 그것을 어떻게 구현해야 하는지가 고민이었다.
• Java의 Swing과 awt를 사용하였음.
• GameFrame(extends JFrame)에 StartPanel, GamePanel, ResultPanel(JPanel)을 필요에 따라 호출하여 정보를 출력하도록 구현하였음.
• Java GUI 구현이 생소하여 GPT의 도움을 제일 많이 받은 단계임.
  • EventListner와 PropertyChangeSupport를 사용해 특정 이벤트 발생 시 적절한 처리를 하도록 리팩터링함
• GameManager가 이제 카드 좌표를 입력 받지 않고 이벤트(클릭)에 따라 GameManager가 관리하는 card1과 card2 참조 변수를 필드로 가져 참조하게 하였다.
• 입력을 받지 않으니 게이머 이름을 입력받으면 초기화를 통해 화면까지 뿌려주었다.
• 이전 단계와의 차이점은 더 이상 입력이 없고 출력도 콘솔로 하지 않으므로 클릭 이벤트 발생해도 Control단이 아닌 GameManager단에서 모든 로직이 해결되었음: 화면 제어 클래스 제외
• 화면 구성
  • 1 단계 - 시작 화면
    • 사용자 이름을 두 개 입력받는다.
    • 확인 버튼을 클릭하면 다음 화면으로 넘어감: 입력 값이 올바르지 않으면 화면을 다시 보여준다.
  • 2 단계 - 게임을 시작하면 플레이어 1부터 카드 선택하는 화면
    • 여기에서는 현재 상태: 플레이어 정보, 점수, 콤보, (전체)시도 횟수, (전체)남은 카드가 표시된다.
    • 카드를 보여준다.
    • 입력창은 좌표 2개 입력받도록
  • 3 단계 - 게임 결과를 보여준다.
• 처음에는 카드를 맞추면 안내창을 띄우려고 했지만, 카드를 보여주고, 상태 업데이트 후 2000ms후 뒤집는 것으로 구현하였다.
• Card 클래스는 JButton을 extend하도록 하였으며, Swing에서 지원하는 버튼아이콘을 활용해 카드 보여주는 것을 구현하였다: cover과 image를 필드로 추가하여 필요에 따라 flip 하도록 하였다.

사용 이미지들

TestImpl.java

package codesquad;

import javax.swing.*;
import javax.swing.Timer;
import java.awt.*;
import java.awt.event.ActionListener;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.util.*;
import java.util.List;

public class TestImpl {
    public static void main(String[] args) {
        new Controller();
    }
}

class Controller implements PropertyChangeListener {
    GameManager gameManager;
    GameFrame gameFrame;
    Controller() {
        gameManager = new GameManager();
        gameManager.addPropertyChangeListener1(this);
        gameManager.addPropertyChangeListener2(this);
        gameFrame = new GameFrame(gameManager.getCardDeck());
        gameFrame.startPanel.button.addActionListener(actionEvent -> gameStart());
    }
    
    private void gameStart() {
        String player1 = gameFrame.startPanel.field1.getText();
        String player2 = gameFrame.startPanel.field2.getText();
        

        if(checkStringLength(player1) || checkStringLength(player2) || checkStringValidity(player1, player2)) {
            return;
        }
        
        makePlayers(player1, player2);
        showGameScreen();
    }
    
    private boolean checkStringLength(String player) {
        if(player.length() > 7) {
            JOptionPane.showMessageDialog(null, "7글자 이하로 이름을 입력해 주세요.", "정보",JOptionPane.INFORMATION_MESSAGE);
            gameFrame.startPanel.field1.removeAll();
            return true;
        }
        return false;
    }
    private boolean checkStringValidity(String player1, String player2) {
        if(isStringEmpty(player1) || isStringEmpty(player2)) {
            return true;
        } else return haveSameName(player1, player2);
    }
    private boolean isStringEmpty(String player) {
        if(player.isEmpty()) {
            JOptionPane.showMessageDialog(null, "이름을 채워주세요.", "정보",JOptionPane.INFORMATION_MESSAGE);
            return true;
        }
        return false;
    }
    
    private boolean haveSameName(String player1, String player2) {
        if(player1.equals(player2)) {
            JOptionPane.showMessageDialog(null, "같은 이름을 입력할 수 없습니다.", "정보",JOptionPane.INFORMATION_MESSAGE);
            gameFrame.startPanel.field1.removeAll();
            gameFrame.startPanel.field2.removeAll();
            return true;
        }
        return false;
    }
    
    private void makePlayers(String playerName1, String playerName2) {
        gameManager.doMakePlayer(1, playerName1);
        gameManager.doMakePlayer(2, playerName2);
    }
    
    private void showGameScreen() {
        gameFrame.gamePanel.updateCurrentStatus(gameManager.getWhosTurn().getName(), gameManager.getWhosTurn().getScore(),
                gameManager.getWhosTurn().getCombo(), gameManager.getTrying(), gameManager.countActive());
        gameFrame.turnToGameScreen();
    }
    @Override
    public void propertyChange(PropertyChangeEvent evt) {
        if("Phase Change".equals(evt.getPropertyName())) {
            gameFrame.gamePanel.updateCurrentStatus(gameManager.getWhosTurn().getName(), gameManager.getWhosTurn().getScore(),
                    gameManager.getWhosTurn().getCombo(), gameManager.getTrying(), gameManager.countActive());

            gameFrame.refresh();
        } else if("Game Clear".equals(evt.getPropertyName())) {
            Result result = gameManager.makeResult();
            gameFrame.resultPanel = new ResultPanel(OutputManager.getResult(result), OutputManager.getPoint1(result), OutputManager.getPoint2(result));
            gameFrame.showResult();
        }
        
    }
}

class CardManager {
    public static final int MAX_CARD_NUMBER = 8;
    public static final int CARD_PAIR = 3;
    public static final int ROW = 6;
    public static final int COLUMN = 3;
    public static final int HOW_MANY_CARDS_TO_PICK = ROW * COLUMN;
    
    private CardManager() {}
    
    public static List<Card> makeDeck(GameManager gameManager) {
        List<Card> cards = makeCards(gameManager);

        Collections.shuffle(cards);

        return cards.subList(0, HOW_MANY_CARDS_TO_PICK);
    }
    
    private static List<Card> makeCards(GameManager gameManager) {
        List<Card> cards = new ArrayList<>();

        for(int i = 0;i < CARD_PAIR; i++) {
            for(int j = 1; j < MAX_CARD_NUMBER+1; j++) {
                cards.add(new Card(j, gameManager));
            }
        }
        return cards;
    }
}

class Card extends JButton{
    private final Integer number;
    private Boolean status;
    private final ImageIcon image;
    private final ImageIcon cover;

    Card(int number, GameManager gameManager) {
        this.number = number;
        this.status = Boolean.TRUE;
        this.image = new ImageIcon(Objects.requireNonNull(getClass().getResource("/" + number + ".png")));
        this.cover = new ImageIcon(Objects.requireNonNull(getClass().getResource("/" + 0 + ".png")));
        this.setIcon(cover);
        this.addActionListener(e -> gameManager.cardClicked(Card.this));
    }
    
    public Boolean getStatus() {
        return this.status;
    }
    public Integer getNumber() {
        return this.number;
    }
    public void changeStatus() {
        this.status = !Boolean.TRUE.equals(this.status);
    }
    public void showCard() {
        this.setIcon(this.image);
    }
    public void coverCard() {
        this.setIcon(this.cover);
    }
    
    @Override
    public boolean equals(Object obj) {
        // 같은 객체는 포함하지 않도록 override
        // if(this == obj) return true;
        if(obj == null || getClass() != obj.getClass()) return false;
        return checkEquals(obj);
    }

    private boolean checkEquals(Object obj) {
        Card card = (Card) obj;
        return number.equals(card.getNumber()) && status.equals(card.getStatus()) && this!=obj;
    }

    @Override
    public int hashCode() {
        return Objects.hash(number, status);
    }
}

class GameManager {
    private final List<Card> cardDeck;
    private int trying;
    private Player player1;
    private Player player2;
    private Player whosTurn;
    private Boolean consecutive;
    private Card card1;
    private Card card2;
    private final PropertyChangeSupport pcs1 = new PropertyChangeSupport(this);
    private final PropertyChangeSupport pcs2 = new PropertyChangeSupport(this);


    GameManager() {
        this.cardDeck = CardManager.makeDeck(this);
        this.trying = 0;
        this.player1 = null;
        this.player2 = null;
        this.whosTurn = null;
        this.consecutive = false;
        this.card1 = null;
        this.card2 = null;
    }
    
    public void doMakePlayer(int gamerNum, String playerName) {
        if(gamerNum == 1) {
            this.player1 = new Player(playerName);
        } else {
            this.player2 = new Player(playerName);
            this.whosTurn = player1;
        }
    }
    public List<Card> getCardDeck() {
        return this.cardDeck;
    }
    public void cardClicked(Card cardClicked) {
        if(card1 == null) {
            makeCard1(cardClicked);
        } else if(card2 == null) {
            makeCard2(cardClicked);
        }
    }
    
    private void makeCard1(Card cardClicked) {
        if(!Boolean.TRUE.equals(cardClicked.getStatus())){// 이미 풀린 카드: 아무것도 하지 않는다.
            return;
        }
        card1 = cardClicked;
        card1.showCard();
    }

    private void makeCard2(Card cardClicked) {
        if(cardClicked == card1) {
            card1.coverCard();
            card1 = null;
            return;
        }
        if(!Boolean.TRUE.equals(cardClicked.getStatus())){// 이미 풀린 카드: 아무것도 하지 않는다.
            return;
        }
        card2 = cardClicked;
        card2.showCard();
        checkCard(card1.getNumber(), card2.getNumber());
    }
    public Player getWhosTurn() {
        return this.whosTurn;
    }
    
    private void changeTurn() {
        if(this.whosTurn == this.player1) {
            //턴 바꿀땐 무조건 deactivate
            whosTurn.updateCombo(deactivateConsecutive());
            this.whosTurn = this.player2;
        } else {
            whosTurn.updateCombo(deactivateConsecutive());
            this.whosTurn = this.player1;
        }
    }
    
    private void activateConsecutive() {
        this.consecutive = true;
    }

    private boolean deactivateConsecutive() {
        this.consecutive = false;
        return false;
    }
    
    public void checkCard(Integer cardNumber1, Integer cardNumber2) {
        if(cardNumber1.equals(cardNumber2)) {
            card1.changeStatus();
            card2.changeStatus();
            
            whosTurn.updateCombo(consecutive);
            whosTurn.setScore(); //현재 플레이어의 점수를 업데이트
            activateConsecutive(); // 콤보를 위해 활성화
            if(!isItOver()) {
                doGame();
            } else {
                pcs2.firePropertyChange("Game Clear", null, null);
            }
            return;
        }
        card2.showCard();
        changeTurn();
        doGame();
    }
    
    public void doGame() {
        Timer timer = new Timer(2000, taskPerformer);
        timer.setRepeats(false);
        timer.start();
    }
    ActionListener taskPerformer = actionEvent -> changePhase();

    public void changePhase() {
        resetCards();
        tryMore();
        pcs1.firePropertyChange("Phase Change", null, null);
    }
    
    private void resetCards() {
        card1 = null;
        card2 = null;
        for(Card card: cardDeck) {
            if(card.getStatus() == Boolean.FALSE) {
                card.showCard();
            } else {
                card.coverCard();
            }
        }
    }
    private void tryMore() {
        this.trying += 1;
    }
    public int getTrying() {
        return this.trying;
    }
    
    public boolean isItOver() {
        for(Card card : cardDeck) {
            if(isCardActive(card)) {
                return false;
            }
        }
        return true;
    }
    
    private boolean isCardActive(Card card) {
        if(Boolean.TRUE.equals(card.getStatus())) {
            return checkIdenticalTwin(card);
        }
        return false;
    }
    
    private boolean checkIdenticalTwin(Card card) {
        // Card 클래스의 equal 재정의로 인한 간소화
        return cardDeck.contains(card);
    }
    
    public int countActive() {
        int count = 0;
        for(Card card : cardDeck) {
            if(Boolean.TRUE.equals(card.getStatus())) {
                count += 1;
            }
        }
        return count;
    }
    
    public Result makeResult() {
        return new Result(player1, player2);
    }

    public void addPropertyChangeListener1(PropertyChangeListener listener) {
        pcs1.addPropertyChangeListener(listener);
    }
    public void addPropertyChangeListener2(PropertyChangeListener listener) {
        pcs2.addPropertyChangeListener(listener);
    }
}

class Result {
    private Player winner;
    private Player another;
    private boolean draw;
    
    public Result(Player player1, Player player2) {
        if(player1.getScore() > player2.getScore()) {
            this.winner = player1;
            this.another = player2;
            this.draw = false;
        } else if(player2.getScore() > player1.getScore()) {
            this.winner = player2;
            this.another = player1;
            this.draw = false;
        } else {
            this.draw = true;
            this.winner = player1;
            this.another = player2;
        }
    }
    public Player getWinner() {
        return this.winner;
    }
    public Player getAnother() {
        return this.another;
    }
    public boolean isItDraw() {
        return this.draw;
    }
}

class OutputManager {
    private OutputManager() {}
    
    public static String getResult(Result result) {
        if(!result.isItDraw()) {
            return "<html>축하합니다! 승자는 "+result.getWinner().getName()+" 입니다.</html>";
        } else {
            return "<html>비겼습니다.</html>";
        }
    }
    public static String getPoint1(Result result) {
        return "<html>"+result.getWinner().getName() +": "+ result.getWinner().getScore()+" 점</html>";
    }
    public static String getPoint2(Result result) {
        return "<html>"+result.getAnother().getName() +": "+ result.getAnother().getScore()+" 점</html>";
    }

    public static String printGameStatus(String name, Integer score, Integer combo, Integer trying, Integer activeCount) {
        return "<html> "+name +"의 차례입니다. 현재 점수: "
                + score+", 콤보: x"+combo + "<br><시도 " + trying+", 남은 카드: "+
                activeCount+"></html>";
    }
}

class Player {
    private static final Integer GAME_SCORE_BASE = 10;
    private Integer score;
    private final String name;
    private Integer combo;
    
    public Player(String name) {
        this.name = name;
        this.score = 0;
        this.combo = 1;
    }
    
    public void updateCombo(boolean consecutive) {
        if(consecutive) {
            this.combo *= 2;
            return;
        }
        this.combo = 1;
    }
    public Integer getScore() {
        return this.score;
    }
    
    public Integer getCombo() { return this.combo; }
    
    public String getName() {
        return this.name;
    }
    
    public void setScore() {
        this.score += this.combo * GAME_SCORE_BASE;
    }
}

class GameFrame extends JFrame {
    StartPanel startPanel;
    GamePanel gamePanel;
    ResultPanel resultPanel;
    
    public GameFrame(List<Card> cardDeck) {
        setTitle("카드 맞추기 게임");
        setSize(500, 500);
        this.startPanel = new StartPanel();
        add(startPanel);
        setVisible(true);
        this.gamePanel = new GamePanel(cardDeck);
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }
    
    public void turnToGameScreen() {
        remove(startPanel);
        add(gamePanel);
        revalidate();
        repaint();
    }
    
    public void refresh() {
        revalidate();
        repaint();
    }
    
    public void showResult(){
        remove(gamePanel);
        add(resultPanel);
        revalidate();
        repaint();
    }
}

class StartPanel extends JPanel {
    JLabel name1 = new JLabel("Player 1");
    JLabel name2 = new JLabel("Player 2");
    JLabel introduction = new JLabel("<html>안녕하세요. 카드게임을 시작하겠습니다.<br>시작하기 전에 플레이어 두 명의 이름을 입력해 주세요.<br></html>");
    JTextField field1 = new JTextField(15);
    JTextField field2 = new JTextField(15);
    JButton button = new JButton("게임 시작!");
    public StartPanel() {
        this.makeStartPanelLayout();
    }
    public void makeStartPanelLayout() {
        this.setLayout(new BorderLayout());
        this.add(introduction, BorderLayout.NORTH);
        
        JPanel centralPanel = new JPanel();
        centralPanel.setLayout(new BoxLayout(centralPanel, BoxLayout.X_AXIS));
        
        makeNamePanel(centralPanel);

        JPanel coverPanel = makeSomeSpace(centralPanel);
        
        this.add(coverPanel, BorderLayout.CENTER);
        this.add(button, BorderLayout.SOUTH);
    }
    
    private void makeNamePanel(JPanel centralPanel) {
        JPanel panelOne = new JPanel();
        panelOne.add(name1);
        panelOne.add(field1);
        field1.setMaximumSize(field1.getPreferredSize());

        JPanel panelTwo = new JPanel();
        panelTwo.add(name2);
        panelTwo.add(field2);
        field2.setMaximumSize(field2.getPreferredSize());

        centralPanel.add(panelOne);
        centralPanel.add(panelTwo);
    }
    private JPanel makeSomeSpace(JPanel centralPanel) {
        JPanel outerPanel = new JPanel();
        outerPanel.setLayout(new BoxLayout(outerPanel, BoxLayout.Y_AXIS));
        outerPanel.add(Box.createVerticalGlue());
        outerPanel.add(centralPanel);
        outerPanel.add(Box.createVerticalGlue());
        return outerPanel;
    }
}

class GamePanel extends JPanel {
    JLabel introduction = new JLabel();
    JPanel cardGridPanel = new JPanel(new GridLayout(3, 6));
    
    public GamePanel(List<Card> cardDeck) {
        setLayout();
        makeCardGrid(cardDeck);
    }
    
    public void updateCurrentStatus(String name, Integer score, Integer combo, Integer trying, Integer activeCount) {
        introduction.setText(OutputManager.printGameStatus(name, score, combo, trying, activeCount));
    }
    private void setLayout() {
        this.setLayout(new BorderLayout());
        this.add(introduction, BorderLayout.NORTH);
        this.add(cardGridPanel, BorderLayout.CENTER);
    }
    private void makeCardGrid(List<Card> cardDeck) {
        for(int i = 0; i < 18; i++) {
            cardGridPanel.add(cardDeck.get(i));
        }
    }
}

class ResultPanel extends JPanel {
    JLabel introduction = new JLabel("<게 임  결 과>");
    JLabel winner = new JLabel();
    JLabel player1Result = new JLabel();
    JLabel player2Result = new JLabel();
    
    ResultPanel(String winner, String result1, String result2) {
        setFonts();
        setLayout(winner, result1, result2);
        makeComponent();
    }
    private void setFonts() {
        Font font = new Font("Arial", Font.BOLD, 20);
        this.winner.setFont(font);
        this.player1Result.setFont(font);
        this.player2Result.setFont(font);
    }
    private void setLayout(String winner, String result1, String result2) {
        this.setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
        this.winner.setText(winner);
        this.winner.setAlignmentX(Component.CENTER_ALIGNMENT);
        this.winner.setMaximumSize(new Dimension(40*10, this.winner.getMinimumSize().height));

        this.player1Result.setText(result1);
        this.player1Result.setAlignmentX(Component.CENTER_ALIGNMENT);
        this.player1Result.setMaximumSize(new Dimension(25*10, this.player1Result.getMinimumSize().height));

        this.player2Result.setText(result2);
        this.player2Result.setAlignmentX(Component.CENTER_ALIGNMENT);
        this.player2Result.setMaximumSize(new Dimension(25*10, this.player2Result.getMinimumSize().height));
    }
    
    private void makeComponent() {
        this.add(Box.createVerticalGlue());
        this.add(this.winner);
        this.add(Box.createRigidArea(new Dimension(0, 10)));
        this.add(this.player1Result);
        this.add(Box.createRigidArea(new Dimension(0, 10)));
        this.add(this.player2Result);
        this.add(Box.createVerticalGlue());

    }
}