Constructor problem.

[Richard Goodwinn]

Hi,
I am working on a solitaire game called Calculation.

The Foundation class provides the methods to manage and display the foundation of the Calculation game. Since the foundation contains four rows of cards, it is natural for the Foundation class to have a field that is an array of four "somethings", where each "something" represents a row of the foundation. So what I have to do is create a FoundationRow class to handle all the logic associated with one row of the foundation. Then later on when I create the Foundation class, it will have an array of four objects of the type FoundationRow.

Anyway, Im trying to write a constructor for class called FoundationRow.

public FoundationRow(int startNumber, Deck deck)

Parameters:
startNumber - the pip count for the first card in the row, which is also the difference in pip values for adjacent cards in this row. This must be a value in the range 1-4 inclusive.

deck - the deck of cards from which the first card whose pip count equals startNumber is extracted as the first card in the row. When the constructor returns, the number of cards in the deck will be one less than where it was called due to the removal of this card. It may be assumed that the gicen deck contains such a card.


The constructor should set up an array of 13 cards in which the first element is the first card in the given deck of the required pip number.

In the game calculation, a card's suit is irrelevant, only the pip count (1-13) is relevant. The game starts with a shuffled deck of cards from which an ace, two, three and four have been extracted. These four extracted cards form the start of four foundation rows. The goal of the game is to build up each foundation row from its start card through to a king. A card can only be added to a foundation row only in the first free position and only if its "pip value" differs from the card to its left by the pip value of the left-most card in the row.
Thus the first row takes cards A,2,3,4..., the second row takes 2,4,6,8,10,Q,A,3... , the third row takes 3,6,9,Q,2,5,8... and the fourth row takes 4,8,Q,3,7,J...

I am having trouble implementing the Constructor as I do not know how to write the code for the Constructors parameters.

Any suggestions?

Here is the code for FoundationRow, with my attempt to write the constructor. (I gave the methods "stub" implementations, so the unit test would be able to compile).

/**
 * A FoundationRow is a single row in a foundation. It has a start card,
 * which determines the step size in number of pips between cards in a row.
 */
public class FoundationRow
{
    private Deck deck;
    private Card[][] rows; 
    
    /**
     *Constructor for objects of class FoundationRow that will not be
     *displayed graphically.  When the constructor returns,the number of cards in the deck will be one less than when it was called due to the removal of 
     *this card.It may be assumed that the given deck contains such a card.
     *@param startNumber the pip count for the first card in the row, which is also the difference in pip values for adjacent cards
     *in this row.  This must be value in the range 1-4 inclusive.
     *@param deck the deck of cards from which the first card whose pip count equals startNumber is extracted as first card in the
     *row.
     */
 
    public FoundationRow(int startNumber, Deck deck)
    {     
      deck = this.deck;
      rows = new Card[4][13]; 
      for(int i=0;i<4;++i){
         rows[i][0] = deck.nextCard(); 
        }
    }
    
    /**
     *An array of 13 elements, each of which is either a Card or null.  If the row contains n (1-13 inclusive) cards,
     *element 0...n-1 will be the cards, and elements n onwards will all be null.  This is just a getter method for the
     *array of cards in this foundation row.
     *@return an array of 13 elements,with the first n being the cards in this row and the remaining 13-n being null,
     *when n is the number of cards currently in this row.
     */     
    public Card[] getCards()
    {
      return null;  
    }
 
    /**
    * Add (or attempt to add) the given card to this row.  Returns true if the add is successful,i.e.,the difference between
    * the number of pips on this card and the number of pips on the card currently at the end of the row is equal to the 
    * number of pips on the card at the start of the row.  If the parameter is null,the method returns false
    * @param card the card to be add to the row, if possible.
    * @return true if and only if the add succeeds.
    */       
    public boolean putCard(Card card)
    {
      return true;
    }
 
    /**
    * A string representation of the object.  This is the string representations of each card in the row, separated by single space.
    * There are no spaces at the start or end of the row -- only between the individual cards.
    * @overrides toString in class java.lang.Object
    */    
    public String toString()
    {
      return "";  
    }
 
}

