merging solitaire

src/main/java/io/zipcoder/casino/CardGame/Card.java

@@ -6,7 +6,7 @@ import static io.zipcoder.casino.CardGame.Face.getFaceByValue;
 import static io.zipcoder.casino.CardGame.Suit.getSuitByValue;
 
 public class Card {
-
+//9D on 10S didn't work...
     private Suit suit;
     private boolean isBlack;
     private Face face;
@@ -23,9 +23,6 @@ public class Card {
 //    }
 
     public static Card toCard(char face, char suit){
-//        char s = suit.charAt(0);
-//        char f = face.charAt(0);
-//        return new Card(getSuitByValue(s), getFaceByValue(f));
         return new Card(getSuitByValue(suit), getFaceByValue(face));
     }
 
@@ -42,7 +39,7 @@ public class Card {
     }
 
     private void setBlack(){
-        if(this.getSuit().toString().equals("HEARTS") || this.getSuit().toString().equals("DIAMOND")) isBlack = false;
+        if(this.getSuit().toString().equals("HEARTS") || this.getSuit().toString().equals("DIAMONDS")) isBlack = false;
         else isBlack = true;
     }
 
@@ -74,6 +71,11 @@ public class Card {
         return suit + "-" + face;
     }
 
+    public String toString2(){
+        if (this.isCovered()) return "--";
+        else return "" + face.getTertiaryValue() + suit.getPrimaryValue();
+    }
+
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;

src/main/java/io/zipcoder/casino/CardGame/Solitaire/Foundation.java

@@ -13,6 +13,7 @@ public class Foundation {
     public static Stack<Card> diamondStack = new Stack<>();
     public static Stack<Card> heartStack = new Stack<>();
     public static Stack<Card> spadeStack = new Stack<>();
+    public static Boolean foundsFull = false;
 
     public Foundation() {
 
@@ -28,59 +29,63 @@ public class Foundation {
         if (tempStackCard.peek().getSuit() == Suit.CLUBS) {
             //Checks if the Clubs Foundation is Empty
             if (clubStack.empty() && tempStackCard.peek().getFace() == Face.ACE) {
-                clubStack.push(tempStackCard.peek());
+                clubStack.push(tempStackCard.pop());
             }
-            //Checks if the Temp Card is 1 more than what
-            // is on the Foundation
-
-            if (tempStackCard.peek().getFace().getPrimaryValue() == clubStack.peek().getFace().getPrimaryValue() + 1) {
-                clubStack.push(tempStackCard.peek());
-
+            //Checks if the Temp Card is 1 more than what is on the Foundation
+            else if (tempStackCard.peek().getFace().getPrimaryValue() == clubStack.peek().getFace().getPrimaryValue() + 1) {
+                clubStack.push(tempStackCard.pop());
             }
         }
 
-        if (tempStackCard.peek().getSuit() == Suit.DIAMONDS) {
+        else if (tempStackCard.peek().getSuit() == Suit.DIAMONDS) {
 
             //Checks if the Diamonds Foundation is Empty
             if (diamondStack.empty() && tempStackCard.peek().getFace() == Face.ACE) {
-                diamondStack.push(tempStackCard.peek());
+                diamondStack.push(tempStackCard.pop());
             }
-            //Checks if the Temp Card is 1 more than what
-            // is on the Foundation
-            if (tempStackCard.peek().getFace().getPrimaryValue() == diamondStack.peek().getFace().getPrimaryValue() + 1) {
-                diamondStack.push(tempStackCard.peek());
+            //Checks if the Temp Card is 1 more than what is on the Foundation
+            else if (tempStackCard.peek().getFace().getPrimaryValue() == diamondStack.peek().getFace().getPrimaryValue() + 1) {
+                diamondStack.push(tempStackCard.pop());
             }
         }
 
-        if (tempStackCard.peek().getSuit() == Suit.HEARTS) {
+        else if (tempStackCard.peek().getSuit() == Suit.HEARTS) {
 
             //Checks if the Heart Foundation is Empty
             if (heartStack.empty() && tempStackCard.peek().getFace() == Face.ACE) {
-                heartStack.push(tempStackCard.peek());
+                heartStack.push(tempStackCard.pop());
             }
-            //Checks if the Temp Card is 1 more than what
-            // is on the Foundation
-            if (tempStackCard.peek().getFace().getPrimaryValue() == heartStack.peek().getFace().getPrimaryValue() + 1) {
-                heartStack.push(tempStackCard.peek());
+            //Checks if the Temp Card is 1 more than what is on the Foundation
+            else if (tempStackCard.peek().getFace().getPrimaryValue() == heartStack.peek().getFace().getPrimaryValue() + 1) {
+                heartStack.push(tempStackCard.pop());
             }
         }
 
-        if (tempStackCard.peek().getSuit() == Suit.SPADES) {
+        else if (tempStackCard.peek().getSuit() == Suit.SPADES) {
 
 
             if (spadeStack.empty() && tempStackCard.peek().getFace() == Face.ACE) {
-                spadeStack.push(tempStackCard.peek());
+                spadeStack.push(tempStackCard.pop());
             }
-            if (tempStackCard.peek().getFace().getPrimaryValue() == spadeStack.peek().getFace().getPrimaryValue() + 1) {
-                spadeStack.push(tempStackCard.peek());
+            else if (tempStackCard.peek().getFace().getPrimaryValue() == spadeStack.peek().getFace().getPrimaryValue() + 1) {
+                spadeStack.push(tempStackCard.pop());
             }
         }
     }
 
     public static Boolean allFoundsFull() {
+        if (foundsFull == true) return true;
+        return false;
+    }
+
+    public static void checkFoundsFull() {
         if (clubStack.size() == 13 && spadeStack.size() == 13
-                && heartStack.size() == 13  && diamondStack.size() == 13)
-            return true;
-        else return false;
+                && heartStack.size() == 13  && diamondStack.size() == 13) {
+            foundsFull = true;
+        }
     }
+
+    public static void cheatFoundations(){
+        foundsFull = true;
+        }
 }

src/main/java/io/zipcoder/casino/CardGame/Solitaire/Solitaire.java

@@ -6,11 +6,13 @@ import io.zipcoder.casino.CardGame.Deck;
 import io.zipcoder.casino.Console;
 import io.zipcoder.casino.Player;
 
+import java.util.EmptyStackException;
 import java.util.Scanner;
 import java.util.Stack;
 
 import static io.zipcoder.casino.CardGame.Card.toCard;
 import static io.zipcoder.casino.CardGame.Solitaire.Foundation.allFoundsFull;
+import static io.zipcoder.casino.CardGame.Solitaire.Foundation.cheatFoundations;
 import static io.zipcoder.casino.CardGame.Solitaire.Foundation.whichSuit;
 
 public class Solitaire extends CardGame {
@@ -19,6 +21,7 @@ public class Solitaire extends CardGame {
         Solitaire s = new Solitaire(new Player("Bill"));
         s.start();
     }
+    Console console = new Console(System.in, System.out);
 
     Scanner in = new Scanner(System.in);
     //clean up.
@@ -29,6 +32,8 @@ public class Solitaire extends CardGame {
     public Stack<Card> wastePile;
     public Tableau[] arrayTabs;
     public static Stack<Card> tempStack = new Stack<>();
+    public static Stack<Card> lastStack = null;
+    public Boolean ifFromWaste = false;
 
     public Solitaire(Player player) {
         this.player = player;
@@ -41,13 +46,27 @@ public class Solitaire extends CardGame {
         tab6 = new Tableau();
         tab7 = new Tableau();
         arrayTabs = new Tableau[]{tab1, tab2, tab3, tab4, tab5, tab6, tab7};
-        start();
     }
 
     public static Deck solitaireDeck = new Deck();
 
-    public void deal() {
+
+    public void start(){
+        System.out.println("Welcome");
+        resetDeck();
+        wastePile.removeAllElements();
+        tempStack.removeAllElements();
+        shuffle();
+        deal();
+        print();
+        takeATurn();
+    }
+
+    public void shuffle(){
         solitaireDeck.shuffle();
+    }
+
+    public void deal() {
         for (int i = 0; i < arrayTabs.length; i++) {
             for (int j = 0; j < arrayTabs.length; j++) {
                 if (j >= i) arrayTabs[j].add(draw());
@@ -63,6 +82,7 @@ public class Solitaire extends CardGame {
 
     public Stack<Card> pickUp(){
         tempStack.push(wastePile.pop());
+        lastStack = wastePile;
         return tempStack;
     }
 
@@ -92,80 +112,75 @@ public class Solitaire extends CardGame {
             case '8':
                 whichSuit(tempStack);
                 break;
-            case '9':
-                whichSuit(tempStack);
-                break;
-            case '0':
-                whichSuit(tempStack);
-                break;
-            case '-':
-                whichSuit(tempStack);
-                break;
-            case 'E': //develop way to replace original stack on pile. don't change coverage until placed. same with pulled from stack.
-                break;
             default:
                 System.out.println("Not a valid entry. Try again or press \'E\'");
                 dropToTab(in.next().charAt(0));
         }
     }
 
-    public Stack<Card> pull(String cardCode){
-        char f = cardCode.charAt(0);
-        char s = cardCode.charAt(1);
+    public void pull(String cardCode){
+        char f = cardCode.toUpperCase().charAt(0);
+        char s = cardCode.toUpperCase().charAt(1);
         Card c = toCard(f,s);
-        return findTab(c).pull(c);
+        findTab(c).pull(c);
     }
 
     public Tableau findTab(Card c){
         for (Tableau tab : arrayTabs)
-            if (tab.stack.contains(c))
+            if (tab.stack.contains(c)) {
+                lastStack = tab.stack;
                 return tab;
+            }
         return null;
     }
 
-    public void start(){
-        System.out.println("Welcome");
-        resetDeck();
-        wastePile.removeAllElements();
-        deal();
-        print();
-        takeATurn();
-    }
-
-    public void end() {
-        System.out.println("Congratulations!");
-        System.out.println("Enter \'N\' to play again or press \'Q\' to quit");
-        String command = in.next().toUpperCase();
-        while (!command.equals("Q") || !command.equals("N")){
-            if (command.equals("Q")) end();
-            else if (command.equals("N")) start();
-            else System.out.println("Invalid. Enter \'N\' to play again or press \'Q\' to quit");
-        }
-    }
-
-    public String getInput(){
-        return in.next();
+    public void peekWaste(){
+        if(wastePile.size()>0) System.out.println("\n\nDraw pile: " + wastePile.peek().toString2());
     }
 
+    //you've got a temp stack. so when you pull a card, show it. if it doesn't go, put it back.
+    //fix empty stack exceptions
+    //draw shouldn't reprint every time. only print top of wastePile
+    //build console class for solitaire printouts
     public void takeATurn() {
-        Console.println("Let's play");
-        while (!getInput().equals("QUIT") || !allFoundsFull()) {
-            if (Console.getInputString("Enter draw to draw a card").equals("DRAW")) {
-                drawCard();
-                print();
-                continue;
-            } else if (Console.getInputString("Enter draw to draw a card").equals("P")) {
-                pickUp();
-                dropToTab(getInput().charAt(0));
-                print();
-            } else if (Console.getInputString("Enter draw to draw a card").length() == 2) {
-                pull(String.valueOf(getInput()));
-                dropToTab(getInput().charAt(0));
-                print();
+            console.println("\n\nReady? Let's Play");
+            while (!allFoundsFull() || !gameOver()) {
+                String command = console.getInputString("\nWhat now?");
+                switch (String.valueOf(command)) {
+                    case "DRAW":
+                        drawCard();
+                        print();
+                        //console.println("\nDraw pile: " + wastePile.peek().toString2());
+                        break;
+                    case "P":
+                        //try, catch, continue
+                        try {
+                            pickUp();
+                            console.println("\nYou just picked up " + tempStack.peek().toString2());
+                                dropToTab(console.getDropTab().charAt(0));
+                            print();
+                            break;
+                        } catch (EmptyStackException e) {
+                            console.println("\nCan't pull from an empty draw pile");
+                            break;
+                        }
+                    case "QUIT":
+                        gameOver();
+//                    case "FOO":
+//                        cheatFoundations();
+                    default:
+                        try {
+                            pull(String.valueOf(command));
+                            console.println("\nYou just pulled " + tempStack.peek().toString2());
+                            dropToTab(console.getDropTab().charAt(0));
+                        } catch (NullPointerException e) {
+                            console.println("Card does not exist. Try again :)\n");
+                            break;
+                        }
+                        print();
+                        break;
+                }
             }
-        }
-
-        if (allFoundsFull()) end();
     }
 
     public void addPlayer(Player player) {
@@ -176,12 +191,6 @@ public class Solitaire extends CardGame {
 
     }
 
-    public void moveable() {
-    }
-
-    public void receivable() {
-    }
-
     public Card draw() {
         return solitaireDeck.draw();
     }
@@ -189,15 +198,56 @@ public class Solitaire extends CardGame {
     public void resetDeck(){
         solitaireDeck = new Deck();
     }
+    Foundation found = new Foundation();
 
     public void print(){
-        int i = 0;
+        System.out.println("CLUBS\t\tDIAMONDS\t\tHEARTS\t\tSPADES");
+        System.out.println("------\t\t--------\t\t------\t\t------");
+
+        if (Foundation.clubStack.size() == 0){
+            System.out.print("  --  \t\t");
+        } else {
+            System.out.print("  " + Foundation.clubStack.peek().toString2() + "  \t\t");
+        }
+
+        if (Foundation.diamondStack.size() == 0){
+            System.out.print("   --  \t\t\t");
+        } else {
+            System.out.print("  " + Foundation.diamondStack.peek().toString2() + "  \t\t\t");
+        }
+
+        if (Foundation.heartStack.size() == 0){
+            System.out.print("  --  \t\t");
+        } else {
+            System.out.print("  " + Foundation.heartStack.peek().toString2() + "  \t");
+        }
+        if (Foundation.spadeStack.size() == 0){
+            System.out.println("  --  \t\t");
+        } else {
+            System.out.print("  " + Foundation.spadeStack.peek().toString2() + "  \t\n");
+        }
+
+        int i = 1;
         for (Tableau tab : arrayTabs) {
-            System.out.println("tab " + i); i++;
-            tab.stack.forEach(e -> System.out.println(e + " " + e.isCovered()));
+            System.out.println("\nCOLUMN " + i); i++;
+            tab.stack.forEach(e -> System.out.print(e.toString2() + " " + "\t"));
         }
-        if (wastePile.size() > 0) System.out.println("Top of Pile " + wastePile.peek());
+        peekWaste();
     }
 
+    public Boolean gameOver(){
+        if(console.getInputString("Are you sure you want to quit?\nEnter Y to quit").equals("Y")) return true;
+        return false;
+    }
 
-}
+    public void end() {
+        System.out.println("Congratulations!");
+        System.out.println("Enter \'N\' to play again or press \'Q\' to quit");
+        String command = in.next().toUpperCase();
+        while (!command.equals("Q") || !command.equals("N")){
+            if (command.equals("Q"));
+            else if (command.equals("N")) start();
+            else System.out.println("Invalid. Enter \'N\' to play again or press \'Q\' to quit");
+        }
+    }
+}

src/main/java/io/zipcoder/casino/CardGame/Solitaire/Tableau.java

@@ -4,6 +4,7 @@ import io.zipcoder.casino.CardGame.Card;
 
 import java.util.Stack;
 
+import static io.zipcoder.casino.CardGame.Solitaire.Solitaire.lastStack;
 import static io.zipcoder.casino.CardGame.Solitaire.Solitaire.tempStack;
 
 public class Tableau {
@@ -23,27 +24,21 @@ public class Tableau {
         stack.push(c);
     }
 
-    //need to preface with a find stack method. maybe at higher level that feeds into this.stack
-    // - so that player doesn't have to select the stack, he can just type in card to place onto.
-
-    //c = the top card of the subStack you want to pull - ex. 6D, 5C, 4H, 3S, 2D, AS; if pulling 4H and down, c = 4H.
-    public Stack<Card> pull(Card c){
-        if(this.stack.contains(c)){
-            while(!stack.peek().equals(c))  tempStack.push(stack.pop());
-            tempStack.push(stack.pop());
-            }
-        unCover();
-        return tempStack;
+    //c = the top card of the subStack you want to pull - ex. 6D, 5C, 4H, 3S, 2D, AS; if you want to pull 4H and down, c = 4H.
+    public void pull(Card c){
+        while(!stack.peek().equals(c))  tempStack.push(stack.pop());
+        tempStack.push(stack.pop());
         }
 
     //does not need parameter. with a stack representing each column, will simply call 'stack'.place() to drop the tempStack on top of it.
     public void place(){
         if (this.canReceive(tempStack.peek())){
             while(tempStack.iterator().hasNext()){
-                unCover();
+                unCover(lastStack);
                 add(tempStack.pop());
             }
-        }
+            unCover(lastStack);
+        } else { lastStack.push(tempStack.pop()); }
     }
 
     //checks whether 'top' card of stack is opposite color and 1 above passed card
@@ -61,7 +56,7 @@ public class Tableau {
         } return false;
     }
 
-    private void unCover(){
-        if (size() > 0 && this.stack.peek().isCovered()) this.stack.peek().setCovered(false);
+    private void unCover(Stack<Card> lastStack){
+        if (size() > 0 && lastStack.peek().isCovered()) lastStack.peek().setCovered(false);
     }
 }

src/main/java/io/zipcoder/casino/Console.java

@@ -6,24 +6,24 @@ import java.util.Scanner;
 
 public class Console {
 
-    private static Scanner input;
-    private static PrintStream output;
+    private final Scanner input;
+    private final PrintStream output;
 
     public Console(InputStream in, PrintStream out) {
         this.input = new Scanner(in);
         this.output = out;
     }
 
-    public static void println(String prompt, Object... args) {
+    public void println(String prompt, Object... args) {
         output.format(prompt + "\n", args);
     }
 
-    public static String getInputString(String prompt, Object... args) {
+    public String getInputString(String prompt, Object... args) {
         println(prompt, args);
         return input.nextLine();
     }
 
-    public static Double getInputDouble(String prompt, Object... args) {
+    public Double getInputDouble(String prompt, Object... args) {
         String stringInput = getInputString(prompt, args);
         do {
             try {
@@ -35,7 +35,7 @@ public class Console {
         } while (true);
     }
 
-    public static Integer getInputInteger(String prompt, Object... args) {
+    public Integer getInputInteger(String prompt, Object... args) {
         return getInputDouble(prompt, args).intValue();
     }
 
@@ -52,4 +52,8 @@ public class Console {
         return scanner.nextInt();
     }
 
+    public String getDropTab(){
+        return getInputString("To which row do you want to drop?");
+    }
+
 }

src/main/java/io/zipcoder/casino/InputOutput.java

@@ -0,0 +1,9 @@
+package io.zipcoder.casino;
+
+public class InputOutput {
+
+    public static final Console console = new Console(System.in, System.out);
+
+
+
+}

src/test/java/io/zipcoder/casino/CardGame/Solitaire/FoundationTest.java

@@ -4,6 +4,7 @@ import io.zipcoder.casino.CardGame.Card;
 import io.zipcoder.casino.CardGame.Deck;
 import io.zipcoder.casino.CardGame.Face;
 import io.zipcoder.casino.CardGame.Suit;
+import io.zipcoder.casino.Player;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -203,4 +204,12 @@ public class FoundationTest {
         Assert.assertEquals(expected, actual);
     }
 
+    @Test
+    public void testCheatFoundations(){
+        Solitaire s = new Solitaire(new Player("234"));
+        s.resetDeck();
+        Foundation.cheatFoundations();
+
+    }
+
 }

src/test/java/io/zipcoder/casino/CardGame/Solitaire/SolitaireTest.java

@@ -10,30 +10,30 @@ import static io.zipcoder.casino.CardGame.Card.toCard;
 public class SolitaireTest {
     Solitaire s = new Solitaire(new Player("Murphy"));
 
-//    @Test
-//    public void testfind() {
-//        s.resetDeck();
-//        s.tab1.add(toCard("Ace", "Hearts"));
-//        s.tab2.add(toCard("five", "diamonds"));
-//
-//        System.out.println(s.findTab(toCard("Ace", "Hearts")).stack.peek());
-//    }
-//
-//    @Test
-//    public void testPull() {
-//        s.resetDeck();
-//        s.tab1.add(toCard("Ace", "Hearts"));
-//        s.tab2.add(toCard("five", "diamonds"));
-//
-//        Integer preSize = s.tab1.size();
-//        s.pull(toCard("Ace", "Hearts")); //main method tested
-//        Integer postSize = s.tab1.size();
-//
-//        Integer actual = preSize - postSize;
-//        Integer expected = 1;
-//
-//        Assert.assertEquals(expected, actual);
-//    }
+    @Test
+    public void testfind() {
+        s.resetDeck();
+        s.tab1.add(toCard('A', 'H'));
+        s.tab2.add(toCard('5', 'D'));
+
+        System.out.println(s.findTab(toCard('A', 'H')).stack.peek());
+    }
+
+    @Test
+    public void testPull2() {
+        s.resetDeck();
+        s.tab1.add(toCard('A', 'H'));
+        s.tab2.add(toCard('5', 'D'));
+
+        Integer preSize = s.tab1.size();
+        s.pull("AH"); //main method tested
+        Integer postSize = s.tab1.size();
+
+        Integer actual = preSize - postSize;
+        Integer expected = 1;
+
+        Assert.assertEquals(expected, actual);
+    }
 
     @Test
     public void drawCard() {
@@ -74,7 +74,8 @@ public class SolitaireTest {
     }
 
     @Test
-    public void testCoverage() {
+    public void testCardCoverage() {
+        //whether top card on each tab is uncovered
         s.resetDeck();
         s.deal();
         int i = 0;
@@ -93,7 +94,53 @@ public class SolitaireTest {
     }
 
     @Test
-    public void testStartGame() {
-        s.start();
+    public void testPull(){
+        s.resetDeck();
+        s.deal();
+        Card expected = s.tab1.stack.peek();
+        s.pull("KC");
+        Card actual = s.tempStack.peek();
+        Assert.assertEquals(expected,actual);
+    }
+
+    @Test
+    public void testPlace(){
+        s.resetDeck();
+        s.deal();
+        Card expected = s.tab1.stack.peek();
+        s.pull("KC");
+        s.tab2.add(s.tempStack.pop());
+        Card actual = s.tab2.stack.peek();
+        s.print();
+        Assert.assertEquals(expected,actual);
+        s.tempStack.removeAllElements();
+    }
+
+    @Test
+    public void testShuffle(){
+        s.resetDeck();
+        Card actual = s.solitaireDeck.deckOfCards.peek();
+        s.shuffle();
+        Card expected = s.solitaireDeck.deckOfCards.peek();
+        Assert.assertNotEquals(expected,actual);
+    }
+
+    @Test
+    public void peekWaste(){
+        s.resetDeck();
+        Card actual = s.solitaireDeck.deckOfCards.peek();
+        s.drawCard();
+        Card expected = s.wastePile.peek();
+        Assert.assertEquals(expected,actual);
+    }
+
+    @Test
+    public void resetDeck(){
+        s.resetDeck();
+        Card actual = s.solitaireDeck.deckOfCards.peek();
+        s.shuffle();
+        s.resetDeck();
+        Card expected = s.solitaireDeck.deckOfCards.peek();
+        Assert.assertEquals(expected,actual);
     }
 }