基于Java怎么實現經典蜘蛛紙牌游戲

基于Java怎么實現經典蜘蛛紙牌游戲

蜘蛛紙牌（Spider Solitaire）是一款經典的紙牌游戲，以其復雜的規則和策略性深受玩家喜愛。本文將介紹如何使用Java語言實現一個簡單的蜘蛛紙牌游戲，涵蓋游戲規則、設計思路、核心代碼實現等內容。

1. 游戲規則簡介

蜘蛛紙牌使用兩副標準的撲克牌（共104張牌），游戲目標是將所有牌按照從K到A的順序排列成8組完整的序列。游戲的主要規則如下：

1. 牌堆：游戲開始時，牌被分成10列，前4列每列有6張牌，后6列每列有5張牌。所有牌都是正面朝下，只有每列最下面的一張牌是正面朝上。
2. 移動規則：玩家可以將一張或多張連續的牌從一個列移動到另一個列，前提是目標列的頂部牌比移動的牌大1，并且花色相同。例如，可以將黑桃7移動到黑桃8上。
3. 空列：如果某一列的所有牌都被移走，可以將任意單張牌或一組連續的牌移動到空列。
4. 發牌：當沒有合法移動時，玩家可以點擊發牌按鈕，系統會從剩余的牌堆中發10張牌到每一列的頂部。
5. 完成序列：當某一列中的牌從K到A按順序排列時，這些牌將被移出游戲界面，視為完成一組序列。

2. 設計思路

為了實現蜘蛛紙牌游戲，我們需要考慮以下幾個核心模塊：

1. 牌堆管理：包括牌的初始化、洗牌、發牌等操作。
2. 游戲界面：使用Java的圖形用戶界面（GUI）庫（如Swing或JavaFX）來顯示牌堆、列、發牌按鈕等。
3. 游戲邏輯：處理牌的移動、合法性檢查、序列完成判斷等。
4. 用戶交互：處理用戶的點擊、拖拽等操作，并更新游戲狀態。

3. 核心代碼實現

3.1 牌的表示

首先，我們需要定義一個Card類來表示一張牌。每張牌有花色（Suit）和點數（Rank）兩個屬性。

public class Card {
    public enum Suit { SPADES, HEARTS, DIAMONDS, CLUBS }
    public enum Rank { ACE, TWO, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE, TEN, JACK, QUEEN, KING }

    private final Suit suit;
    private final Rank rank;
    private boolean faceUp;

    public Card(Suit suit, Rank rank) {
        this.suit = suit;
        this.rank = rank;
        this.faceUp = false;
    }

    public Suit getSuit() { return suit; }
    public Rank getRank() { return rank; }
    public boolean isFaceUp() { return faceUp; }
    public void flip() { faceUp = !faceUp; }

    @Override
    public String toString() {
        return rank + " of " + suit;
    }
}

3.2 牌堆的初始化與洗牌

接下來，我們定義一個Deck類來管理牌堆。牌堆需要支持洗牌和發牌操作。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Deck {
    private List<Card> cards;

    public Deck() {
        cards = new ArrayList<>();
        for (Card.Suit suit : Card.Suit.values()) {
            for (Card.Rank rank : Card.Rank.values()) {
                cards.add(new Card(suit, rank));
                cards.add(new Card(suit, rank)); // 兩副牌
            }
        }
        shuffle();
    }

    public void shuffle() {
        Collections.shuffle(cards);
    }

    public List<Card> deal(int numCards) {
        List<Card> dealtCards = new ArrayList<>();
        for (int i = 0; i < numCards; i++) {
            if (!cards.isEmpty()) {
                dealtCards.add(cards.remove(0));
            }
        }
        return dealtCards;
    }

    public boolean isEmpty() {
        return cards.isEmpty();
    }
}

3.3 游戲邏輯的實現

游戲的核心邏輯包括牌的移動、合法性檢查、序列完成判斷等。我們可以定義一個Game類來管理這些邏輯。

import java.util.List;
import java.util.Stack;

public class Game {
    private Deck deck;
    private List<Stack<Card>> columns;
    private List<Stack<Card>> completedSequences;

    public Game() {
        deck = new Deck();
        columns = new ArrayList<>();
        completedSequences = new ArrayList<>();
        initializeColumns();
    }