That compiles fine, but the Constructor doesn't pass the unit test. Can anyone see what Ive done wrong?

Here is the class Deck code in case its useful

import java.util.*;
import java.awt.*;
 
    /**
     * * A full deck of cards. It is shuffled when first constructed
     * * * and thereafter cards are removed from the deck by calls to 
     * * * * nextCard until no further cards remain. Cards can also be
     * * * * * placed back on the deck at either the start or the end.
     * * * * * */
public class Deck
{
    private java.util.List<Card> cards;      // The list of cards
    private static java.util.Random generator = null;
    
    /**
     * Constructor for a shuffled deck of cards.
     * @param seed the seed for the random number generator used to
     * shuffle the deck. A different unique shuffle is obtained for
     * each possible value of seed.
     */
    public Deck(long seed)
    {
        // Create a deck of cards in sorted order of suit then pip count.
        
        cards = new ArrayList<Card>();
        for (int suit = Card.SPADES; suit <= Card.CLUBS; suit++) {
            for (int pips = 1; pips <= Card.CARDS_IN_SUIT; pips++) {
                cards.add(new Card(suit, pips));
            }
        }
        
        // Now shuffle the deck, using a random number generator based
        // on the seed value given as a parameter.
        
        java.util.Random generator = new java.util.Random(seed); 
        java.util.Collections.shuffle(cards, generator);
    }
     
    /**
     * The number of cards still remaining in the deck.
     * @return the number of cards left in the deck.
     */
    public int numCardsRemaining()
    {
        return cards.size();
    }
    
    /**
     * Get the next card from the deck, reducing the number of cards
     * remaining in the deck by one.
     * @return the "top" card in the deck
     */
    public Card nextCard()
    {
        return cards.remove(0);
    }
    
    /**
     * Add the given card to the start (front) of the current deck.
     * @param card the card to be placed at the start of the deck
     */
    public void addAtStart(Card card)
    {
        cards.add(0, card);
    }
    
    /**
     * Add the given card to the end (back) of the current deck.
     * @param card the card to be placed on the end of the deck
     */
    public void addAtEnd(Card card)
    {
        cards.add(card);
    }
}

Thanks for any help

[ May 17, 2006: Message edited by: Richard Goodwinn ]
[ May 17, 2006: Message edited by: Richard Goodwinn ]

[Edwin Keeton]

How about changing the first assignment in your constructor to this:

this.deck = deck;
   

[Richard Goodwinn]

Oops, thanks. Didn't realise I had that around the wrong way.

Still doesn't pass the unit test though

[Garrett Rowe]

What is the code of the unit test that is not passing?

[Richard Goodwinn]

public class FoundationRowTest extends junit.framework.TestCase
{
    private Deck twoCardDeck;
    private Card ace;
    private Card three;
    
    /**
     * Default constructor for test class FoundationRowTest
     */
    public FoundationRowTest()
    {
    }
    
    /**
     * Test the constructor and the getCards methods together.
     */
    public void testConstructor1()
    {
        // Construct a new row and check it has the right values in it
        FoundationRow testRow = new FoundationRow(1, twoCardDeck);
        Card[] cards = testRow.getCards();
        assertEquals(13, cards.length);
        assertEquals(ace, cards[0]);
        for (int i = 1; i < 13; i++) {
            assertEquals(null, cards[i]);
        }
        
        // Check that the ace has been removed from the deck, leaving
        // only the three.
        assertEquals(1, twoCardDeck.numCardsRemaining());
        assertEquals(three, twoCardDeck.nextCard());
    }
        
    /**
     * Test the constructor and the getCards methods together, take 2!
     * This is the same as testConstructor1 except that it starts
     * the row with the value 3.
     */
    public void testConstructor2()
    {
         // Construct a new row and check it has the right values in it
        FoundationRow testRow = new FoundationRow(3, twoCardDeck);
        Card[] cards = testRow.getCards();
        assertEquals(13, cards.length);
        assertEquals(three, cards[0]);
        for (int i = 1; i < 13; i++) {
            assertEquals(null, cards[i]);
        }
        
        // Check that the ace has been removed from the deck, leaving
        // only the three.
        assertEquals(1, twoCardDeck.numCardsRemaining());
        assertEquals(ace, twoCardDeck.nextCard());
    } 
    
