Card game

reniaL

Card：一张牌
/**
* Object presenting one card
* @author reniaL
*/
public class Card {
    private int face;
    private int suit;
    private static final String faces[] = { "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A" };
    private static final String suits[] = { "Diamonds", "Clubs", "Hearts", "Spades" };
    public Card(int cardFace, int cardSuit) {
        face = cardFace;
        suit = cardSuit;
    }
    public int getFace() {
        return face;
    }
    public int getSuit() {
        return suit;
    }
    /**
     * Get the "value" of this card
     */
    public int getValue() {
        return face * 4 + suit;
    }
    public String toString() {
        return faces[face] + " of " + suits[suit];
    }
}

DeckOfCards:一副牌
/**
* presenting a deck of cards(52)
* @author reniaL
*/
public class DeckOfCards {
    private Card deck[];
    private int currentCard;
    private static final int NUM = 52;
    private Random rand;
    public DeckOfCards() {
        deck = new Card[NUM];
        currentCard = 0;
        rand = new Random();
        for (int i = 0; i  deck.length; i++) {
            deck = new Card(i / 4, i % 4);
        }
    }
    public void Shuffle() {
        currentCard = 0;
        for (int first = 0; first  deck.length; first++) {
            int second = rand.nextInt(NUM);
            Card temp = deck[first];
            deck[first] = deck[second];
            deck[second] = temp;
        }
    }
    public Card DealCard() {
        if (currentCard  deck.length) {
            return deck[currentCard++];
        } else
            return null;
    }
}

TypeOfHand:一手牌的类型
/**
* enumeration of type of a hand of cards
* @author reniaL
*/
public enum TypeOfHand {
    //     declare constants of enum type
    NOTHING(0, "Nothing"),
    PAIR(1, "A Pair"),
    THREE(2, "Three Of A Kind"),
    DOUBLE_PAIR(3, "Two Pairs"),
    HOUSE(4, "House"),
    FOUR(5, "Four Of A Kind"),
    FLUSH(6, "Flush"),
    STRAIGHT(7, "Straight");
    private final int type;
    private final String typeName;
    TypeOfHand(int theType, String theTypeName) {
        type = theType;
        typeName = theTypeName;
    }
    public int getType() {
        return type;
    }
    public String getTypeName() {
        return typeName;
    }
}

