MERRY CHRISTMAS...........BIOTCH
Printable View
MERRY CHRISTMAS...........BIOTCH
MERRY CHRISTMAS...........BIOTCH
MERRY CHRISTMAS...........BIOTCH
MERRY CHRISTMAS...........BIOTCH
MERRY CHRISTMAS...........BIOTCH
MERRY CHRISTMAS...........BIOTCH
MERRY CHRISTMAS...........BIOTCH
MERRY CHRISTMAS...........BIOTCH
MERRY CHRISTMAS...........BIOTCH
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
public class EvenUpB { //handles the essentials of the even-up game
public static int score = 0; //score is initialized to 0
static Deck tableau = new Deck(); // make a new deck of cards of 52 cards
static Deck hand = new Deck(); // make an empty deck for the hand
static Deck waste = new Deck(); //make an empty dec for wastepile
public static void loadIt(){ //Loads the deck of cards in hand
hand.loadDeck(TestDeck.STACKED); //loads the test deck
hand.shuffle(); //shuffles the deck
tableau.push(hand.pop()); //puts a card from hand into the tableau
}
public static void deckDisplay(Deck deck){ //displays a deck as a row
Deck temp = new Deck(); //new temporary deck
Card toDisplay; //cards to display
if(deck.isEmpty()){ //if deck is empty
System.out.println("--");
}
else
while(!deck.isEmpty()); //while the deck is not empty
temp.push(deck.pop());
while(!deck.isEmpty()){ //while the deck is still not empty
toDisplay = temp.pop(); //cards are the cards popped from the temporary deck
deck.push(toDisplay);
System.out.println(toDisplay.show()+ ""); //display the cards
}
}//deckDisplay
public static void cardDisplay(){ //displays the cards to the user
System.out.print("Hand: " + hand.peek().show()); //prints out the hand deck; looks at the top card and displays it
System.out.print(" Tableau: ");
deckDisplay(tableau);
System.out.println();
System.out.println(" Waste: ");
deckDisplay(waste);
System.out.println(" SCORE: " + score); //displays the score
}//cardDisplay
/*Deals a card*/
public static void dealIt(){ //deals out a new card from hand deck
if(hand.isEmpty()){ //if the hand is empty, displays error message.
System.out.println("************ERROR************* *****");
System.out.println("The hand is empty, cannot deal en empty deck.");
System.out.println("Please load a deck and then deal.");
}
else{
tableau.push(hand.pop()); //takes the top card from hand and puts it in the tableau
}
}//dealIt
}
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
fleeb
neeb
dweeb
schleeb
I should make a new signature.
trust me thats not the last time that paris hilton is gonna find herself in a petstore
nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nubnub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub nub
Yeah.. just made 2 new things for my sig.
Coolll
woo just made a new sig also?
potato smash mmmm
mmmmmmmmmmmmmmmmmmmmmmmmmm Chex Mix....
Bump.
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xml:lang="en" lang="en" xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>GFXVoid Forums -> World Record Thread</title>
<meta http-equiv="content-type" content="text/html; charset=iso-8859-1" />
<style type="text/css">
body
{
background: #FFF;
color: #222;
font-family: Verdana, Tahoma, Arial, Trebuchet MS, Sans-Serif, Georgia, Courier, Times New Roman, Serif;
font-size: 11px;
line-height: 135%;
text-align: center;
}
table,
tr,
td
{
background: transparent;
color: #222;
font-size: 11px;
line-height: 135%;
}
table
{
width: 100%;
}
td,
.divpad
{
padding: 5px;
}
form
{
display: inline;
}
img
{
border: 0;
vertical-align: middle;
}
a:link,
a:visited,
a:active
{
background: transparent;
color: #222;
text-decoration: underline;
}
a:hover
{
background: transparent;
color: #34498B;
}
#ipbwrapper
{
margin: 20px auto 20px auto;
text-align: left;
width: 98%;
}
.pagelink,
.pagelinklast,
.pagecurrent,
.minipagelink,
.minipagelinklast
{
background: #F0F5FA;
border: 1px solid #072A66;
padding: 1px 3px 1px 3px;
}
.pagelinklast,
.minipagelinklast
{
background: #DCDCDC;
}
.pagecurrent
{
background: #FFC9A5;
}
.minipagelink,
.minipagelinklast
{
border: 1px solid #C2CFDF;
font-size: 10px;
margin: 0 1px 0 0;
}
.pagelink a:active,
.pagelink a:visited,
.pagelink a:link,
.pagelinklast a:active,
.pagelinklast a:visited,
.pagelinklast a:link,
.pagecurrent a:active,
.pagecurrent a:visited,
.pagecurrent a:link,
.minipagelink a:active,
.minipagelink a:visited,
.minipagelink a:link,
.minipagelinklast a:active,
.minipagelinklast a:visited,
.minipagelinklast a:link
{
text-decoration: none;
}
.fauxbutton
{
background: #BFCDE0;
border: 1px solid #072A66;
font-size: 11px;
font-weight: bold;
padding: 4px;
}
.fauxbutton a:link,
.fauxbutton a:visited,
.fauxbutton a:active
{
color: #222 !important;
text-decoration: none;
}
.forumdesc,
.forumdesc a:link,
.forumdesc a:visited,
.forumdesc a:active
{
background: transparent;
font-size: 10px;
color: #666;
line-height: 135%;
margin: 2px 0 0 0;
}
.searchlite
{
background-color: yellow;
font-weight: bold;
color: red;
}
.activeusers
{
background: #FFF;
border: 1px solid #072A66;
color: #000;
margin: 0px;
padding: 1px;
}
.activeuserposting a:link,
.activeuserposting a:visited,
.activeuserposting a:active,
.activeuserposting
{
font-style: italic;
text-decoration: none;
border-bottom: 1px dotted black;
}
fieldset.search
{
line-height: 150%;
padding: 6px;
}
label
{
cursor: pointer;
}
img.attach
{
background: #808080 url(style_images/1/click2enlarge.gif) no-repeat top right;
border: 1px solid #808080;
margin: 0 2px 0 0;
padding: 11px 2px 2px 2px;
}
.thumbwrap,
.thumbwrapp,
.fullimagewrap
{
border: 1px solid #072A66;
margin: 2px;
}
.thumbwrapp
{
border: 2px solid #660707;
}
.fullimagewrap
{
background: #F5F9FD;
text-align: center;
margin: 5px 0 5px 0;
padding: 5px;
}
.thumbwrap h4,
.thumbwrapp h4
{
background: #DDE6F2;
border: 0 !important;
border-bottom: 1px solid #000000 !important;
color: #000000;
font-size: 12px;
font-weight: bold;
padding: 5px;
}
.thumbwrap p,
.thumbwrapp p
{
background: #EEF2F7 !important;
border: 0 !important;
border-top: 1px solid #000000 !important;
margin: 0 !important;
padding: 5px !important;
text-align: left;
}
.thumbwrap p.alt,
.thumbwrapp p.alt
{
background: #DCDCDC !important;
margin: 0 !important;
padding: 5px !important;
text-align: left;
}
.thumbwrapp p.pin
{
background: #EFDFDF !important;
text-align: center !important;
}
.thumbwrap img.galattach,
.thumbwrapp img.galattach
{
background: #FFF url(style_images/1/img_larger.gif) no-repeat bottom right;
border: 1px solid #072A66;
margin: 5px;
padding: 2px 2px 10px 2px;
}
li.helprow
{
margin: 0 0 10px 0;
}
ul#help
{
padding: 0 0 0 15px;
}
.warngood,
.warnbad
{
color: #0B9500;
font-weight: bold;
}
.warnbad
{
color: #DD0000;
}
#padandcenter
{
margin: 0 auto 0 auto;
padding: 14px 0 14px 0;
text-align: center;
}
#profilename
{
font-size: 28px;
font-weight: bold;
}
#photowrap
{
padding: 6px;
}
#phototitle
{
border-bottom: 1px solid #000;
font-size: 24px;
}
#photoimg
{
margin: 15px 0 0 0;
text-align: center;
}
#ucpmenu,
#ucpcontent
{
background: #F5F9FD;
border: 1px solid #345487;
line-height: 150%;
}
#ucpmenu p
{
padding: 2px 5px 6px 9px;
}
#ucpmenu a:link,
#ucpmenu a:active,
#ucpmenu a:visited
{
text-decoration: none;
}
#ucpcontent
{
width: auto;
}
#ucpcontent p
{
padding: 10px;
}
.activeuserstrip
{
background: #BCD0ED;
padding: 6px;
}
.signature
{
background: transparent;
color: #339;
font-size: 10px;
line-height: 150%;
}
.postdetails
{
font-size: 10px;
line-height: 140%;
}
.postcolor
{
font-size: 12px;
line-height: 160%;
}
.normalname
{
color: #003;
font-size: 12px;
font-weight: bold;
}
.normalname a:link,
.normalname a:visited,
.normalname a:active
{
font-size: 12px;
}
.post1,
.bg1
{
background: #F5F9FD;
}
.post2,
.bg3
{
background: #EEF2F7;
}
.row2shaded,
.post1shaded
{
background-color: #DEDBE4;
}
.row4shaded,
.post2shaded
{
background-color: #E3DFE7;
}
.row1
{
background: #F1F1F1;
background-color: #F1F1F1;
}
.row2
{
background: #EBEBEB;
background-color: #EBEBEB;
}
.darkrow1
{
background: url(style_images/1/tile_sub.gif);
color: #3A4F6C;
}
.darkrow3
{
background: url(style_images/1/tile_sub.gif);
color: #3A4F6C;
}
.plainborder,
.tablefill,
.tablepad
{
background: #F5F9FD;
border: 1px solid #345487;
}
.tablefill,
.tablepad
{
padding: 6px;
}
.tablepad
{
border: 0 !important;
}
.wrapmini
{
float: left;
line-height: 1.5em;
width: 25%;
}
.pagelinks
{
float: left;
line-height: 1.2em;
width: 35%;
}
.desc
{
font-size: 11px;
color: #434951;
}
.lastaction
{
font-size: 10px;
color: #434951;
}
.edit
{
font-size: 9px;
}
.thin
{
border: 1px solid #FFF;
line-height: 150%;
margin: 2px 0 2px 0;
padding: 6px 0 6px 0;
}
.calmonths
{
background: #F0F5FA;
border: 1px solid #C2CFDF;
font-size: 18px;
font-weight: bold;
margin: 5px 0 5px 0;
padding: 8px;
text-align: center;
}
.weekday
{
font-size: 14px;
font-weight: bold;
}
.calmonths a
{
text-decoration: none;
}
.calday,
.calweekday
{
background: #DCDCDC;
color: #666;
font-size: 11px;
font-weight: bold;
padding: 4px;
text-align: right;
}
.calweekday
{
border-right: 1px solid #AAA;
color: #222;
font-size: 14px;
padding: 6px;
text-align: center;
}
.cellblank,
.celldate,
.celltoday,
.mcellblank,
.mcelldate,
.mcelltoday
{
background: #EEF2F7;
height: 100px;
vertical-align: top;
}
.mcellblank,
.mcelldate,
.mcelltoday
{
height: auto;
}
.cellblank,
.mcellblank
{
background: #C2CFDF;
}
.celltoday,
.mcelltoday
{
border: 2px solid #8B0000;
}
input,
textarea,
select
{
background: #FFF;
border: 1px solid #4C77B6;
color: #000;
font-family: verdana, helvetica, sans-serif;
font-size: 11px;
margin: 5px;
padding: 2px;
vertical-align: middle;
}
select
{
font-family: verdana, helvetica, sans-serif;
font-size: 12px;
}
input.button
{
width: auto;
}
optgroup option
{
font-family: verdana, helvetica, sans-serif;
font-size: 12px;
}
.codebuttons
{
font-family: Verdana, Helvetica, Sans-Serif;
font-size: 10px;
vertical-align: middle;
margin: 2px;
}
.textarea,
.searchinput,
.button,
.gobutton
{
background: #FFF;
border: 1px solid #4C77B6;
color: #000;
font-family: Verdana, Helvetica, Sans-Serif;
font-size: 11px;
padding: 2px;
vertical-align: middle;
}
.button
{
background: #DCDCDC;
}
.gobutton
{
background: transparent;
color: #072A66;
vertical-align: middle;
}
.radiobutton,
.checkbox,
.helpbox
{
vertical-align: middle;
}
.formtable
{
background: transparent;
}
.formtable td,
.pformleft,
.pformleftw,
.pformright
{
background: #F5F9FD;
border: 1px solid #C2CFDF;
font-weight: bold;
margin: 1px 0 0 0;
padding: 6px;
width: 25%;
}
.formtable td.wider,
.pformleftw,
.pformright
{
width: 40%;
}
.formtable td.formright,
.pformright
{
font-weight: normal;
width: auto;
}
.formtable td.formtitle,
.formsubtitle
{
background: #EBEBEB;
border: 1px solid #969696;
font-weight: normal;
}
.formsubtitle
{
color: #3A4F6C;
font-weight: bold;
padding: 5px;
}
.formtable td.formstrip
{
background: #DDE8F2;
border: 1px solid #969696;
font-weight: normal;
}
.quotetop
{
background: #9A9A9A url(style_images/1/css_img_quote.gif) no-repeat right;
border: 1px dotted #000;
border-left: 4px solid #DCDCDC;
color: #000;
font-weight: bold;
font-size: 10px;
margin: 8px auto 0 auto;
padding: 3px;
}
.quotemain
{
background: #FAFCFE;
border: 1px dotted #000;
border-left: 4px solid #DCDCDC;
color: #465584;
padding: 4px;
margin: 0 auto 8px auto;
}
.codetop,
.sqltop,
.htmltop
{
background: #FDDBCC url(style_images/1/css_img_code.gif) no-repeat right;
color: #000;
font-weight: bold;
margin: 0 auto 0 auto;
padding: 3px;
width: 98%;
}
.codemain,
.sqlmain,
.htmlmain
{
background: #FAFCFE;
border: 1px dotted #000;
color: #465584;
font-family: Courier, Courier New, Verdana, Arial;
margin: 0 auto 0 auto;
padding: 2px;
width: 98%;
}
#QUOTE,
#CODE
{
background: #FAFCFE;
border: 1px solid #000;
color: #465584;
font-family: Verdana, Arial;
font-size: 11px;
padding: 2px;
white-space: normal;
}
#CODE
{
font-family: Courier, Courier New, Verdana, Arial;
}
.cleared
{
clear: both;
}
.borderwrap,
.borderwrapm
{
background: #FFF;
border: 1px solid #072A66;
}
.borderwrapm
{
margin: 5px;
}
.borderwrap h3,
.maintitle,
.maintitlecollapse
{
background: transparent url(style_images/1/tile_cat.gif);
border: 1px solid #FFF;
border-bottom: 1px solid #000000;
color: #000;
font-size: 12px;
font-weight: bold;
padding: 8px;
}
.maintitlecollapse
{
border: 1px solid #FFF;
}
.maintitle p,
.maintitlecollapse p,
.formsubtitle p
{
background: transparent !important;
border: 0 !important;
margin: 0 !important;
padding: 0 !important;
}
.maintitle p.expand,
.maintitle p.goto,
.maintitlecollapse p.expand,
.formsubtitle p.members
{
float: right;
width: auto !important;
}
.maintitle a:link,
.maintitle a:visited,
.maintitlecollapse a:link,
.maintitlecollapse a:visited
{
background: transparent;
color: #000;
text-decoration: none;
}
.maintitle a:hover,
.maintitle a:active,
.maintitlecollapse a:hover,
.maintitlecollapse a:active
{
background: transparent;
color: #111;
}
table th,
.borderwrap table th,
.subtitle,
.subtitlediv,
.postlinksbar
{
background: transparent url(style_images/1/tile_sub.gif);
border-bottom: 1px solid #000000;
color: #3A4F6C;
font-size: 10px;
font-weight: bold;
letter-spacing: 1px;
padding: 5px;
}
.subtitlediv
{
border: 1px solid #FFF;
border-bottom: 1px solid #000000;
text-align: right;
}
.borderwrap table th a:link,
.subtitle a:link,
.subtitlediv a:link,
.borderwrap table th a:visited,
.subtitle a:visited,
.subtitlediv a:visited,
MWUAHAHH
^
|
|
|
/\
Part of the source for this page :S
my source is so big it cant fit it all in : /
***************Fatal error: Allowed memory size of 8388608 bytes exhausted (tried to allocate 265258 bytes) in /home/gfxvoid/forums/sources/classes/class_display.php on line 276***********************
yea i didn't post all of it rofl ! :D
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
Bump
D:
OWN IT UP.
