如何向玩家分发一副纸牌？

时间：2019-06-18 21:43:27

标签： java

我一直在尝试使用Java创建基本的纸牌游戏（实验）。在洗牌后，我需要根据参加游戏的玩家数量，将6张洗过的卡传递给每个玩家。 （最多6位玩家）

通过使用“ Player”类中的setHand（）方法，我可以分配6张牌，但是在开始游戏后，通过循环播放玩家的主要方法，如果有2位玩家，我只会看到2张牌。 

    public static void main (String[] args) {
        //Create players between 2-6
        Game newGame = new Game();
        List<Player> players = newGame.createPlayers();

        //Let user decide the number of cards set either 24 or 36 or 52 and create deck
        if(players != null){
            newGame.createDeck(players);

            for (Player player: players){
                    player.showHand();
            }
        }

    }

public class Game {
    private Dealer dealer;
    private List<Player> players = new ArrayList<>();
    private int numberOfPlayers;

    public List<Player> createPlayers(){
        Scanner scanner = new Scanner(System.in);
        System.out.println("Number of players(up to 6)");
        numberOfPlayers = scanner.nextInt();
        if(numberOfPlayers <= 6) {
            int count = 0;
            while (count < numberOfPlayers) {
                System.out.println("Please enter the names");
                String playerName = scanner.next();
                players.add(new Player(playerName));
                count++;
            }
            return players;
        }else{
            System.out.println("More than 6 players are not allowed");
            return null;
        }

    }

    public void createDeck(List<Player> players){
        System.out.println("Number of Cards (24/36/52)");
        Scanner scanner = new Scanner(System.in);
        int numberOfCards = scanner.nextInt();

        Dealer newDeck = new Dealer(numberOfCards, numberOfPlayers);
        newDeck.shuffleDeck();
        newDeck.dealShuffledCardsToPlayers(players);
    }
}

public class Dealer {
    private Deck deck;
    private List<Player> players;
    private final int NUMBER_OF_CARDS;

    public Dealer(int numberOfCards, int numberOfPlayers) {
        this.deck = new Deck(numberOfCards);
        this.players = new ArrayList<>(numberOfPlayers);
        this.NUMBER_OF_CARDS = numberOfCards;
    }

    public void shuffleDeck(){
        Collections.shuffle(deck.getDeck());
    }

    public void dealShuffledCardsToPlayers(List<Player> players){
        for(Player player: players){
            for(int i= 0; i<6; i++) {
                player.setHand(deck.deal(6));
            }
        }
    }
}

public class Player {
    private String name;
    private int points;
    private List<Card> hand;

    public Player(String name) {
        this.name = name;
        this.points = 0;
        this.hand = new ArrayList<>();
    }

    public List<Card> getHand(){
        return hand;
    }

    public void setHand(List<Card> hand) {
        this.hand = hand;
//        System.out.println(hand);
    }


    public void showHand(){
        for(int i=0; i<this.hand.size(); i++){
            System.out.println(this.hand.get(i));
        }
    }

}

public class Deck{
    private List<Card> deck;
//    private static final Random GENERATOR = new Random();
    public Deck (int numberOfCards) {
        deck = new ArrayList<>(numberOfCards);

        int count = 0;

        for (final Card.Suit suit : Card.Suit.values()) {
            for (final Card.Rank rank : Card.Rank.values()) {
                deck.add(new Card(rank, suit));
                count++;
            }
        }
    }

    public List<Card> getDeck(){
        return deck;
    }

    public List<Card> deal(int size){
        List<Card> hand = new ArrayList<>(size);
        hand.add(deck.remove(size));
        return hand;
    }
}

预期结果是向玩家分发6张洗牌。另外，请分享您对需要改进和我做错了什么的想法。

1 个答案:

答案 0 :(得分：2)

如评论中所述，通常最好将您的问题合并为一个说明问题的较短代码示例。另外，调试器是您的朋友，设置断点并逐步确定变量值是否与应用程序不同点上的期望值匹配。

您没有看到所需结果的原因是因为dealShuffledCardsToPlayers(...)和deck.deal(...)方法中的逻辑。

让我们从deck.deal（int size）方法的内部开始。

public List<Card> deal(int size){
        List<Card> hand = new ArrayList<>(size);
        hand.add(deck.remove(size));
        return hand;
    }

在此方法中，每次调用时，您都会创建一个传入的大小的新手ArrayList，但随后只向其中添加了一个对象（卡片组索引为size的卡片）。如果您查看List.remove的标题，您会注意到它仅返回从列表中删除的元素（在您的情况下为1卡）。

  

