Assignment 2：Painting a Winner, Part 1：Solo Red

package cs3500.solored.model.hw02;

/**
 * Card接口的实现，表示游戏中的卡牌。
 */
public class CardImpl implements Card {

    private final Color color;
    private final int number;

    /**
     * 构造函数，创建一张指定颜色和数字的卡牌。
     *
     * @param color  卡牌的颜色
     * @param number 卡牌的数字
     * @throws IllegalArgumentException 如果颜色为null，或数字不在1到7之间
     */
    public CardImpl(Color color, int number) {
        if (color == null) {
            throw new IllegalArgumentException("颜色不能为空");
        }
        if ((number < 1 || number > 7) && number != -1) {
            throw new IllegalArgumentException("数字必须在1到7之间，除非是特殊的画布卡牌");
        }
        this.color = color;
        this.number = number;
    }

    /**
     * 获取卡牌的颜色。
     *
     * @return 卡牌的颜色
     */
    public Color getColor() {
        return color;
    }

    /**
     * 获取卡牌的数字。
     *
     * @return 卡牌的数字
     */
    public int getNumber() {
        return number;
    }

    @Override
    public String toString() {
        if (number == -1) {
            // 特殊处理画布卡牌的显示，只显示颜色代码
            return color.getCode();
        }
        return color.getCode() + String.valueOf(number);
//        return color.getCode() + number;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        CardImpl card = (CardImpl) o;

        if (number != card.number) return false;
        return color == card.color;
    }

    @Override
    public int hashCode() {
        int result = color != null ? color.hashCode() : 0;
        result = 31 * result + number;
        return result;
    }
}

package cs3500.solored.model.hw02;

/**
 * 表示游戏中使用的颜色枚举。
 */
public enum Color {
    RED("R", 5),
    ORANGE("O", 4),
    BLUE("B", 3),
    INDIGO("I", 2),
    VIOLET("V", 1);

    private final String code;
    private final int rank;

    Color(String code, int rank) {
        this.code = code;
        this.rank = rank;
    }

    /**
     * 获取颜色的代码表示。
     * @return 颜色的代码表示
     */
    public String getCode() {
        return code;
    }

    /**
     * 获取颜色的等级，用于比较颜色的顺序。
     * @return 颜色的等级
     */
    public int getRank() {
        return rank;
    }
}

package cs3500.solored.model.hw02;

import java.util.List;

/**
 * Behaviors for a solo game of RedSeven.
 * The game consists of four structures:
 * <ul>
 *   <li>A deck of cards to draw from</li>
 *   <li>A hand to play from</li>
 *   <li>Four palettes to play to</li>
 *   <li>A canvas that dictates the winning rule</li>
 * </ul>
 * The goal of the game is to use all the cards in the deck
 * while ensuring exactly one palette is winning each round.
 * @param <C> the type of cards used
 */
public interface RedGameModel<C extends Card> {

  //Operations

  /**
   * Play the given card from the hand to the losing palette chosen.
   * The card is removed from the hand and placed at the far right
   * end of the palette.
   *
   * @param paletteIdx a 0-index number representing which palette to play to
   * @param cardIdxInHand a 0-index number representing the card to play from the hand
   * @throws IllegalStateException if the game has not started or the game is over
   * @throws IllegalArgumentException if paletteIdx < 0 or more than the number of palettes
   * @throws IllegalArgumentException if cardIdxInHand < 0
   *     or greater/equal to the number of cards in hand
   * @throws IllegalStateException if the palette referred to by paletteIdx is winning
   */
  void playToPalette(int paletteIdx, int cardIdxInHand);

  /**
   * Play the given card from the hand to the canvas.
   * This changes the rules of the game for all palettes.
   * The method can only be called once per turn.
   *
   * @param cardIdxInHand a 0-index number representing the card to play from the hand
   * @throws IllegalStateException if the game has not started or the game is over
   * @throws IllegalArgumentException if cardIdxInHand < 0
   *     or greater/equal to the number of cards in hand
   * @throws IllegalStateException if this method was already called once in a given turn
   * @throws IllegalStateException if there is exactly one card in hand
   */
  void playToCanvas(int cardIdxInHand);

  /**
   * Draws cards from the deck until the hand is full
   * OR until the deck is empty, whichever occurs first. Newly drawn cards
   * are added to the end of the hand (far-right conventionally).
   * SIDE-EFFECT: Allows the player to play to the canvas again.
   *
   * @throws IllegalStateException if the game has not started or the game is over
   */
  void drawForHand();