    /**
     * Test that the order of cards in the deck is not altered by
     * the construction of a new FoundationRow, except for the removal
     * of the start card.
     */
    public void testConstructor3()
    {
        Deck deck1 = new Deck(1);  // Deck to use in constructing row
        Deck deck2 = new Deck(1);  // A copy of that deck
        FoundationRow testRow = new FoundationRow(3, deck1);
        assertEquals(51, deck1.numCardsRemaining());
        boolean found = false;  // True when we've found the first occurrence of a 3
        
        // Go through both the deck used in constructing the new row
        // and the copy deck, checking that we get the same cards except for the
        // first card with a pip count of three (which should have been removed).
        while (deck2.numCardsRemaining() > 0) {
            Card c2 = deck2.nextCard();  // Card from our copy deck
            if (c2.getNumber() == 3 && !found) {
                found = true;
            }
            else {
                Card c1 = deck1.nextCard();  // Card from deck used in constructing row
                assertEquals(c2.getNumber(), c1.getNumber());
                assertEquals(c2.getSuit(), c1.getSuit());
            }
        }
        assertEquals(0, deck1.numCardsRemaining());
    }
    
   /**
     * Test the putCard method for a row starting with an ace.
     */
    public void testPutCard1()
    {
        FoundationRow row = new FoundationRow(1, twoCardDeck);
        Card twoOfClubs = new Card(Card.CLUBS, 2);
        boolean ok = row.putCard(twoOfClubs);
        assertEquals(true, ok);
        Card[] cards = row.getCards();
        assertEquals(13, cards.length);
        assertEquals(ace, cards[0]); // Make sure the first card didn't get clobbered
        assertEquals(twoOfClubs, cards[1]);  // The second should be the two
        assertEquals(null, cards[2]);  // Make sure the third is still null
        
        // Now try adding an illegal card
        
        Card fourOfHearts = new Card(Card.HEARTS, 4);
        ok = row.putCard(fourOfHearts);
        assertEquals(false, ok);
        cards = row.getCards();
        assertEquals(ace, cards[0]);
        assertEquals(twoOfClubs, cards[1]);
        assertEquals(null, cards[2]);
    }
    
    /**
     * Test the putCard method, this time for a row starting with a three.
     */
    public void testPutCard2()
    {
        FoundationRow row = new FoundationRow(3, twoCardDeck);
        Card sixOfClubs = new Card(Card.CLUBS, 6);
        boolean ok = row.putCard(sixOfClubs);
        assertEquals(true, ok);
        Card[] cards = row.getCards();
        assertEquals(13, cards.length);
        assertEquals(three, cards[0]); // Make sure the first card didn't get clobbered
        assertEquals(sixOfClubs, cards[1]);  // The second should be the six
        assertEquals(null, cards[2]);  // Make sure the third is still null
        
        // Now try adding an illegal card
        
        Card fourOfHearts = new Card(Card.HEARTS, 4);
        ok = row.putCard(fourOfHearts);
        assertEquals(false, ok);
        cards = row.getCards();
        assertEquals(three, cards[0]);
        assertEquals(sixOfClubs, cards[1]);
        assertEquals(null, cards[2]);
    }
    
    /**
     * Test that the putCard method, repeatedly applied to a row starting
     * with a three, allows us to fill up the whole row.
     */
    public void testPutCard3()
    {
        FoundationRow row = new FoundationRow(3, twoCardDeck);
        int[] numsToAdd = {6, 9, 12, 2, 5, 8, 11, 1, 4, 7, 10, 13};
        for (int i = 0; i < numsToAdd.length; i++) {
            Card card = new Card(Card.CLUBS, numsToAdd[i]); // A card of reqd pip value
            assertEquals(true, row.putCard(card));
        }
        
        // Now check that the row contains the right sequence of cards.
        
        Card[] cards = row.getCards();
        assertEquals(13, cards.length);
        assertEquals(cards[0], three);  // Check the first card
        for (int i = 1; i < 13; i++) {  // Check all the others
            assertNotNull(cards[i]);
            assertEquals(numsToAdd[i-1], cards[i].getNumber());
        }
    }
    
