Solitaire: logic to pull and place on foundation stacks works

pom.xml

     <groupId>io.zipcoder</groupId>
     <artifactId>casino</artifactId>
     <version>1.0-SNAPSHOT</version>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>8</source>
+                    <target>8</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
 
     <dependencies>
         <dependency>

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

 package io.zipcoder.casino.CardGame;
 
+import java.util.Objects;
+
 public class Card {
 
     private Suit suit;
     public Card(Suit suit, Face face){
         this.suit = suit;
         this.face = face;
+        setBlack();
+    }
+
+    public static Card toCard(String face, String suit){
+        return new Card(Suit.valueOf(suit.toUpperCase()), Face.valueOf(face.toUpperCase()));
     }
 
     public Suit getSuit() {
         return isBlack;
     }
 
-    public void setBlack(boolean black) {
-        isBlack = black;
+    private void setBlack(){
+        if(this.getSuit().toString().equals("HEARTS") || this.getSuit().toString().equals("DIAMOND")) isBlack = false;
+        else isBlack = true;
     }
 
     public Face getFace() {
     public String toString(){
         return suit + "-" + face;
     }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Card card = (Card) o;
+        return suit == card.suit &&
+                face == card.face;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(suit, face);
+    }
 }

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

 
 public class Deck {
 
-    public Stack<Card> deckOfCards = new Stack<Card>();
+    public Stack<Card> deckOfCards = new Stack<>();
 
     public void shuffle(){
         Collections.shuffle(deckOfCards);

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

     private Face(int value) {
         this.value = value;
     }
+
+    public int getValue(){
+        return value;
+    }
 }

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

 
 import io.zipcoder.casino.CardGame.Card;
 import io.zipcoder.casino.CardGame.CardGame;
+import io.zipcoder.casino.CardGame.Deck;
 import io.zipcoder.casino.Player;
-//
-//public class Solitaire extends CardGame {
-//
-//    private Player player;
-//    private Tableau tableau;
-//    private Foundation foundation;
-//    private java.util.Stack wastepile;
-//
-//
-//    public Solitaire(Player player) {
-//        this.player = player;
-//    }
-//
-//    public void moveable() {
-//    }
-//
-//    public void receivable() {
-//    }
-//
-//    public Card draw() {
-//        return null;
-//    }
-//
-//    public void flip() {
-//        // shoulder technically be card.setCovered(false); or something like that
-//        boolean covered = false;
-//    }
-//
-//}
+
+public class Solitaire extends CardGame {
+
+    private Player player;
+    private Tableau tableau;
+    private Foundation foundation;
+    private java.util.Stack wastepile;
+
+    public static Deck solitaireDeck = new Deck();
+
+
+    public Solitaire(Player player) {
+        this.player = player;
+    }
+
+    public void start(){
+
+    }
+
+    public void end() {
+
+    }
+
+    public void takeATurn() {
+
+    }
+
+    public void addPlayer() {
+
+    }
+
+    public void removePlayer() {
+
+    }
+
+    public void moveable() {
+    }
+
+    public void receivable() {
+    }
+
+    public Card draw() {
+        return solitaireDeck.draw();
+    }
+
+    public void flip() {
+        // shoulder technically be card.setCovered(false); or something like that
+        boolean covered = false;
+    }
+
+}

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

 
 public class Tableau {
 
-    private Stack stack;
+    //consider making an undo method
+
+    public Stack<Card> stack;
+    public static Stack<Card> tempStack;
 
     public Tableau(){
-        this.stack = new Stack<Card>();
+        this.stack = new Stack<>();
+        this.tempStack = new Stack<>();
     }
 
+    public Integer size() { return stack.size(); }
+
+    public void add(Card c){
+        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(stack.contains(c)){
+            while(!stack.peek().equals(c))  tempStack.push(stack.pop());
+            tempStack.push(stack.pop());
+            }
+        return tempStack;
+        }
+
+    //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())){
+//            for(Card c : tempStack){
+//                tempStack.pop();
+//                stack.push(c);
+//            }
+            while(tempStack.iterator().hasNext()){
+                stack.push(tempStack.pop());
+            }
+//           tempStack.forEach(e -> stack.push(tempStack.pop()));
+        }
+    }
+
+    //checks whether 'top' card of stack is opposite color and 1 above passed card
+    private boolean canReceive(Card c) {
+        if ((this.stack.peek().getFace().getValue() - 1) == c.getFace().getValue()
+                && (this.stack.peek().isBlack() != c.isBlack())) {
+            return true;
+        } else {
+            System.out.println("Can't match " + stack.peek().toString() + " and " + c.toString());
+            return false;
+        }
+    }
 }

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

 
     private Suit() {
     }