  /**
   * Starts the game with the given options. The deck given is used
   * to set up the palettes and hand. Modifying the deck given to this method
   * will not modify the game state in any way.
   *
   * @param deck the cards used to set up and play the game
   * @param shuffle whether the deck should be shuffled prior to setting up the game
   * @param numPalettes number of palettes in the game
   * @param handSize the maximum number of cards allowed in the hand
   * @throws IllegalStateException if the game has started or the game is over
   * @throws IllegalArgumentException if numPalettes < 2 or handSize <= 0
   * @throws IllegalArgumentException if deck's size is not large enough to setup the game
   * @throws IllegalArgumentException if deck has non-unique cards or null cards
   */
  void startGame(List<C> deck, boolean shuffle, int numPalettes, int handSize);

  //Observations

  /**
   * Returns the number of cards remaining in the deck used in the game.
   * @return the number of cards in the deck
   * @throws IllegalStateException if the game has not started
   */
  int numOfCardsInDeck();

  /**
   * Returns the number of palettes in the running game.
   * @return the number of palettes in the game
   * @throws IllegalStateException if the game has not started
   */
  int numPalettes();

  /**
   * Returns the index of the winning palette in the game.
   * @return the 0-based index of the winning palette
   * @throws IllegalStateException if the game has not started
   */
  int winningPaletteIndex();

  /**
   * Returns if the game is over as specified by the implementation.
   * @return true if the game has ended and false otherwise
   * @throws IllegalStateException if the game has not started
   */
  boolean isGameOver();

  /**
   * Returns if the game is won by the player as specified by the implementation.
   * @return true if the game has been won or false if the game has not
   * @throws IllegalStateException if the game has not started or the game is not over
   */
  boolean isGameWon();

  /**
   * Returns a copy of the hand in the game. This means modifying the returned list
   * or the cards in the list has no effect on the game.
   * @return a new list containing the cards in the player's hand in the same order
   *     as in the current state of the game.
   * @throws IllegalStateException if the game has not started
   */
  List<C> getHand();

  /**
   * Returns a copy of the specified palette. This means modifying the returned list
   * or the cards in the list has no effect on the game.
   * @param paletteNum 0-based index of a particular palette
   * @return a new list containing the cards in specified palette in the same order
   *     as in the current state of the game.
   * @throws IllegalStateException if the game has not started
   * @throws IllegalArgumentException if paletteIdx < 0 or more than the number of palettes
   */
  List<C> getPalette(int paletteNum);

  /**
   * Return the top card of the canvas.
   * Modifying this card has no effect on the game.
   * @return the top card of the canvas
   * @throws IllegalStateException if the game has not started or the game is over
   */
  C getCanvas();

  /**
   * Get a NEW list of all cards that can be used to play the game.
   * Editing this list should have no effect on the game itself.
   * Repeated calls to this method should produce a list of cards in the same order.
   * Modifying the cards in this list should have no effect on any returned list
   * or the game itself.
   * @return a new list of all possible cards that can be used for the game
   */
  List<C> getAllCards();
}

package cs3500.solored.model.hw02;

import java.util.*;

/**
 * RedGameModel接口的实现，表示Solo Red游戏的模型。
 */
public class SoloRedGameModel implements RedGameModel<CardImpl> {

    private List<CardImpl> deck;
    private List<CardImpl> hand;
    private List<List<CardImpl>> palettes;
    private CardImpl canvas;
    private int handSize;
    private int numPalettes;
    private Random rand;
    private boolean gameStarted;
    private boolean gameOver;
    private boolean gameWon;
    private boolean canPlayToCanvas;

    /**
     * 无参数构造函数，初始化游戏，准备开始。
     */
    public SoloRedGameModel() {
        this.rand = new Random();
        this.gameStarted = false;
    }

    /**
     * 带有随机数生成器的构造函数，用于测试随机性相关的属性。
     *
     * @param rand 随机数生成器
     * @throws IllegalArgumentException 如果rand为null
     */
    public SoloRedGameModel(Random rand) {
        if (rand == null) {
            throw new IllegalArgumentException("Random对象不能为空");
        }
        this.rand = rand;
        this.gameStarted = false;
    }

