Merge from home

PokerGame.java
PokerGameTest.java

PokerKata/src/session3/Card.java

@@ -0,0 +1,22 @@
+package session3;
+
+public class Card {
+
+	private int value;
+	private String card;
+
+	public Card(String cardAsString) {
+		this.card = cardAsString;
+		this.value = "23456789TJQKA".indexOf(cardAsString.substring(0,1)) + 2;
+	}
+
+	public int getValue() {
+		return value;
+	}
+	
+	@Override
+	public String toString() {
+		return card;
+	}
+	
+}

PokerKata/src/session3/HighCardRule.java

@@ -0,0 +1,31 @@
+package session3;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+
+public class HighCardRule {
+
+	public static Player compare(Player player1, Player player2) {
+		// Hands to lists
+		List<Card> playerHand1 = player1.getPlayerHand();
+		List<Card> playerHand2 = player2.getPlayerHand();
+
+		PokerGameComparator comparator = new PokerGameComparator();
+		Collections.sort(playerHand1, comparator);
+		Collections.sort(playerHand2, comparator);
+
+		for (int i = 0; i < playerHand1.size(); i++) {
+			int p1Value = playerHand1.get(i).getValue();
+			int p2Value = playerHand2.get(i).getValue();
+			if (p1Value > p2Value) {
+				return player1;
+			}
+			if (p2Value > p1Value) {
+				return player2;
+			}
+		}
+		return null;
+	}
+
+}

PokerKata/src/session3/PairRule.java

@@ -0,0 +1,46 @@
+package session3;
+
+import java.util.Collections;
+
+public class PairRule {
+
+	public static Player compare(Player left, Player right) {
+//		if (playerHasPair(left)) {
+//			return left;
+//		}
+//		if (playerHasPair(right)) {
+//			return right;
+//		}
+		
+		int pairValueLeft = getValueOfPairForPlayer(left);
+		int pairValueRight = getValueOfPairForPlayer(right);
+		
+		if (pairValueLeft > pairValueRight) {
+			return left;
+		}
+		
+		if (pairValueRight  > pairValueLeft) {
+			return right;
+		}
+		
+		return null;
+	}
+
+	private static int getValueOfPairForPlayer(Player left) {
+		PokerGameComparator comparator = new PokerGameComparator();
+		Collections.sort(left.getPlayerHand(), comparator);
+		int cardValue=0;
+		
+		for (Card card : left.getPlayerHand()) {
+			if (card.getValue() == cardValue){
+				return card.getValue();
+			}
+			else{
+				cardValue= card.getValue();
+			}
+				
+		}
+		return 0;
+	}
+
+}

PokerKata/src/session3/Player.java

@@ -0,0 +1,28 @@
+package session3;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Player {
+
+	private String name;
+	private ArrayList<Card> cards;
+
+	public Player(String name, String cards) {
+		this.name = name;
+		this.cards = new ArrayList<Card>();
+		String[] split = cards.split(" ");
+		for (String val : split) {
+			this.cards.add(new Card(val));
+		}
+	}
+
+	public String getPlayerName() {
+		return name;
+	}
+
+	public List<Card> getPlayerHand() {
+		return this.cards;
+	}
+
+}

PokerKata/src/session3/PokerGame.java

@@ -1,14 +1,6 @@
-/**
- * PokerGame.java
- * 
- * Course in Software Craftsmenship @ Högskolan Väst
- * Poker game kata for testing TDD, Test Driven Development
- * 
- * 2015-04-27
- */
-
 package session3;
 
+<<<<<<< HEAD
 import java.util.Arrays;
 
 /**
@@ -268,10 +260,23 @@ public class PokerGame {
 		// Find all values
 		for (int i = 0; i < hand.length() - 1; i += 2) {
 			temp += hand.charAt(i);
+=======
+public class PokerGame {
+
+	public Player calculateWinningPlayer(Player left, Player right) {
+		
+		Player twoPairResult = TwoPairRule.compare(left, right);
+		if(twoPairResult != null){
+			return twoPairResult;
 		}
-		colors = temp.toCharArray();
-		Arrays.sort(colors);
-		return colors;
+		
+		Player pairResult = PairRule.compare(left, right);
+		if(pairResult != null){
+			return pairResult;
+>>>>>>> origin/master
+		}
+		
+		return HighCardRule.compare(left, right);
 	}
 
 }

PokerKata/src/session3/PokerGameComparator.java

@@ -0,0 +1,12 @@
+package session3;
+
+import java.util.Comparator;
+
+public class PokerGameComparator implements Comparator<Card> {
+
+	@Override
+	public int compare(Card arg0, Card arg1) {
+		return arg1.getValue() - arg0.getValue();
+	}
+
+}

PokerKata/src/session3/TwoPairRule.java

@@ -0,0 +1,67 @@
+package session3;
+
+import java.util.Collections;
+
+public class TwoPairRule {
+
+	private static final int[] noPairs = { 0, 0 };
+
+	public static Player compare(Player left, Player right) {
+		int[] pairsLeft = getValuesForTwoPair(left);
+		int[] pairsRight = getValuesForTwoPair(right);
+
+		for (int i = 0; i < 2; i++) {
+			int pairValueLeft = pairsLeft[i];
+			int pairValueRight = pairsRight[i];
+
+			if (pairValueLeft > pairValueRight) {
+				return left;
+			}
+			if (pairValueRight > pairValueLeft) {
+				return right;
+			}
+		}
+
+		return null;
+	}
+
+	private static int[] getValuesForTwoPair(Player player) {
+		if (!playerHasTwoPair(player)) {
+			return noPairs;
+		}
+		PokerGameComparator comparator = new PokerGameComparator();
+		Collections.sort(player.getPlayerHand(), comparator);
+		int[] cardValues = new int[2];
+		int pairCount = 0;
+
+		for (Card card : player.getPlayerHand()) {
+			if (card.getValue() == cardValues[pairCount]) {
+				cardValues[pairCount++] = card.getValue();
+			} else {
+				cardValues[pairCount] = card.getValue();
+			}
+		}
+		return cardValues;
+	}
+
+	private static boolean playerHasTwoPair(Player player) {
+		PokerGameComparator comparator = new PokerGameComparator();
+		Collections.sort(player.getPlayerHand(), comparator);
+		int cardValue = 0;
+		int pairCount = 0;
+
+		for (Card card : player.getPlayerHand()) {
+			if (card.getValue() == cardValue) {
+				pairCount++;
+			} else {
+				cardValue = card.getValue();
+			}
+		}
+
+		if (pairCount == 2) {
+			return true;
+		}
+		return false;
+	}
+
+}