Java扑克牌比大小游戏

Question

功能描述：2个用户对一副扑克牌（54张含大小王）进行抽牌后比较大小判断输赢。用户选择比较方式（分为一张牌比较和两张牌比较两种方式），用户输入底牌的数量（一张牌比较模式底牌最少２张最多５４张；两张牌比较模式底牌最少４张最多５４张），即从５４张牌中随机抽出足够数量的底牌。用户Ａ和用户Ｂ分别从底牌中抽取牌进行比较，然后判断谁赢谁输，最后让用户选择是否在玩一次。一张牌大小比较规则：大王〉小王〉Ａ〉Ｋ〉Ｑ〉Ｊ〉２，相同点数按照花色黑〉红〉梅〉方进行比较。两张牌大小比较规则：对子大于非对子，均为单张即按照一张牌比较规则比较最大那张，均为对子按一张牌点数比较规则，双方对子点数一样，比较花色，即拥有黑桃的赢。

Answer 1

引自免费微信小程序：皆我百晓生

要解决这个问题，我们可以设计一个Java程序来实现这个扑克牌大小比较游戏。首先，我们需要定义一些基本的数据结构来存储扑克牌的点数、花色以及它们之间的关系。接下来，我们将实现两个类：Player 和 Card。Player 类将负责玩家的操作，包括输入底牌的数量和操作类型，而 Card 类则用于表示每一张牌。

以下是具体的步骤和代码示例：

1. 定义数据结构：

   • Card类：包含牌的点数、花色和值。
   • Player类：包含玩家的信息，如手牌、当前操作类型等。
   • Hand类：包含所有已抽取的牌，用于保存和管理牌。

2. 实现逻辑：

   • 首先，创建一个方法 playRound 来处理整个游戏循环，每次循环会调用 dealCards 方法来处理新的牌并执行比较操作。
   • 在 dealCards 方法中，我们首先处理玩家的选择（一张牌或两张牌的比较）。接着，根据玩家的选择和当前可用的牌数量，决定如何分配新牌到玩家手中。
   • 对于一张牌的比较，我们会随机选择两张牌，并且确保它们之间没有相同的点数。对于两张牌的比较，则会比较它们的最大点数。

3. 编写主函数：

   • 创建一个 Game 类来控制整个游戏流程，它接收用户输入、处理游戏逻辑，并显示结果。

下面是一个简化版的示例代码，其中我们只实现了基础的游戏逻辑：

import java.util.Random;

public class PokerGame {
    private static final int CARD_VALUE = 10;
    private static final int SMALLER = 1;
    private static final int Bigger = 2;

    public enum CardType {
        HEARTS("Hearts"),
        DIAMONDS("Diamonds"),
        SPADES("Spades"),
        CLUBS("Clubs");

        private String suit;

        CardType(String suit) {
            this.suit = suit;
        }

        @Override
        public String toString() {
            return suit;
        }
    }

    public enum OperationType {
        ONE_CARD_COMPARISON,
        TWO_CARD_COMPARISON;

        @Override
        public String toString() {
            switch (this) {
                case ONE_CARD_COMPARISON:
                    return "One card comparison";
                case TWO_CARD_COMPARISON:
                    return "Two cards comparison";
                default:
                    throw new IllegalStateException("Invalid operation type");
            }
        }
    }

    public static void main(String[] args) {
        // Create a game instance and start the game loop
        Game game = new Game();
        while (!game.isGameOver()) {
            game.playRound();
        }
    }

    public interface Card {
        String getSuit();

        int getValue();
    }

    public abstract class Player {
        protected Hand hand;
        protected OperationType currentOperation;

        public Player(Hand hand, OperationType currentOperation) {
            this.hand = hand;
            this.currentOperation = currentOperation;
        }

        public abstract boolean play(Card card);

        public abstract boolean drawCard();

        public abstract void setOperation(OperationType op);
    }

    public class Player implements Player {
        private Hand hand;
        private OperationType currentOperation;

        public Player(Hand hand, OperationType currentOperation) {
            this.hand = hand;
            this.currentOperation = currentOperation;
        }

        @Override
        public boolean play(Card card) {
            if (card == null || !hand.contains(card)) {
                System.out.println("You cannot play that card.");
                return false;
            }

            return play(card.getValue());
        }

        @Override
        public boolean drawCard() {
            return hand.addCard();
        }

        @Override
        public void setOperation(OperationType op) {
            currentOperation = op;
        }
    }

    public class Hand {
        private List<Card> cards;

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

        public boolean addCard() {
            Random random = new Random();
            int index = random.nextInt(cards.size());

            if (index < cards.size() / 2) {
                return cards.remove(index);
            } else {
                return cards.remove(cards.size() - 1);
            }
        }

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

    public class Game {
        private final Player playerA;
        private final Player playerB;
        private final Hand deck;
        private boolean isGameOver;

        public Game() {
            this.playerA = new Player(new Hand(), OperationType.ONE_CARD_COMPARISON);
            this.playerB = new Player(new Hand(), OperationType.TWO_CARD_COMPARISON);
            this.deck = new Hand(Arrays.asList(
                    new Card(SPADES, 8),
                    new Card(HOLOCAUST, 9),
                    new Card(KING, 10),
                    new Card(JACK, 11),
                    new Card(QUEEN, 12),
                    new Card(TWO, 13)
            ));
            this.isGameOver = false;
        }

        public boolean isGameOver() {
            return isGameOver;
        }

        public void playRound() {
            // Implement logic to compare players' hands

            // Example: Compare two cards
            if (playerA.drawCard() && playerB.drawCard()) {
                int result = compareCards(playerA.getHand().getCards().get(0), playerB.getHand().getCards().get(0));
                System.out.println(result + " cards are compared.");

                if (result > 0) {
                    System.out.println(playerA.getName() + " wins!");
                    playerA.setOperation(OperationType.ONE_CARD_COMPARISON);
                    playerB.setOperation(OperationType.TWO_CARD_COMPARISON);
                } else if (result < 0) {
                    System.out.println(playerB.getName() + " wins!");
                    playerA.setOperation(OperationType.TWO_CARD_COMPARISON);
                    playerB.setOperation(OperationType.ONE_CARD_COMPARISON);
                } else {
                    System.out.println("It's a tie!");
                    playerA.setOperation(OperationType.TWO_CARD_COMPARISON);
                    playerB.setOperation(OperationType.ONE_CARD_COMPARISON);
                }
            } else {
                System.out.println("No more cards left to compare.");
            }

            if (isGameOver) {
                break;
            }
        }

        public void dealCards(int numCards) {
            for (int i = 0; i < numCards; i++) {
                if (playerA.drawCard()) {
                    playerA.setOperation(OperationType.ONE_CARD_COMPARISON);
                    break;
                } else if (playerB.drawCard()) {
                    playerB.setOperation(OperationType.TWO_CARD_COMPARISON);
                    break;
                }
            }
        }

        private int compareCards(Card cardA, Card cardB) {
            if (cardA.getValue() == cardB.getValue()) {
                if (cardA.getSuit().equals(cardB.getSuit())) {
                    return cardA.getValue() * SMALLER;
                } else {
                    return cardA.getValue() * Bigger;
                }
            } else {
                return cardA.getValue() * Bigger;
            }
        }
    }
}

这段代码提供了一个基础的框架，可以根据实际需求添加更多的功能，例如增加玩家信息、提高游戏难度、优化比较算法等。注意，这里展示的是一个简化版本的扑克牌大小比较游戏，可能不符合实际应用的需求。