    @Override
    public List<CardImpl> getAllCards() {
        List<CardImpl> allCards = new ArrayList<>();
        for (Color color : Color.values()) {
            for (int number = 1; number <= 7; number++) {
                allCards.add(new CardImpl(color, number));
            }
        }
        return allCards;
    }

    @Override
    public void startGame(List<CardImpl> deck, boolean shuffle, int numPalettes, int handSize) {
        if (gameStarted) {
            throw new IllegalStateException("游戏已经开始");
        }
        if (gameOver) {
            throw new IllegalStateException("游戏已经结束");
        }
        if (numPalettes < 2) {
            throw new IllegalArgumentException("调色板数量必须至少为2");
        }
        if (handSize <= 0) {
            throw new IllegalArgumentException("手牌数量必须为正数");
        }
        if (deck == null) {
            throw new IllegalArgumentException("牌堆不能为空");
        }

        // 检查牌堆中是否有重复或null卡牌
        Set<CardImpl> cardSet = new HashSet<>(deck);
        if (cardSet.size() != deck.size()) {
            throw new IllegalArgumentException("牌堆中包含重复的卡牌");
        }
        for (CardImpl card : deck) {
            if (card == null) {
                throw new IllegalArgumentException("牌堆中包含null卡牌");
            }
        }

        int requiredCards = numPalettes + handSize;
        if (deck.size() < requiredCards) {
            throw new IllegalArgumentException("牌堆中的卡牌数量不足以设置游戏");
        }

        this.deck = new ArrayList<>(deck);
        if (shuffle) {
            Collections.shuffle(this.deck, rand);
        }

        this.numPalettes = numPalettes;
        this.handSize = handSize;
        this.palettes = new ArrayList<>();

        // 初始化调色板
        for (int i = 0; i < numPalettes; i++) {
            List<CardImpl> palette = new ArrayList<>();
            palette.add(this.deck.remove(0));
            palettes.add(palette);
        }

        // 初始化画布为红色（特殊卡）
        this.canvas = new CardImpl(Color.RED, -1);

        // 初始化手牌
        this.hand = new ArrayList<>();
        while (hand.size() < handSize && !deck.isEmpty()) {
//            hand.add(deck.remove(0));
            hand.add(this.deck.remove(0));
        }

        this.gameStarted = true;
        this.gameOver = false;
        this.gameWon = false;
        this.canPlayToCanvas = true;
    }

    @Override
    public void playToPalette(int paletteIdx, int cardIdxInHand) {
        if (!gameStarted) {
            throw new IllegalStateException("游戏尚未开始");
        }
        if (gameOver) {
            throw new IllegalStateException("游戏已经结束");
        }
        if (paletteIdx < 0 || paletteIdx >= numPalettes) {
            throw new IllegalArgumentException("无效的调色板索引");
        }
        if (cardIdxInHand < 0 || cardIdxInHand >= hand.size()) {
            throw new IllegalArgumentException("手牌中无效的卡牌索引");
        }

        int winningPaletteIdx = winningPaletteIndex();
        if (paletteIdx == winningPaletteIdx) {
            throw new IllegalStateException("该调色板已经是赢家");
        }

        // 从手牌中移除卡牌
        CardImpl cardToPlay = hand.remove(cardIdxInHand);
        // 将卡牌添加到调色板的最右端
        palettes.get(paletteIdx).add(cardToPlay);

        // 检查该调色板是否现在赢得了比赛
        winningPaletteIdx = winningPaletteIndex();
//        if (paletteIdx == winningPaletteIdx) {
        if (paletteIdx != winningPaletteIdx) {
            gameOver = true;
            gameWon = false;
            // 调色板现在是赢家
            // 补充手牌
//            drawForHand();
            // 重置canPlayToCanvas
//            canPlayToCanvas = true;
//
//            // 检查游戏是否已经赢了
//            if (hand.isEmpty() && deck.isEmpty()) {
//                gameOver = true;
//                gameWon = true;
//            }
        } // else {
//            // 调色板仍然未获胜，游戏结束，玩家失败
//            gameOver = true;
//            gameWon = false;
//        }
    }