    private void initializeColumns() {
        for (int i = 0; i < 10; i++) {
            Stack<Card> column = new Stack<>();
            int numCards = i < 4 ? 6 : 5;
            List<Card> dealtCards = deck.deal(numCards);
            for (Card card : dealtCards) {
                column.push(card);
            }
            column.peek().flip(); // 最下面一張牌正面朝上
            columns.add(column);
        }
    }

    public boolean moveCards(int fromColumn, int toColumn, int numCards) {
        Stack<Card> fromStack = columns.get(fromColumn);
        Stack<Card> toStack = columns.get(toColumn);

        if (fromStack.size() < numCards) return false;

        List<Card> cardsToMove = new ArrayList<>();
        for (int i = 0; i < numCards; i++) {
            cardsToMove.add(fromStack.pop());
        }

        if (isValidMove(cardsToMove.get(0), toStack.peek())) {
            for (Card card : cardsToMove) {
                toStack.push(card);
            }
            return true;
        } else {
            for (Card card : cardsToMove) {
                fromStack.push(card);
            }
            return false;
        }
    }

    private boolean isValidMove(Card card, Card targetCard) {
        return card.getRank().ordinal() == targetCard.getRank().ordinal() - 1 &&
               card.getSuit() == targetCard.getSuit();
    }

    public void dealNewCards() {
        if (!deck.isEmpty()) {
            for (Stack<Card> column : columns) {
                Card newCard = deck.deal(1).get(0);
                newCard.flip();
                column.push(newCard);
            }
        }
    }

    public void checkForCompletedSequences() {
        for (Stack<Card> column : columns) {
            if (column.size() >= 13) {
                List<Card> sequence = new ArrayList<>();
                for (int i = 0; i < 13; i++) {
                    sequence.add(column.pop());
                }
                if (isCompleteSequence(sequence)) {
                    completedSequences.add(new Stack<>());
                    completedSequences.get(completedSequences.size() - 1).addAll(sequence);
                } else {
                    for (Card card : sequence) {
                        column.push(card);
                    }
                }
            }
        }
    }

    private boolean isCompleteSequence(List<Card> sequence) {
        for (int i = 0; i < sequence.size() - 1; i++) {
            if (sequence.get(i).getRank().ordinal() != sequence.get(i + 1).getRank().ordinal() + 1 ||
                sequence.get(i).getSuit() != sequence.get(i + 1).getSuit()) {
                return false;
            }
        }
        return true;
    }
}

3.4 圖形用戶界面

最后，我們可以使用Java的Swing庫來創建游戲界面。以下是一個簡單的界面實現：

import javax.swing.*;
import java.awt.*;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

public class SpiderSolitaireGUI extends JFrame {
    private Game game;
    private JPanel gamePanel;

    public SpiderSolitaireGUI() {
        game = new Game();
        initializeUI();
    }

    private void initializeUI() {
        setTitle("Spider Solitaire");
        setSize(800, 600);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLocationRelativeTo(null);

        gamePanel = new JPanel(new GridLayout(1, 10));
        updateGamePanel();

        JButton dealButton = new JButton("Deal New Cards");
        dealButton.addActionListener(e -> {
            game.dealNewCards();
            updateGamePanel();
        });

        add(gamePanel, BorderLayout.CENTER);
        add(dealButton, BorderLayout.SOUTH);
    }

    private void updateGamePanel() {
        gamePanel.removeAll();
        for (Stack<Card> column : game.getColumns()) {
            JPanel columnPanel = new JPanel(new GridLayout(column.size(), 1));
            for (Card card : column) {
                JLabel cardLabel = new JLabel(card.toString(), SwingConstants.CENTER);
                cardLabel.setOpaque(true);
                cardLabel.setBackground(Color.WHITE);
                cardLabel.setBorder(BorderFactory.createLineBorder(Color.BLACK));
                columnPanel.add(cardLabel);
            }
            gamePanel.add(columnPanel);
        }
        gamePanel.revalidate();
        gamePanel.repaint();
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> {
            SpiderSolitaireGUI frame = new SpiderSolitaireGUI();
            frame.setVisible(true);
        });
    }
}

4. 總結

本文介紹了如何使用Java實現一個簡單的蜘蛛紙牌游戲。通過定義Card、Deck、Game等類，我們實現了牌堆管理、游戲邏輯和用戶界面。雖然這個實現還比較簡單，但它為后續的功能擴展（如拖拽操作、動畫效果等）提供了基礎。希望本文能為有興趣開發紙牌游戲的讀者提供一些參考。