From 7ff5e12124aebe9255c7962ce6eb0ef49ceea9c1 Mon Sep 17 00:00:00 2001 From: Michael Hunteman Date: Tue, 22 Nov 2022 14:07:43 -0600 Subject: Initial commit --- .vscode/launch.json | 21 ++ Game.class | Bin 0 -> 5582 bytes Game.java | 364 ++++++++++++++++++++++++++++++++ GameTest.java | 527 ++++++++++++++++++++++++++++++++++++++++++++++ card/Card$1.class | Bin 0 -> 661 bytes card/Card.class | Bin 0 -> 1351 bytes card/Card.java | 60 ++++++ card/Suit.class | Bin 0 -> 883 bytes card/Suit.java | 8 + lib/hamcrest-core-1.3.jar | Bin 0 -> 45024 bytes lib/junit-4.13.2.jar | Bin 0 -> 384581 bytes 11 files changed, 980 insertions(+) create mode 100644 .vscode/launch.json create mode 100644 Game.class create mode 100644 Game.java create mode 100644 GameTest.java create mode 100644 card/Card$1.class create mode 100644 card/Card.class create mode 100644 card/Card.java create mode 100644 card/Suit.class create mode 100644 card/Suit.java create mode 100644 lib/hamcrest-core-1.3.jar create mode 100644 lib/junit-4.13.2.jar diff --git a/.vscode/launch.json b/.vscode/launch.json new file mode 100644 index 0000000..f571609 --- /dev/null +++ b/.vscode/launch.json @@ -0,0 +1,21 @@ +{ + // Use IntelliSense to learn about possible attributes. + // Hover to view descriptions of existing attributes. + // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387 + "version": "0.2.0", + "configurations": [ + { + "type": "java", + "name": "Launch Current File", + "request": "launch", + "mainClass": "${file}" + }, + { + "type": "java", + "name": "Launch Game", + "request": "launch", + "mainClass": "Game", + "projectName": "holdem_ed7e9667" + } + ] +} \ No newline at end of file diff --git a/Game.class b/Game.class new file mode 100644 index 0000000..95ceca7 Binary files /dev/null and b/Game.class differ diff --git a/Game.java b/Game.java new file mode 100644 index 0000000..8959282 --- /dev/null +++ b/Game.java @@ -0,0 +1,364 @@ +import java.util.*; +import card.*; + +class Game { + private List deck = new ArrayList<>(); + private List> hands = new ArrayList<>(); + private List ranks = new ArrayList<>(); + + public Game() { + setDeck(); + } + + public Game(int handsNum) { + setDeck(); + for (int i = 0; i < handsNum; i++) { + hands.add(setHand()); + ranks.add(getRank(hands.get(i))); + } + } + + public void setHands(List> hands) { + this.hands = hands; + } + + public void setRanks(List ranks) { + this.ranks = ranks; + } + + public void setDeck() { + Suit s = Suit.CLUBS; + for (int i = 0; i < 4; i++) { + switch (i) { + case 0: + s = Suit.CLUBS; + break; + case 1: + s = Suit.DIAMONDS; + break; + case 2: + s = Suit.HEARTS; + break; + case 3: + s = Suit.SPADES; + break; + } + for (int j = 1; j <= 13; j++) { + Card card = new Card(j, s); + deck.add(card); + } + } + } + + public List sort(List hand) { + if (hand.size() <= 1) + return hand; + int mid = hand.size() / 2; + List left = sort(hand.subList(0, mid)); + List right = sort(hand.subList(mid, hand.size())); + return merge(left, right); + } + + public List merge(List left, List right) { + List result = new ArrayList<>(); + int l = 0, r = 0; + while (l < left.size() || r < right.size()) { + if (l < left.size() && (r == right.size() + || left.get(l).getValue() < right.get(r).getValue() )) { + result.add(left.get(l)); + l++; + } else { + result.add(right.get(r)); + r++; + } + } + return result; + } + + public List setHand() { + List hand = new ArrayList<>(); + Random rand = new Random(); + for (int i = 0; i < 5; i++) { + int randInt = rand.nextInt(deck.size()); + hand.add(deck.get(randInt)); + deck.remove(randInt); + } + return sort(hand); + } + + public void getHand(List hand) { + for (Card c : hand) { + System.out.println(c.displayCard()); + } + } + + public int getRank(List hand) { + if (isRoyalFlush(hand)) { + return 9; + } else if (isStraightFlush(hand)) { + return 8; + } else if (isFourOfKind(hand)) { + return 7; + } else if (isFullHouse(hand)) { + return 6; + } else if (isFlush(hand)) { + return 5; + } else if (isStraight(hand)) { + return 4; + } else if (isThreeOfKind(hand)) { + return 3; + } else if (isTwoPair(hand)) { + return 2; + } else if (isPair(hand)) { + return 1; + } else { + return 0; + } + } + + public void displayRank(List hand, int rank) { + switch (rank) { + case 8: + System.out.println("Straight flush"); + break; + case 7: + System.out.println("Four of a kind"); + break; + case 6: + System.out.println("Full house"); + break; + case 5: + System.out.println("Flush"); + break; + case 4: + System.out.println("Straight"); + break; + case 3: + System.out.println("Three of a kind"); + break; + case 2: + System.out.println("Two pair"); + break; + case 1: + System.out.println("Pair"); + break; + default: + System.out.println("High card " + highCard(hand)); + } + } + + public String highCard(List hand) { + if (hand.get(0).getValue() == 1) + return hand.get(0).displayCard(); + return hand.get(hand.size() - 1).displayCard(); + } + + public boolean isPair(List hand) { + boolean pair = false; + for (int i = 0; i < hand.size() - 1; i++) + pair = pair || (hand.get(i).getValue() == hand.get(i + 1).getValue()); + return pair; + } + + public boolean isTwoPair(List hand) { + int numberOfPairs = 0; + int i = 0; + while (i < hand.size() - 1) { + if (isPair(hand.subList(i, i + 2))) { + numberOfPairs++; + i += 2; + } else { + i++; + } + } + return numberOfPairs == 2; + } + + public boolean isThreeOfKind(List hand) { + boolean threeOfKind = false; + for (int i = 0; i < hand.size() - 2; i++) + threeOfKind = threeOfKind + || (hand.get(i).getValue() == hand.get(i + 2).getValue()); + return threeOfKind; + } + + // TODO: ace high straight + public boolean isStraight(List hand) { + int prev = hand.get(0).getValue(); + int count = 0; + for (int i = 1; i < hand.size() && count < 4; i++) { + if (hand.get(i).getValue() - prev == 1) { + count++; + } else { + count = 0; + } + prev = hand.get(i).getValue(); + } + return count == 4; + } + + public boolean isFlush(List hand) { + boolean flush = true; + Suit suit = hand.get(0).getSuit(); + for (int i = 1; i < hand.size(); i++) + flush = flush && (hand.get(i).getSuit() == suit); + return flush; + } + + public boolean isFullHouse(List hand) { + boolean pairThreeOfKind = false; + boolean threeOfKindPair = false; + + for (int i = 0; i < hand.size() - 4; i++) + pairThreeOfKind = (hand.get(i).getValue() == hand.get(i + 1).getValue()) + && (hand.get(i + 2).getValue() == hand.get(i + 4).getValue()); + + for (int i = 0; i < hand.size() - 4; i++) + threeOfKindPair = (hand.get(i).getValue() == hand.get(i + 2).getValue()) + && (hand.get(i + 3).getValue() == hand.get(i + 4).getValue()); + + return pairThreeOfKind || threeOfKindPair; + } + + public boolean isFourOfKind(List hand) { + boolean fourOfKind = false; + for (int i = 0; i < hand.size() - 3; i++) + fourOfKind = fourOfKind + || (hand.get(i).getValue() == hand.get(i + 3).getValue()); + return fourOfKind; + } + + public boolean isStraightFlush(List hand) { + return isStraight(hand) && isFlush(hand); + } + + // TODO: check A-10 + public boolean isRoyalFlush(List hand) { + return isFlush(hand) && hand.get(0).getValue() == 1 + && hand.get(1).getValue() == 10 && hand.get(4).getValue() == 13; + } + + public boolean compareHighCard(List firstHand, List secondHand) { + if (firstHand.get(0).getValue() == 1) { + return true; + } else if (secondHand.get(0).getValue() == 1) { + return false; + } + for (int j = firstHand.size() - 1; j > 0; j--) { + if (firstHand.get(j).getValue() + > secondHand.get(j).getValue()) { + return true; + } else if (secondHand.get(j).getValue() + > firstHand.get(j).getValue()) { + return false; + } + } + return false; + } + + public boolean comparePair(List firstHand, List secondHand) { + Set temp = new HashSet<>(); + int high = firstHand.get(0).getValue(); + for (int i = 1; i < firstHand.size(); i++) { + Card c = firstHand.get(i); + if (temp.contains(c.getValue())) { + high = c.getValue(); + } else { + temp.add(c.getValue()); + } + } + temp.clear(); + for (Card c : secondHand) { + if (temp.contains(c.getValue())) { + if (high > c.getValue()) + return true; + } else { + temp.add(c.getValue()); + } + } + return false; + } + + // TODO: combine with comparePair and compareThreeOfKind + public boolean compareTwoPair(List firstHand, List secondHand) { + Set temp = new HashSet<>(); + int high = firstHand.get(0).getValue(); + for (int i = 1; i < firstHand.size(); i++) { + Card c = firstHand.get(i); + if (temp.contains(c.getValue()) && c.getValue() > high) { + high = c.getValue(); + } else { + temp.add(c.getValue()); + } + } + temp.clear(); + int greater = 0; + for (Card c : secondHand) { + if (temp.contains(c.getValue()) && high > c.getValue()) { + greater++; + } else { + temp.add(c.getValue()); + } + } + return greater >= 2; + } + + public int getWinner() { + int bestHand = 0, bestRank = 0; + for (int i = 0; i < ranks.size(); i++) { + if (ranks.get(i) > bestRank) { + bestHand = i; + bestRank = ranks.get(i); + } else if (ranks.get(i) == bestRank) { + switch (bestRank) { + case 7: + if (compareTwoPair(hands.get(i), hands.get(bestHand))) { + bestHand = i; + bestRank = ranks.get(i); + } + break; + case 6: + if (compareTwoPair(hands.get(i), hands.get(bestHand))) { + bestHand = i; + bestRank = ranks.get(i); + } + break; + case 3: + if (compareTwoPair(hands.get(i), hands.get(bestHand))) { + bestHand = i; + bestRank = ranks.get(i); + } + break; + case 2: + if (compareTwoPair(hands.get(i), hands.get(bestHand))) { + bestHand = i; + bestRank = ranks.get(i); + } + break; + case 1: + if (comparePair(hands.get(i), hands.get(bestHand))) { + bestHand = i; + bestRank = ranks.get(i); + } + break; + case 0: + if (compareHighCard(hands.get(i), hands.get(bestHand))) { + bestHand = i; + bestRank = ranks.get(i); + } + } + } + } + return bestHand; + } + + public static void main(String args[]) { + Game g = new Game(10); + for (int i = 0; i < g.hands.size(); i++) { + g.getHand(g.hands.get(i)); + g.displayRank(g.hands.get(i), g.ranks.get(i)); + System.out.println(); + } + System.out.println(g.getWinner()); + } +} diff --git a/GameTest.java b/GameTest.java new file mode 100644 index 0000000..4f67793 --- /dev/null +++ b/GameTest.java @@ -0,0 +1,527 @@ +import java.util.*; +import static org.junit.Assert.assertEquals; +import org.junit.Test; +import card.*; + +public class GameTest { + @Test + public void testPair() { + Game g = new Game(); + List firstHand = new ArrayList<>(); + List> hands = new ArrayList<>(); + List ranks = new ArrayList<>(); + firstHand.add(new Card(1, Suit.CLUBS)); + firstHand.add(new Card(1, Suit.HEARTS)); + firstHand.add(new Card(2, Suit.DIAMONDS)); + firstHand.add(new Card(3, Suit.SPADES)); + firstHand.add(new Card(4, Suit.HEARTS)); + hands.add(firstHand); + ranks.add(g.getRank(firstHand)); + assertEquals(Arrays.asList(1), ranks); + } + + @Test + public void testTwoPair() { + Game g = new Game(); + List firstHand = new ArrayList<>(); + List> hands = new ArrayList<>(); + List ranks = new ArrayList<>(); + firstHand.add(new Card(1, Suit.CLUBS)); + firstHand.add(new Card(1, Suit.HEARTS)); + firstHand.add(new Card(2, Suit.DIAMONDS)); + firstHand.add(new Card(2, Suit.SPADES)); + firstHand.add(new Card(4, Suit.HEARTS)); + hands.add(firstHand); + ranks.add(g.getRank(firstHand)); + assertEquals(Arrays.asList(2), ranks); + } + + @Test + public void testThreeOfKind() { + Game g = new Game(); + List firstHand = new ArrayList<>(); + List> hands = new ArrayList<>(); + List ranks = new ArrayList<>(); + firstHand.add(new Card(1, Suit.CLUBS)); + firstHand.add(new Card(1, Suit.HEARTS)); + firstHand.add(new Card(1, Suit.DIAMONDS)); + firstHand.add(new Card(2, Suit.SPADES)); + firstHand.add(new Card(4, Suit.HEARTS)); + hands.add(firstHand); + ranks.add(g.getRank(firstHand)); + assertEquals(Arrays.asList(3), ranks); + } + + @Test + public void testStraight() { + Game g = new Game(); + List firstHand = new ArrayList<>(); + List> hands = new ArrayList<>(); + List ranks = new ArrayList<>(); + firstHand.add(new Card(1, Suit.CLUBS)); + firstHand.add(new Card(2, Suit.HEARTS)); + firstHand.add(new Card(3, Suit.DIAMONDS)); + firstHand.add(new Card(4, Suit.SPADES)); + firstHand.add(new Card(5, Suit.HEARTS)); + hands.add(firstHand); + ranks.add(g.getRank(firstHand)); + assertEquals(Arrays.asList(4), ranks); + } + + @Test + public void testFlush() { + Game g = new Game(); + List firstHand = new ArrayList<>(); + List> hands = new ArrayList<>(); + List ranks = new ArrayList<>(); + firstHand.add(new Card(1, Suit.HEARTS)); + firstHand.add(new Card(7, Suit.HEARTS)); + firstHand.add(new Card(3, Suit.HEARTS)); + firstHand.add(new Card(9, Suit.HEARTS)); + firstHand.add(new Card(12, Suit.HEARTS)); + hands.add(firstHand); + ranks.add(g.getRank(firstHand)); + assertEquals(Arrays.asList(5), ranks); + } + + @Test + public void testFullHouse() { + Game g = new Game(); + List firstHand = new ArrayList<>(); + List> hands = new ArrayList<>(); + List ranks = new ArrayList<>(); + firstHand.add(new Card(1, Suit.CLUBS)); + firstHand.add(new Card(1, Suit.HEARTS)); + firstHand.add(new Card(1, Suit.DIAMONDS)); + firstHand.add(new Card(2, Suit.SPADES)); + firstHand.add(new Card(2, Suit.HEARTS)); + hands.add(firstHand); + ranks.add(g.getRank(firstHand)); + assertEquals(Arrays.asList(6), ranks); + } + + @Test + public void testFourOfKind() { + Game g = new Game(); + List firstHand = new ArrayList<>(); + List> hands = new ArrayList<>(); + List ranks = new ArrayList<>(); + firstHand.add(new Card(1, Suit.CLUBS)); + firstHand.add(new Card(1, Suit.HEARTS)); + firstHand.add(new Card(1, Suit.DIAMONDS)); + firstHand.add(new Card(1, Suit.SPADES)); + firstHand.add(new Card(2, Suit.HEARTS)); + hands.add(firstHand); + ranks.add(g.getRank(firstHand)); + assertEquals(Arrays.asList(7), ranks); + } + + @Test + public void testStraightFlush() { + Game g = new Game(); + List firstHand = new ArrayList<>(); + List> hands = new ArrayList<>(); + List ranks = new ArrayList<>(); + firstHand.add(new Card(1, Suit.CLUBS)); + firstHand.add(new Card(2, Suit.CLUBS)); + firstHand.add(new Card(3, Suit.CLUBS)); + firstHand.add(new Card(4, Suit.CLUBS)); + firstHand.add(new Card(5, Suit.CLUBS)); + hands.add(firstHand); + ranks.add(g.getRank(firstHand)); + assertEquals(Arrays.asList(8), ranks); + } + + @Test + public void testRoyalFlush() { + Game g = new Game(); + List firstHand = new ArrayList<>(); + List> hands = new ArrayList<>(); + List ranks = new ArrayList<>(); + firstHand.add(new Card(1, Suit.CLUBS)); + firstHand.add(new Card(10, Suit.CLUBS)); + firstHand.add(new Card(11, Suit.CLUBS)); + firstHand.add(new Card(12, Suit.CLUBS)); + firstHand.add(new Card(13, Suit.CLUBS)); + hands.add(firstHand); + ranks.add(g.getRank(firstHand)); + assertEquals(Arrays.asList(9), ranks); + } + + @Test + public void testUnsortedPair() { + Game g = new Game(); + List firstHand = new ArrayList<>(); + List> hands = new ArrayList<>(); + List ranks = new ArrayList<>(); + firstHand.add(new Card(2, Suit.CLUBS)); + firstHand.add(new Card(9, Suit.HEARTS)); + firstHand.add(new Card(2, Suit.DIAMONDS)); + firstHand.add(new Card(13, Suit.SPADES)); + firstHand.add(new Card(6, Suit.CLUBS)); + firstHand = g.sort(firstHand); + hands.add(firstHand); + ranks.add(g.getRank(firstHand)); + assertEquals(Arrays.asList(1), ranks); + } + + @Test + public void testUnsortedTwoPair() { + Game g = new Game(); + List firstHand = new ArrayList<>(); + List> hands = new ArrayList<>(); + List ranks = new ArrayList<>(); + firstHand.add(new Card(2, Suit.CLUBS)); + firstHand.add(new Card(4, Suit.CLUBS)); + firstHand.add(new Card(2, Suit.SPADES)); + firstHand.add(new Card(1, Suit.HEARTS)); + firstHand.add(new Card(4, Suit.DIAMONDS)); + firstHand = g.sort(firstHand); + hands.add(firstHand); + ranks.add(g.getRank(firstHand)); + assertEquals(Arrays.asList(2), ranks); + } + + @Test + public void testUnsortedThreeOfKind() { + Game g = new Game(); + List firstHand = new ArrayList<>(); + List> hands = new ArrayList<>(); + List ranks = new ArrayList<>(); + firstHand.add(new Card(7, Suit.CLUBS)); + firstHand.add(new Card(4, Suit.DIAMONDS)); + firstHand.add(new Card(7, Suit.HEARTS)); + firstHand.add(new Card(1, Suit.CLUBS)); + firstHand.add(new Card(7, Suit.SPADES)); + firstHand = g.sort(firstHand); + hands.add(firstHand); + ranks.add(g.getRank(firstHand)); + assertEquals(Arrays.asList(3), ranks); + } + + @Test + public void testUnsortedStraight() { + Game g = new Game(); + List firstHand = new ArrayList<>(); + List> hands = new ArrayList<>(); + List ranks = new ArrayList<>(); + firstHand.add(new Card(7, Suit.CLUBS)); + firstHand.add(new Card(4, Suit.HEARTS)); + firstHand.add(new Card(6, Suit.SPADES)); + firstHand.add(new Card(8, Suit.DIAMONDS)); + firstHand.add(new Card(5, Suit.CLUBS)); + firstHand = g.sort(firstHand); + hands.add(firstHand); + ranks.add(g.getRank(firstHand)); + assertEquals(Arrays.asList(4), ranks); + } + + @Test + public void testUnsortedFlush() { + Game g = new Game(); + List firstHand = new ArrayList<>(); + List> hands = new ArrayList<>(); + List ranks = new ArrayList<>(); + firstHand.add(new Card(7, Suit.SPADES)); + firstHand.add(new Card(2, Suit.SPADES)); + firstHand.add(new Card(6, Suit.SPADES)); + firstHand.add(new Card(11, Suit.SPADES)); + firstHand.add(new Card(3, Suit.SPADES)); + firstHand = g.sort(firstHand); + hands.add(firstHand); + ranks.add(g.getRank(firstHand)); + assertEquals(Arrays.asList(5), ranks); + } + + @Test + public void testUnsortedFullHouse() { + Game g = new Game(); + List firstHand = new ArrayList<>(); + List> hands = new ArrayList<>(); + List ranks = new ArrayList<>(); + firstHand.add(new Card(4, Suit.CLUBS)); + firstHand.add(new Card(8, Suit.HEARTS)); + firstHand.add(new Card(4, Suit.DIAMONDS)); + firstHand.add(new Card(8, Suit.SPADES)); + firstHand.add(new Card(4, Suit.HEARTS)); + firstHand = g.sort(firstHand); + hands.add(firstHand); + ranks.add(g.getRank(firstHand)); + assertEquals(Arrays.asList(6), ranks); + } + + @Test + public void testUnsortedFourOfKind() { + Game g = new Game(); + List firstHand = new ArrayList<>(); + List> hands = new ArrayList<>(); + List ranks = new ArrayList<>(); + firstHand.add(new Card(1, Suit.CLUBS)); + firstHand.add(new Card(1, Suit.HEARTS)); + firstHand.add(new Card(2, Suit.DIAMONDS)); + firstHand.add(new Card(1, Suit.SPADES)); + firstHand.add(new Card(1, Suit.HEARTS)); + firstHand = g.sort(firstHand); + hands.add(firstHand); + ranks.add(g.getRank(firstHand)); + assertEquals(Arrays.asList(7), ranks); + } + + @Test + public void testUnsortedStraightFlush() { + Game g = new Game(); + List firstHand = new ArrayList<>(); + List> hands = new ArrayList<>(); + List ranks = new ArrayList<>(); + firstHand.add(new Card(2, Suit.CLUBS)); + firstHand.add(new Card(4, Suit.CLUBS)); + firstHand.add(new Card(3, Suit.CLUBS)); + firstHand.add(new Card(1, Suit.CLUBS)); + firstHand.add(new Card(5, Suit.CLUBS)); + firstHand = g.sort(firstHand); + hands.add(firstHand); + ranks.add(g.getRank(firstHand)); + assertEquals(Arrays.asList(8), ranks); + } + + @Test + public void testUnsortedRoyalFlush() { + Game g = new Game(); + List firstHand = new ArrayList<>(); + List> hands = new ArrayList<>(); + List ranks = new ArrayList<>(); + firstHand.add(new Card(11, Suit.CLUBS)); + firstHand.add(new Card(13, Suit.CLUBS)); + firstHand.add(new Card(10, Suit.CLUBS)); + firstHand.add(new Card(1, Suit.CLUBS)); + firstHand.add(new Card(12, Suit.CLUBS)); + firstHand = g.sort(firstHand); + hands.add(firstHand); + ranks.add(g.getRank(firstHand)); + assertEquals(Arrays.asList(9), ranks); + } + + @Test + public void highCardVsHighCard() { + Game g = new Game(); + List firstHand = new ArrayList<>(); + List secondHand = new ArrayList<>(); + List> hands = new ArrayList<>(); + List ranks = new ArrayList<>(); + firstHand.add(new Card(11, Suit.CLUBS)); + firstHand.add(new Card(3, Suit.DIAMONDS)); + firstHand.add(new Card(8, Suit.SPADES)); + firstHand.add(new Card(9, Suit.HEARTS)); + firstHand.add(new Card(5, Suit.CLUBS)); + firstHand = g.sort(firstHand); + hands.add(firstHand); + ranks.add(g.getRank(firstHand)); + secondHand.add(new Card(1, Suit.CLUBS)); + secondHand.add(new Card(3, Suit.SPADES)); + secondHand.add(new Card(9, Suit.SPADES)); + secondHand.add(new Card(7, Suit.DIAMONDS)); + secondHand.add(new Card(5, Suit.HEARTS)); + secondHand = g.sort(secondHand); + hands.add(secondHand); + ranks.add(g.getRank(secondHand)); + g.setHands(hands); + g.setRanks(ranks); + assertEquals(1, g.getWinner()); + } + + @Test + public void highCardVsPair() { + Game g = new Game(); + List firstHand = new ArrayList<>(); + List secondHand = new ArrayList<>(); + List> hands = new ArrayList<>(); + List ranks = new ArrayList<>(); + firstHand.add(new Card(11, Suit.CLUBS)); + firstHand.add(new Card(3, Suit.DIAMONDS)); + firstHand.add(new Card(8, Suit.SPADES)); + firstHand.add(new Card(9, Suit.HEARTS)); + firstHand.add(new Card(5, Suit.CLUBS)); + firstHand = g.sort(firstHand); + hands.add(firstHand); + ranks.add(g.getRank(firstHand)); + secondHand.add(new Card(4, Suit.CLUBS)); + secondHand.add(new Card(3, Suit.SPADES)); + secondHand.add(new Card(9, Suit.SPADES)); + secondHand.add(new Card(9, Suit.DIAMONDS)); + secondHand.add(new Card(5, Suit.HEARTS)); + secondHand = g.sort(secondHand); + hands.add(secondHand); + ranks.add(g.getRank(secondHand)); + g.setHands(hands); + g.setRanks(ranks); + assertEquals(1, g.getWinner()); + } + + @Test + public void pairVsPair() { + Game g = new Game(); + List firstHand = new ArrayList<>(); + List secondHand = new ArrayList<>(); + List> hands = new ArrayList<>(); + List ranks = new ArrayList<>(); + firstHand.add(new Card(1, Suit.CLUBS)); + firstHand.add(new Card(13, Suit.DIAMONDS)); + firstHand.add(new Card(5, Suit.SPADES)); + firstHand.add(new Card(6, Suit.DIAMONDS)); + firstHand.add(new Card(5, Suit.CLUBS)); + firstHand = g.sort(firstHand); + hands.add(firstHand); + ranks.add(g.getRank(firstHand)); + secondHand.add(new Card(11, Suit.HEARTS)); + secondHand.add(new Card(2, Suit.CLUBS)); + secondHand.add(new Card(12, Suit.HEARTS)); + secondHand.add(new Card(9, Suit.SPADES)); + secondHand.add(new Card(12, Suit.CLUBS)); + secondHand = g.sort(secondHand); + hands.add(secondHand); + ranks.add(g.getRank(secondHand)); + g.setHands(hands); + g.setRanks(ranks); + assertEquals(1, g.getWinner()); + } + + @Test + public void pairVsTwoPair() { + Game g = new Game(); + List firstHand = new ArrayList<>(); + List secondHand = new ArrayList<>(); + List> hands = new ArrayList<>(); + List ranks = new ArrayList<>(); + firstHand.add(new Card(11, Suit.CLUBS)); + firstHand.add(new Card(3, Suit.DIAMONDS)); + firstHand.add(new Card(8, Suit.SPADES)); + firstHand.add(new Card(9, Suit.HEARTS)); + firstHand.add(new Card(8, Suit.CLUBS)); + firstHand = g.sort(firstHand); + hands.add(firstHand); + ranks.add(g.getRank(firstHand)); + secondHand.add(new Card(4, Suit.CLUBS)); + secondHand.add(new Card(3, Suit.SPADES)); + secondHand.add(new Card(9, Suit.SPADES)); + secondHand.add(new Card(9, Suit.DIAMONDS)); + secondHand.add(new Card(3, Suit.HEARTS)); + secondHand = g.sort(secondHand); + hands.add(secondHand); + ranks.add(g.getRank(secondHand)); + g.setHands(hands); + g.setRanks(ranks); + assertEquals(1, g.getWinner()); + } + + @Test + public void twoPairVsTwoPair() { + Game g = new Game(); + List firstHand = new ArrayList<>(); + List secondHand = new ArrayList<>(); + List> hands = new ArrayList<>(); + List ranks = new ArrayList<>(); + firstHand.add(new Card(1, Suit.CLUBS)); + firstHand.add(new Card(8, Suit.SPADES)); + firstHand.add(new Card(6, Suit.SPADES)); + firstHand.add(new Card(8, Suit.HEARTS)); + firstHand.add(new Card(6, Suit.CLUBS)); + firstHand = g.sort(firstHand); + hands.add(firstHand); + ranks.add(g.getRank(firstHand)); + secondHand.add(new Card(12, Suit.HEARTS)); + secondHand.add(new Card(9, Suit.CLUBS)); + secondHand.add(new Card(9, Suit.SPADES)); + secondHand.add(new Card(2, Suit.SPADES)); + secondHand.add(new Card(12, Suit.DIAMONDS)); + secondHand = g.sort(secondHand); + hands.add(secondHand); + ranks.add(g.getRank(secondHand)); + g.setHands(hands); + g.setRanks(ranks); + assertEquals(1, g.getWinner()); + } + + @Test + public void threeOfKindVsThreeOfKind() { + Game g = new Game(); + List firstHand = new ArrayList<>(); + List secondHand = new ArrayList<>(); + List> hands = new ArrayList<>(); + List ranks = new ArrayList<>(); + firstHand.add(new Card(11, Suit.CLUBS)); + firstHand.add(new Card(2, Suit.CLUBS)); + firstHand.add(new Card(11, Suit.SPADES)); + firstHand.add(new Card(13, Suit.SPADES)); + firstHand.add(new Card(11, Suit.DIAMONDS)); + firstHand = g.sort(firstHand); + hands.add(firstHand); + ranks.add(g.getRank(firstHand)); + secondHand.add(new Card(9, Suit.HEARTS)); + secondHand.add(new Card(12, Suit.CLUBS)); + secondHand.add(new Card(8, Suit.HEARTS)); + secondHand.add(new Card(12, Suit.HEARTS)); + secondHand.add(new Card(12, Suit.SPADES)); + secondHand = g.sort(secondHand); + hands.add(secondHand); + ranks.add(g.getRank(secondHand)); + g.setHands(hands); + g.setRanks(ranks); + assertEquals(1, g.getWinner()); + } + + @Test + public void fullHouseVsfullHouse() { + Game g = new Game(); + List firstHand = new ArrayList<>(); + List secondHand = new ArrayList<>(); + List> hands = new ArrayList<>(); + List ranks = new ArrayList<>(); + firstHand.add(new Card(11, Suit.CLUBS)); + firstHand.add(new Card(11, Suit.HEARTS)); + firstHand.add(new Card(11, Suit.SPADES)); + firstHand.add(new Card(5, Suit.SPADES)); + firstHand.add(new Card(5, Suit.DIAMONDS)); + firstHand = g.sort(firstHand); + hands.add(firstHand); + ranks.add(g.getRank(firstHand)); + secondHand.add(new Card(12, Suit.HEARTS)); + secondHand.add(new Card(12, Suit.CLUBS)); + secondHand.add(new Card(8, Suit.HEARTS)); + secondHand.add(new Card(12, Suit.DIAMONDS)); + secondHand.add(new Card(8, Suit.SPADES)); + secondHand = g.sort(secondHand); + hands.add(secondHand); + ranks.add(g.getRank(secondHand)); + g.setHands(hands); + g.setRanks(ranks); + assertEquals(1, g.getWinner()); + } + + @Test + public void fourOfKindVsfourOfKind() { + Game g = new Game(); + List firstHand = new ArrayList<>(); + List secondHand = new ArrayList<>(); + List> hands = new ArrayList<>(); + List ranks = new ArrayList<>(); + firstHand.add(new Card(11, Suit.CLUBS)); + firstHand.add(new Card(11, Suit.HEARTS)); + firstHand.add(new Card(11, Suit.SPADES)); + firstHand.add(new Card(13, Suit.SPADES)); + firstHand.add(new Card(11, Suit.DIAMONDS)); + firstHand = g.sort(firstHand); + hands.add(firstHand); + ranks.add(g.getRank(firstHand)); + secondHand.add(new Card(12, Suit.HEARTS)); + secondHand.add(new Card(12, Suit.CLUBS)); + secondHand.add(new Card(8, Suit.HEARTS)); + secondHand.add(new Card(12, Suit.DIAMONDS)); + secondHand.add(new Card(12, Suit.SPADES)); + secondHand = g.sort(secondHand); + hands.add(secondHand); + ranks.add(g.getRank(secondHand)); + g.setHands(hands); + g.setRanks(ranks); + assertEquals(1, g.getWinner()); + } +} diff --git a/card/Card$1.class b/card/Card$1.class new file mode 100644 index 0000000..2e6a9e7 Binary files /dev/null and b/card/Card$1.class differ diff --git a/card/Card.class b/card/Card.class new file mode 100644 index 0000000..89c0106 Binary files /dev/null and b/card/Card.class differ diff --git a/card/Card.java b/card/Card.java new file mode 100644 index 0000000..fb42314 --- /dev/null +++ b/card/Card.java @@ -0,0 +1,60 @@ +package card; + +public class Card { + private int value; + private Suit suit; + + public Card(int value, Suit suit) { + this.value = value; + this.suit = suit; + } + + public int getValue() { + return this.value; + } + + public Suit getSuit() { + return this.suit; + } + + public String displayCard() { + String name = ""; + if (this.value < 1 || this.value > 13) { + name += "UNKNOWN"; + } else if (this.value > 1 && this.value < 11) { + name += this.value; + } else { + switch (this.value) { + case 1: + name += "ace"; + break; + case 11: + name += "jack"; + break; + case 12: + name += "queen"; + break; + case 13: + name += "king"; + break; + default: + name += "UNKNOWN"; + } + } + switch (this.suit) { + case CLUBS: + name += " of clubs"; + break; + case DIAMONDS: + name += " of diamonds"; + break; + case HEARTS: + name += " of hearts"; + break; + case SPADES: + name += " of spades"; + break; + } + return name; + } +} diff --git a/card/Suit.class b/card/Suit.class new file mode 100644 index 0000000..0450003 Binary files /dev/null and b/card/Suit.class differ diff --git a/card/Suit.java b/card/Suit.java new file mode 100644 index 0000000..f31de7e --- /dev/null +++ b/card/Suit.java @@ -0,0 +1,8 @@ +package card; + +public enum Suit { + CLUBS, + DIAMONDS, + HEARTS, + SPADES +} diff --git a/lib/hamcrest-core-1.3.jar b/lib/hamcrest-core-1.3.jar new file mode 100644 index 0000000..9d5fe16 Binary files /dev/null and b/lib/hamcrest-core-1.3.jar differ diff --git a/lib/junit-4.13.2.jar b/lib/junit-4.13.2.jar new file mode 100644 index 0000000..6da55d8 Binary files /dev/null and b/lib/junit-4.13.2.jar differ -- cgit v1.2.3