    @Override
    public void playToCanvas(int cardIdxInHand) {
        if (!gameStarted) {
            throw new IllegalStateException("游戏尚未开始");
        }
        if (gameOver) {
            throw new IllegalStateException("游戏已经结束");
        }
        if (!canPlayToCanvas) {
            throw new IllegalStateException("每回合只能一次更改画布");
        }
        if (hand.size() == 1) {
            throw new IllegalStateException("手牌只剩一张时不能更改画布");
        }
        if (cardIdxInHand < 0 || cardIdxInHand >= hand.size()) {
            throw new IllegalArgumentException("手牌中无效的卡牌索引");
        }

        // 从手牌中移除卡牌
        CardImpl cardToPlay = hand.remove(cardIdxInHand);
        // 将卡牌放置在画布上
        canvas = cardToPlay;
        // 设置canPlayToCanvas为false
        canPlayToCanvas = false;
    }

    @Override
    public void drawForHand() {
        if (!gameStarted) {
            throw new IllegalStateException("游戏尚未开始");
        }
        if (gameOver) {
            throw new IllegalStateException("游戏已经结束");
        }
        // 从牌堆中抽牌直到手牌满或牌堆为空
        while (hand.size() < handSize && !deck.isEmpty()) {
            hand.add(deck.remove(0));
        }
        // 重置canPlayToCanvas
        canPlayToCanvas = true;
    }

    @Override
    public int numOfCardsInDeck() {
        if (!gameStarted) {
            throw new IllegalStateException("游戏尚未开始");
        }
        return deck.size();
    }

    @Override
    public int numPalettes() {
        if (!gameStarted) {
            throw new IllegalStateException("游戏尚未开始");
        }
        return numPalettes;
    }

    @Override
    public int winningPaletteIndex() {
        if (!gameStarted) {
            throw new IllegalStateException("游戏尚未开始");
        }

        List<Integer> winningPalettes = new ArrayList<>();

        // 根据当前规则，找到所有可能的赢家调色板索引
        for (int i = 0; i < palettes.size(); i++) {
            if (isWinningPalette(i)) {
                winningPalettes.add(i);
            }
        }

        // 如果只有一个赢家，返回其索引
        if (winningPalettes.size() == 1) {
            return winningPalettes.get(0);
        } else if (winningPalettes.size() > 1) {
            // 如果有平局，根据红色规则打破平局
            return breakTie(winningPalettes);
        } else {
            // 如果没有赢家，返回-1
            return -1;
        }
    }

    private boolean isWinningPalette(int paletteIdx) {
        List<CardImpl> palette = palettes.get(paletteIdx);
        String ruleColorCode = canvas.getColor().getCode();

        // 根据规则颜色，判断调色板是否获胜
        switch (ruleColorCode) {
            case "R":
                return isHighestCard(paletteIdx);
            case "O":
                return isMostOfOneNumber(paletteIdx);
            case "B":
                return isMostColors(paletteIdx);
            case "I":
                return isLongestRun(paletteIdx);
            case "V":
                return isMostBelowFour(paletteIdx);
            default:
                return false;
        }
    }

    // 判断是否为最高卡牌
    private boolean isHighestCard(int paletteIdx) {
        CardImpl highestCard = getHighestCard(palettes.get(paletteIdx));
        for (int i = 0; i < palettes.size(); i++) {
            if (i != paletteIdx) {
                CardImpl otherHighest = getHighestCard(palettes.get(i));
                if (compareCards(otherHighest, highestCard) > 0) {
                    return false;
                } else if (compareCards(otherHighest, highestCard) == 0) {
                    // 平局，继续
                    continue;
                }
            }
        }
        return true;
    }

    // 判断是否拥有最多相同数字的卡牌
    private boolean isMostOfOneNumber(int paletteIdx) {
        Map<Integer, Integer> countMap = getNumberCountMap(palettes.get(paletteIdx));
        int maxCount = Collections.max(countMap.values());

        for (int i = 0; i < palettes.size(); i++) {
            if (i != paletteIdx) {
                Map<Integer, Integer> otherCountMap = getNumberCountMap(palettes.get(i));
                int otherMaxCount = Collections.max(otherCountMap.values());
                if (otherMaxCount > maxCount) {
                    return false;
                } else if (otherMaxCount == maxCount) {
                    // 平局，继续
                    continue;
                }
            }
        }
        return true;
    }

    // 判断是否拥有最多不同颜色的卡牌
    private boolean isMostColors(int paletteIdx) {
        Set<Color> colors = getColorsSet(palettes.get(paletteIdx));
        int colorCount = colors.size();

        for (int i = 0; i < palettes.size(); i++) {
            if (i != paletteIdx) {
                Set<Color> otherColors = getColorsSet(palettes.get(i));
                int otherColorCount = otherColors.size();
                if (otherColorCount > colorCount) {
                    return false;
                } else if (otherColorCount == colorCount) {
                    // 平局，继续
                    continue;
                }
            }
        }
        return true;
    }