    /**
     * Test the toString method. Test on a row created with 
     * a single ace, then after adding a 2 and again after adding
     * a three.
     */
    public void testToString()
    {
        FoundationRow row = new FoundationRow(1, twoCardDeck);
        assertEquals("SA", row.toString()); // Should be just the ace of spades
        assertEquals(true, row.putCard(new Card(Card.CLUBS, 2)));
        assertEquals("SA C2", row.toString());
        assertEquals(true, row.putCard(new Card(Card.HEARTS, 3)));
        assertEquals("SA C2 H3", row.toString());
    }
 
    /**
     * Sets up the test fixture.
     *
     * Called before every test case method.
     */
    protected void setUp()
    {
        twoCardDeck = new Deck(1);  // Create a new deck
        for (int i = 0; i < 52; i++) {  // Take out all the cards from it!
            twoCardDeck.nextCard();
        }
        
        // Build a new 2-card deck with the ace of spades at the top and the three
        // of hearts below it.
        
        ace = new Card(Card.SPADES, Card.ACE);
        three = new Card(Card.HEARTS, 3);
        twoCardDeck.addAtStart(ace);
        twoCardDeck.addAtEnd(three);
    }
 
    /**
     * Tears down the test fixture.
     *
     * Called after every test case method.
     */
    protected void tearDown()
    {
    }
}

[Garrett Rowe]

Well testConstructor1() and testConstructor2() won't pass because they depend on the getCards() method being properly implemented, however at the moment getCards() always returns null.

[Richard Goodwinn]

OK, so I need to implement putCards() first?

So the putCard method should add the given card to the end of the current row (i.e., to the next free slot) if and only if the card is non-null and the difference between its pip count and the pip count of the card currently at the end of the row is the right amount for this row. Specifically, the pip-count difference must equal the startNumber parameter passed to the constructor (and hence must also equal the pip count of the first card in the row).
Then theres the problem that I need to deal with the cyclic behaviour of this method, i.e., I need to allow for the fact that after King we "wrap around" again to Ace, 2, 3, ... etc.
I've been thinking for the past couple hours on how I would do that. The best idea Ive come up with is to use the "modulo" operator "%" when checking if a card can legally be added.

Though so far all my attempts at writing code to achieve this feat have proven futile
[ May 17, 2006: Message edited by: Richard Goodwinn ]

[Richard Goodwinn]

public FoundationRow(int startNumber, Deck aDeck)
{
    deck = aDeck;
    rows = new Card[4][13];//initialize global rows object
 
    for(int i=0;i<4;++i){
        rows[i][0] = deck.nextCard(); //add first 4 cards to rows
    }
}

Oops, I think I just realised something.

The FOoundationRow class only deals with the logic of one row. Then I have to create a Foundation class which deals with an array of four FoundationRow arrays.

So wouldn't the constructor code for FoundationRow have something like Card[13] instead of Card[4][13]? (Shouldn't the Foundation class be the one that has Card[4][13]?)

[Richard Goodwinn]

Any suggestions?

I really need to finish this FoundationRow class, but I still cannot get it to pass the tests. My code compiles, but I am very bad with arrays so my code is probably nothing what it should look like

[Garrett Rowe]

Originally posted by Richard Goodwinn:

public FoundationRow(int startNumber, Deck aDeck)
{
    deck = aDeck;
    rows = new Card[4][13];//initialize global rows object
 
    for(int i=0;i<4;++i){
        rows[i][0] = deck.nextCard(); //add first 4 cards to rows
    }
}

Oops, I think I just realised something.

The FOoundationRow class only deals with the logic of one row. Then I have to create a Foundation class which deals with an array of four FoundationRow arrays.

So wouldn't the constructor code for FoundationRow have something like Card[13] instead of Card[4][13]? (Shouldn't the Foundation class be the one that has Card[4][13]?)

The Foundation class probably shouldn't have a Card[4][13] array but instead should have a FoundationRow[] array of length 4.