HandOfCards:一手牌
/**
* A. a pair
* B. two pairs
* C. three of a kind
* D. a full house
* E. four of a kind
* F. a flush
* G. a straight
*/
public class HandOfCards {
    private static final int NUM = 5; // number of cards
    private Card myCards[];
    private TypeOfHand type; // type of this hand
    private int value; // value of this hand
    private ArrayListInteger> unneeded; // array of index of the unneeded cards
    /**
     * Deal from deckOfCards 5 times to make a hand of cards, and sort
     */
    public HandOfCards(DeckOfCards deckOfCards) {
        myCards = new Card[NUM];
        unneeded = new ArrayListInteger>();
        for (int i = 0; i  NUM; i++) {
            myCards = deckOfCards.DealCard();
        }
        // sort and analyze the cards on hand
        sortCards();
        analyze();
    }
    /**
     * Analyze the cards on hand to determine the type and value
     */
    private void analyze() {
        unneeded.clear();
        if (checkPair()) { // type is PAIR, continue to check if it's double pair, three, four, or house
            if (checkThree()) {
                if (!checkFour()) {
                    checkHouse();
                }
            } else {
                checkDoublePair();
            }
        } else if (!checkStraight()) {
            if (!checkFlush()) { // NOTHING
                type = TypeOfHand.NOTHING;
                value = myCards[4].getValue();
                for (int i = 0; i  5; i++) {
                    unneeded.add(i);
                }
            }
        }
    }
    private boolean checkPair() {
        for (int i = 1; i  NUM; i++) {
            if (myCards.getFace() == myCards[i - 1].getFace()) {
                type = TypeOfHand.PAIR;
                value = type.getType() * 52 + myCards.getValue();
                for (int j = 0; j  NUM; j++) {
                    if ((j != i) && (j != i - 1)) {
                        unneeded.add(j);
                    }
                }
                return true;
            }
        }
        return false;
    }
    private boolean checkDoublePair() {
        int i = 1;
        while ((i  NUM) && (myCards.getFace() != myCards[i - 1].getFace())) {
            i++;
        }
        for (int j = i + 2; j  NUM; j++) {
            if (myCards[j].getFace() == myCards[j - 1].getFace()) {
                unneeded.clear();
                type = TypeOfHand.DOUBLE_PAIR;
                value = type.getType() * 52 + myCards[j].getValue();
                if (j == 3) { // AABBX
                    unneeded.add(4);
                } else {
                    if (i == 1) { // AAXBB
                        unneeded.add(2);
                    } else { // XAABB
                        unneeded.add(0);
                    }
                }
                return true;
            }
        }
        return false;
    }
    private boolean checkThree() {
        for (int i = 2; i  NUM; i++) {
            if ((myCards.getFace() == myCards[i - 1].getFace())
                    && (myCards.getFace() == myCards[i - 2].getFace())) {
                unneeded.clear();
                type = TypeOfHand.THREE;
                value = type.getType() * 52 + myCards.getValue();
                for (int j = 0; j  NUM; j++) {
                    if ((j != i) && (j != i - 1) && (j != i - 2)) {
                        unneeded.add(j);
                    }
                }
                return true;
            }
        }
        return false;
    }
    private boolean checkHouse() {
        if ((myCards[0].getFace() == myCards[1].getFace())
                && (myCards[3].getFace() == myCards[4].getFace())
                && ((myCards[2].getFace() == myCards[0].getFace()) || (myCards[2]
                        .getFace() == myCards[4].getFace()))) {
            type = TypeOfHand.HOUSE;
            if (myCards[2].getFace() == myCards[0].getFace()) {
                value = type.getType() * 52 + myCards[2].getValue();
            } else {
                value = type.getType() * 52 + myCards[4].getValue();
            }
            unneeded.clear();
            return true;
        }
        return false;
    }
    private boolean checkFour() {
        for (int i = 3; i  NUM; i++) {
            if ((myCards.getFace() == myCards[i - 1].getFace())
                    && (myCards.getFace() == myCards[i - 2].getFace())
                    && (myCards.getFace() == myCards[i - 3].getFace())) {
                type = TypeOfHand.FOUR;
                value = type.getType() * 52 + myCards.getValue();
                unneeded.clear();
                return true;
            }
        }
        return false;
    }
    private boolean checkFlush() {
        int suit = myCards[0].getSuit();
        for (int i = 1; i  NUM; i++) {
            if (myCards.getSuit() != suit) {
                return false;
            }
        }
        type = TypeOfHand.FLUSH;
        value = type.getType() * 52 + myCards[4].getValue();
        unneeded.clear();
        return true;
    }
    private boolean checkStraight() {
        for (int i = 1; i  NUM; i++) {
            if ((myCards.getFace() - myCards[i - 1].getFace() != 1)) {
                return false;
            }
        }
        type = TypeOfHand.STRAIGHT;
        value = type.getType() * 52 + myCards[4].getValue();
        unneeded.clear();
        return true;
    }
    /**
     * Sort cards on hand, insertion sort
     */
    private void sortCards() {
        Card tempCard;
        for (int i = 0; i  NUM; i++) {
            for (int j = i; (j > 0)
                    && (myCards[j].getValue()  myCards[j - 1].getValue()); j--) {
                tempCard = myCards[j];
                myCards[j] = myCards[j - 1];
                myCards[j - 1] = tempCard;
            }
        }
    }
    public void reDeal(DeckOfCards deckOfCards) {
        for (int i : unneeded) {
            myCards = deckOfCards.DealCard();
        }
        // sort and analyze the cards on hand
        sortCards();
        analyze();
    }
    public void display() {
        for (int i = 0; i  NUM; i++) {
            System.out.print(myCards + "\t");
        }
        System.out.println("\nType: " + type.getTypeName());
        System.out.println("Value: " + value);
        if (unneeded.size() == 0) {
            System.out.println("Unneeded: empty");
        } else {
            System.out.println("Unneeded: " + unneeded);
        }
    }
    public TypeOfHand getType() {
        return type;
    }
    public int getValue() {
        return value;
    }
    public ArrayListInteger> getUnneeded() {
        return unneeded;
    }
    public Card[] getMyCards() {
        return myCards;
    }
    public void setMyCards(Card[] myCards) {
        this.myCards = myCards;
        sortCards();
        analyze();
    }
}

GameTest:测试
public class GameTest {
    public static void main(String[] args) {
        DeckOfCards deckOfCards = new DeckOfCards();
        deckOfCards.Shuffle();
        HandOfCards hand = new HandOfCards(deckOfCards);
        System.out.println("Before redeal:");
        hand.display();
        hand.reDeal(deckOfCards);
        System.out.println("\nAfter redeal:");
        hand.display();
    }
}


本文来自ChinaUnix博客，如果查看原文请点：http://blog.chinaunix.net/u1/39889/showart_509797.html