    // 判断是否拥有最长的连续序列
    private boolean isLongestRun(int paletteIdx) {
        int maxRunLength = getLongestRunLength(palettes.get(paletteIdx));

        for (int i = 0; i < palettes.size(); i++) {
            if (i != paletteIdx) {
                int otherMaxRunLength = getLongestRunLength(palettes.get(i));
                if (otherMaxRunLength > maxRunLength) {
                    return false;
                } else if (otherMaxRunLength == maxRunLength) {
                    // 平局，继续
                    continue;
                }
            }
        }
        return true;
    }

    // 判断是否拥有最多小于4的卡牌
    private boolean isMostBelowFour(int paletteIdx) {
        int count = getBelowFourCount(palettes.get(paletteIdx));

        for (int i = 0; i < palettes.size(); i++) {
            if (i != paletteIdx) {
                int otherCount = getBelowFourCount(palettes.get(i));
                if (otherCount > count) {
                    return false;
                } else if (otherCount == count) {
                    // 平局，继续
                    continue;
                }
            }
        }
        return true;
    }

    // 获取调色板中最高的卡牌
    private CardImpl getHighestCard(List<CardImpl> palette) {
        return palette.stream().max(this::compareCards).orElse(null);
    }

    // 比较两张卡牌，返回负数表示c1<c2，零表示相等，正数表示c1>c2
    private int compareCards(CardImpl c1, CardImpl c2) {
        if (c1.getNumber() != c2.getNumber()) {
            return c1.getNumber() - c2.getNumber();
        } else {
            return c1.getColor().getRank() - c2.getColor().getRank();
        }
    }

    // 获取数字出现次数的映射
    private Map<Integer, Integer> getNumberCountMap(List<CardImpl> palette) {
        Map<Integer, Integer> countMap = new HashMap<>();
        for (CardImpl card : palette) {
            countMap.put(card.getNumber(), countMap.getOrDefault(card.getNumber(), 0) + 1);
        }
        return countMap;
    }

    // 获取颜色集合
    private Set<Color> getColorsSet(List<CardImpl> palette) {
        Set<Color> colors = new HashSet<>();
        for (CardImpl card : palette) {
            colors.add(card.getColor());
        }
        return colors;
    }

    // 获取最长连续序列的长度
    private int getLongestRunLength(List<CardImpl> palette) {
        if (palette.isEmpty()) {
            return 0;
        }
        Set<Integer> numberSet = new HashSet<>();
        for (CardImpl card : palette) {
            numberSet.add(card.getNumber());
        }
        List<Integer> numbers = new ArrayList<>(numberSet);
        Collections.sort(numbers);
        int maxRun = 1;
        int currentRun = 1;
        for (int i = 1; i < numbers.size(); i++) {
            if (numbers.get(i) == numbers.get(i - 1) + 1) {
                currentRun++;
                maxRun = Math.max(maxRun, currentRun);
            } else {
                currentRun = 1;
            }
        }
        return maxRun;
    }

    // 获取小于4的卡牌数量
    private int getBelowFourCount(List<CardImpl> palette) {
        int count = 0;
        for (CardImpl card : palette) {
            if (card.getNumber() < 4) {
                count++;
            }
        }
        return count;
    }

    // 打破平局，返回赢家调色板的索引
    private int breakTie(List<Integer> tiedPalettes) {
        List<CardImpl> winningCards = new ArrayList<>();
        for (int idx : tiedPalettes) {
            List<CardImpl> palette = palettes.get(idx);
            List<CardImpl> winningCardsInPalette = getWinningCardsInPalette(palette);
            CardImpl highestCard = winningCardsInPalette.stream().max(this::compareCards).orElse(null);
            winningCards.add(highestCard);
        }

        CardImpl highestCardOverall = winningCards.stream().max(this::compareCards).orElse(null);
        int winningIdx = -1;
        for (int i = 0; i < winningCards.size(); i++) {
            if (compareCards(winningCards.get(i), highestCardOverall) == 0) {
                winningIdx = tiedPalettes.get(i);
                break;
            }
        }
        return winningIdx;
    }