+
 }

src/test/java/io/zipcoder/casino/CardGame/DeckTest.java

     }
 
     @Test
+    public void testDraw() {
+        String actual = deck.draw().toString();
+        String expected = "CLUBS-KING";
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
     public void testShuffle() {
         deck.shuffle();
         String actual = deck.deckOfCards.get(0).toString();

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

+package io.zipcoder.casino.CardGame.Solitaire;
+
+import io.zipcoder.casino.CardGame.Card;
+import org.junit.Assert;
+import org.junit.Test;
+import sun.tools.jconsole.Tab;
+
+import static io.zipcoder.casino.CardGame.Card.toCard;
+import static io.zipcoder.casino.CardGame.Solitaire.Solitaire.solitaireDeck;
+import static io.zipcoder.casino.CardGame.Solitaire.Tableau.tempStack;
+
+public class TableauTest {
+
+    Tableau stack1 = new Tableau();
+    Tableau stack2 = new Tableau();
+
+    @Test
+    public void addTest() {
+        stack1.add(solitaireDeck.draw());
+        stack1.add(solitaireDeck.draw());
+        stack1.add(solitaireDeck.draw());
+        stack1.add(solitaireDeck.draw());
+
+        Integer actual = stack1.size();
+        Integer expected = 4;
+
+        for(Card c : stack1.stack) System.out.println(c.toString());
+        Assert.assertEquals(expected,actual);
+    }
+
+    @Test
+    public void pullTest() {
+        stack1.add(solitaireDeck.draw());
+        stack1.add(solitaireDeck.draw());
+        stack1.add(solitaireDeck.draw());
+        stack1.add(solitaireDeck.draw());
+
+        stack1.pull(toCard("Queen","Clubs"));
+        Integer actual = tempStack.size();
+        Integer expected = 3;
+
+        for(Card c : stack1.stack) System.out.println(c.toString());
+        Assert.assertEquals(expected,actual);
+    }
+
+    @Test
+    public void placeTest() {
+        stack1.add(solitaireDeck.draw());
+        stack1.add(solitaireDeck.draw());
+        stack1.add(solitaireDeck.draw());
+        stack1.add(solitaireDeck.draw());
+
+        stack2.add(toCard("King","Hearts"));
+        stack1.pull(toCard("Queen","Clubs"));
+        stack2.place();
+        Integer actual = stack2.size();
+        Integer expected = 4;
+
+        for(Card c : stack2.stack) System.out.println("Stack 2 " + c.toString());
+        for(Card c : stack1.stack) System.out.println("Stack 1 " + c.toString());
+        for(Card c : tempStack) System.out.println("tempStack " + c.toString());
+        Assert.assertEquals(expected,actual);
+    }
+
+    @Test
+    public void placeTest2() {
+        stack1.add(solitaireDeck.draw());
+        stack1.add(solitaireDeck.draw());
+        stack1.add(solitaireDeck.draw());
+        stack1.add(solitaireDeck.draw());
+
+        stack2.add(toCard("King","Hearts"));
+        stack1.pull(toCard("JACK","Clubs"));
+        stack2.place();
+        Integer actual = stack2.size();
+        Integer expected = 1;
+
+        for(Card c : stack2.stack) System.out.println("Stack 2 " + c.toString());
+        for(Card c : stack1.stack) System.out.println("Stack 1 " + c.toString());
+        for(Card c : tempStack) System.out.println("tempStack " + c.toString());
+        Assert.assertEquals(expected,actual);
+    }
+}