删除此列表中指定位置的元素（可选        操作）。将所有后续元素向左移动（减去一个        从他们的索引）。返回从中删除的元素        列表。

然后在dealer.dealShuffledCardsToPlayers(List<Player> players)中，在此循环中将每个玩家的手牌设置六次

for(Player player: players){
            for(int i= 0; i<6; i++) {
                player.setHand(deck.deal(6));
            }
        }

但是每次设置它时，它只是在deck.deal（...）方法中从卡组中取出的一张（最后一张）卡，这就是为什么每个玩家最终只能获得一张卡的原因。

我认为您的意思是让deck.deal(...)方法随机分配6张牌并返回所发的手牌，如下所示：

    public List<Card> deal(int size){
        List<Card> hand = new ArrayList<>(size);
        Random rand = new Random();
        for (int dealtCount = 0; dealtCount < size; dealtCount++) {
            hand.add(deck.remove(rand.nextInt(deck.size())));
        }
        return hand;
    }

或者您可能会忽略随机性，只取前六张牌，因为您已经洗牌了（这相当于在洗牌后将牌堆顶掉）。

然后进行适当的调整，您就可以删除dealer.dealShuffledCardsToPlayers(List<Player> players)中的外部循环，从而变得：

        for(Player player: players){
            player.setHand(deck.deal(6));
        }

在添加了卡打印输出上方打印的玩家名称（为了便于调试日志中清楚显示）之后，您将在设置3个随机玩家时最终获得以下奖励：

Number of players(up to 6)
3
Please enter the names
George
Please enter the names
Maria
Please enter the names
Joe
Number of Cards (24/36/52)
52
Player: George
FOUR of DIAMONDS
TEN of DIAMONDS
THREE of CLUBS
TWO of CLUBS
NINE of SPADES
EIGHT of SPADES

Player: Maria
TWO of DIAMONDS
KING of CLUBS
FOUR of SPADES
FIVE of HEARTS
JACK of SPADES
SEVEN of DIAMONDS

Player: Joe
NINE of HEARTS
JACK of HEARTS
FIVE of DIAMONDS
ACE of CLUBS
ACE of SPADES
JACK of CLUBS

另一件事是，您最有可能想防止玩家/纸牌数的错误组合-即，如果您的纸牌数仅为24，那么您将无法拥有一个6人游戏来向每位玩家分发6张纸牌。< / p>

编辑-插入了我的示例的修改后的类：

Dealer.java 

public class Dealer {
    private Deck deck;
    private List<Player> players;
    private final int NUMBER_OF_CARDS;

    public Dealer(int numberOfCards, int numberOfPlayers) {
        this.deck = new Deck(numberOfCards);
        this.players = new ArrayList<>(numberOfPlayers);
        this.NUMBER_OF_CARDS = numberOfCards;
    }

    public void shuffleDeck(){
        Collections.shuffle(deck.getDeck());
    }

    public void dealShuffledCardsToPlayers(List<Player> players){
//        List<Card> tempCard = deck.getDeck();
//        for(int i=0; i < players.size(); i++){
//            for(int j=0; j < 6; j++){
//                players.add(tempCard.remove(i+j*6));
//            }
//        }
        for(Player player: players){
            player.setHand(deck.deal(6));
        }
    }
}

Deck.java 

public class Deck{
    private List<Card> deck;
    //    private static final Random GENERATOR = new Random();
    public Deck (int numberOfCards) {
        deck = new ArrayList<>(numberOfCards);

        int count = 0;

        for (final Card.Suit suit : Card.Suit.values()) {
            for (final Card.Rank rank : Card.Rank.values()) {
                deck.add(new Card(rank, suit));
                count++;
            }
        }
    }

    public List<Card> getDeck(){
        return deck;
    }

    public List<Card> deal(int size){
        List<Card> hand = new ArrayList<>(size);
        Random rand = new Random();
        for (int dealtCount = 0; dealtCount < size; dealtCount++) {
            hand.add(deck.remove(rand.nextInt(deck.size())));
        }
        return hand;
    }

    @Override
    public String toString(){
        StringBuilder builder = new StringBuilder();
        for(int i = 0; i < deck.size(); i++){
            builder.append(i + " ");
            builder.append(deck.get(i));
            builder.append(System.getProperty("line.separator"));
        }
        return builder.toString();
    }
}
相关问题
最新问题