    // 获取调色板中用于获胜的卡牌（根据当前规则）
    private List<CardImpl> getWinningCardsInPalette(List<CardImpl> palette) {
        String ruleColorCode = canvas.getColor().getCode();
        List<CardImpl> winningCards = new ArrayList<>();

        switch (ruleColorCode) {
            case "R":
                CardImpl highestCard = getHighestCard(palette);
                winningCards.add(highestCard);
                break;
            case "O":
                Map<Integer, Integer> countMap = getNumberCountMap(palette);
                int maxCount = Collections.max(countMap.values());
                for (CardImpl card : palette) {
                    if (countMap.get(card.getNumber()) == maxCount) {
                        winningCards.add(card);
                    }
                }
                break;
            case "B":
                // 所有不同颜色的卡牌
                Set<Color> colors = getColorsSet(palette);
                for (Color color : colors) {
                    for (CardImpl card : palette) {
                        if (card.getColor() == color) {
                            winningCards.add(card);
                            break;
                        }
                    }
                }
                break;
//                Set<Color> colorsB = getColorsSet(palette);
//                for (Color color : colorsB) {
//                    CardImpl highestCardOfColor = null;
//                    for (CardImpl card : palette) {
//                        if (card.getColor() == color) {
//                            if (highestCardOfColor == null || compareCards(card, highestCardOfColor) > 0) {
//                                highestCardOfColor = card;
//                            }
//                        }
//                    }
//                    if (highestCardOfColor != null) {
//                        winningCards.add(highestCardOfColor);
//                    }
//                }
//                break;
            case "I":
                // 最长连续序列中的卡牌
                Set<Integer> numberSet = new HashSet<>();
                for (CardImpl card : palette) {
                    numberSet.add(card.getNumber());
                }
                List<Integer> numbers = new ArrayList<>(numberSet);
                Collections.sort(numbers);
                int maxRun = getLongestRunLength(palette);
                for (int i = 0; i <= numbers.size() - maxRun; i++) {
                    boolean isRun = true;
                    for (int j = 1; j < maxRun; j++) {
                        if (numbers.get(i + j) != numbers.get(i + j - 1) + 1) {
                            isRun = false;
                            break;
                        }
                    }
                    if (isRun) {
                        for (int k = i; k < i + maxRun; k++) {
                            int num = numbers.get(k);
                            for (CardImpl card : palette) {
                                if (card.getNumber() == num) {
                                    winningCards.add(card);
                                    break;
                                }
                            }
                        }
                        break;
                    }
                }
                break;
            case "V":
                // 小于4的卡牌
                for (CardImpl card : palette) {
                    if (card.getNumber() < 4) {
                        winningCards.add(card);
                    }
                }
                break;
            default:
                break;
        }

        return winningCards;
    }

    @Override
    public boolean isGameOver() {
        if (!gameStarted) {
            throw new IllegalStateException("游戏尚未开始");
        }
        return gameOver;
    }

    @Override
    public boolean isGameWon() {
        if (!gameStarted) {
            throw new IllegalStateException("游戏尚未开始");
        }
        if (!gameOver) {
            throw new IllegalStateException("游戏尚未结束");
        }
        return gameWon;
    }

    @Override
    public List<CardImpl> getHand() {
        if (!gameStarted) {
            throw new IllegalStateException("游戏尚未开始");
        }
        return new ArrayList<>(hand);
    }

    @Override
    public List<CardImpl> getPalette(int paletteNum) {
        if (!gameStarted) {
            throw new IllegalStateException("游戏尚未开始");
        }
        if (paletteNum < 0 || paletteNum >= numPalettes) {
            throw new IllegalArgumentException("无效的调色板索引");
        }
        return new ArrayList<>(palettes.get(paletteNum));
    }

    @Override
    public CardImpl getCanvas() {
        if (!gameStarted) {
            throw new IllegalStateException("游戏尚未开始");
        }
        if (gameOver) {
            throw new IllegalStateException("游戏已经结束");
        }
        return canvas;
    }
}

package cs3500.solored.view.hw02;

/**
 * Behaviors needed for a view of the RedSeven implementation
 * that transmits information to the user.
 */
public interface RedGameView {

  /**
   * Creates a String with state of the game.
   * This rendering includes
   * <ul>
   *   <li>The color of the card on the Canvas</li>
   *   <li>Each palette from P1 to Pn, where n is the number of palettes, where each palette
   *   has all of its card printed with one space between them</li>
   *   <li>A greater than symbol indicating the winning palette</li>
   *   <li>The hand, where all cards are printed with one space between them</li>
   * </ul>
   * An example below for a 4-palette, 7-hand game in-progress
   * Canvas: R
   * P1: R6 B1
   * > P2: R7
   * P3: V1
   * P4: I2
   * Hand: V2 I3 R1 O2 G6 R5 O1
   * @return
   */
  String toString();
}

package cs3500.solored.view.hw02;

import cs3500.solored.model.hw02.RedGameModel;

import java.util.List;

/**
 * RedGameView接口的实现，用于以文本形式显示游戏状态。
 */
public class SoloRedGameTextView implements RedGameView {
    private final RedGameModel<?> model;

    public SoloRedGameTextView(RedGameModel<?> model) {
        this.model = model;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        try {
            sb.append("Canvas: ").append(model.getCanvas().toString()).append("\n");
            int winningPaletteIdx = model.winningPaletteIndex();
            for (int i = 0; i < model.numPalettes(); i++) {
                if (i == winningPaletteIdx) {
                    sb.append("> ");
                } // else {
//                    sb.append("  ");
//                }
                sb.append("P").append(i + 1).append(": ");
                List<?> palette = model.getPalette(i);
                for (int j = 0; j < palette.size(); j++) {
                    sb.append(palette.get(j).toString());
                    if (j < palette.size() - 1) {
                        sb.append(" ");
                    }
                }
                sb.append("\n");
            }
            sb.append("Hand: ");
            List<?> hand = model.getHand();
            for (int i = 0; i < hand.size(); i++) {
                sb.append(hand.get(i).toString());
                if (i < hand.size() - 1) {
                    sb.append(" ");
                }
            }
        } catch (IllegalStateException e) {
            return "游戏尚未开始。";
        }
        return sb.toString();
    }
}

package cs3500.solored;

import cs3500.solored.model.hw02.*;
import cs3500.solored.view.hw02.SoloRedGameTextView;

import java.util.List;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // 创建游戏模型
        SoloRedGameModel model = new SoloRedGameModel();
        // 获取所有卡牌
        List<CardImpl> allCards = model.getAllCards();
        // 开始游戏
//        model.startGame(allCards, true, 4, 7);
//        model.startGame(allCards, false, 4, 7);
        model.startGame(allCards, false, 4, 1);
        // 创建视图
        SoloRedGameTextView view = new SoloRedGameTextView(model);
        // 显示游戏状态
        System.out.println(view.toString());

        // 模拟游戏进行
        Scanner scanner = new Scanner(System.in);
        while (!model.isGameOver()) {
            System.out.println("\n请选择操作：");
            System.out.println("1. 将手牌打到调色板");
            System.out.println("2. 将手牌打到画布并将手牌打到调色板");
            System.out.print("请输入选项（1或2）：");
            int choice = scanner.nextInt();

            if (choice == 1) {
                System.out.print("请输入要打出的手牌索引（从0开始）：");
                int handIdx = scanner.nextInt();
                System.out.print("请输入要打到的调色板索引（从0开始）：");
                int paletteIdx = scanner.nextInt();
                try {
                    model.playToPalette(paletteIdx, handIdx);
                    System.out.println("操作成功！");
                } catch (Exception e) {
                    System.out.println("操作失败：" + e.getMessage());
                }
            } else if (choice == 2) {
                System.out.print("请输入要打到画布的手牌索引（从0开始）：");
                int canvasHandIdx = scanner.nextInt();
                System.out.print("请输入要打出的手牌索引（从0开始）：");
                int handIdx = scanner.nextInt();
                System.out.print("请输入要打到的调色板索引（从0开始）：");
                int paletteIdx = scanner.nextInt();
                try {
                    model.playToCanvas(canvasHandIdx);
                    model.playToPalette(paletteIdx, handIdx);
                    System.out.println("操作成功！");
                } catch (Exception e) {
                    System.out.println("操作失败：" + e.getMessage());
                }
            } else {
                System.out.println("无效的选项，请重试。");
                continue;
            }

            // 更新视图并显示
            System.out.println(view.toString());
        }

        if (model.isGameWon()) {
            System.out.println("\n恭喜！你赢得了游戏！");
        } else {
            System.out.println("\n游戏结束，你输了。");
        }
    }
}