Computer Science 182 Data Structures and Program Design
Programming Project #3 A Linked List Video Poker Card Game (15 points)


One of the nice things about Java is it is very easy to do fun things with graphics.  The start code provided here will display a deck of cards on the screen and shuffle them.

Your mission, is to start with this code and build a Video card game. Obviously the program you write will not just display all the cards on the screen, it will not reveal the cards until dealt.


The cards you see on the screen will be part of a Linked List. When you deal a hand of cards, you must create your own Linked List of cards and move the dealt card(s) from the deck's linked list to the hands linked list.


Make sure you pay attention to the following guidelines for this project:

Design First: 3 points of this project will be based solely on your design, do it before you start coding this project. Sketch on paper what you want the screen to look like. Draw it at the start of the game (empty card hands), after initial deal and during the game. Draw your linked lists. Draw pictures of what the linked lists will look like. Draw the lists at the start of the game (empty card hand), after initial deal and during the game. Finally write some pseudo code for the deal, the transfer of cards from the deck to the player/computer hand.
Use at least 3 linked lists in your design. For Video Poker it would be a deck, players hand, discard list. Show ALL 3 lists on the screen.
Design upgrades to the Card class for use in scoring. The card class must have member variable(s) that allow you to determine the rank/suit of the card and determine poker hands (pairs, 3 of a kind, flush, straight etc.).
Use the linked lists when displaying cards. When you show cards in a linked list use the following pseudo code to do it:
current card =  list.first

while  (current card is NOT null)
    display current card on the screen
    current card = current card.next

Here are some hints that make this project easier, implement it step by step (or button by button):

Start with the 'New Deck' button. Most of it has been done for you, just need to display the deck across the top row of the screen, rather then over the entire screen. I would display the cards closer together so you can see at least half the card and tell what it is. Don't worry if the end of the deck goes off the right side of the screen, when cards are dealt the deck gets smaller and the cards at the end come in to view. At the start show the cards face up!
The 'Shuffle' button is pretty much done. At the start don't shuffle the cards! It is much easier to debug the linked lists, knowing exactly which cards will be coming off the deck and moving into the hand(s). When the program is working, then start shuffling the cards.
The 'Deal Poker' button. Write the code to have the deal button create a new card list, remove 5 cards from the deck, insert them into the new card list. Have the paintComponent display the new list in the middle row below the deck. In other words, don't start with a full version of poker, write a simple program that creates an empty hand, deals 5 cards from the deck to the hand and displays those 5 cards. Space the cards out, do not overlap them, the 5 cards dealt to the player should clearly be shown as a SEPARATE linked list (hand) from the deck. Each time the 'Deal Poker' button is pressed start a new hand and take 5 MORE cards from the deck. After the first 'Deal Poker' there will be 5 cards in the hand, and 47 left in the deck, after the second 'Deal Poker' there will be 5 new cards in the hand, and 42 left in the deck, and so on. While the user can choose to start a 'New Deck' any time they want, they DO NOT have to until the deck has less than 10 cards left in it. By design 'Deal Poker' can be pressed many times in a row. Display a message in the text box or on the screen to press 'New Deck' and STOP dealing cards when there are less than 10 cards in the deck.
Partial credit warning! Do the steps in order! Turn in the most advanced step you can get working for partial credit. Don't mess with additional steps until the basic 'Deal Poker' is working.
Now turn to the buttons on the bottom of the screen. Draw Poker requires discards or throwing away cards in the hand. You will need 5 discard buttons (add more buttons), and the initial function is quite simple. Toggle the card face up/face down. A card left face up will be kept in the hand and a card face down will be thrown away (discarded). Players often change their mind so the buttons MUST flip the cards back and forth. A player can discard all or none of the cards in the hand.
When the player makes up their mind the 'Draw' button will remove the discards (if any) from the players hand and add them to a third linked list for the discards. New cards MUST be taken from the deck to replace the discards with cards from the deck, restoring the hand to the final 5 cards. It is not a typical feature of Video Poker but show the discards in a third row below the hand just like the deck is shown above the hand. Display the discards closer together so you can see at least half the card and tell what it is. I want you to 'see' the card objects move from the deck linked list, to the hand linked list to the discard linked list.
It is HELPFUL to start the game in cheat mode (show all deck cards face up) when testing the game. It is so much easier to decide what to discard if you can see the deck. And easier to test specific scoring hands (see below) when you know what is coming off the deck. Now you can implement the 'Cheat' button, it simply toggles the deck linked lists face up or face down. If those cards are currently face up press 'Cheat' and they turn face down. Press 'Cheat' again and they toggle face up. The 'Cheat' button has no affect on the cards in the hand linked list or the discard list.
Scoring after 'Draw' is pressed! Do not even think about doing this until the basic game play above is working. Google 'Poker Hands' a low hand contains a pair ( two 4's), moving up there is two pairs (two Jacks, two 6's), three of a kind, etc. A very good hand named a straight flush is easy to test if the cards are NOT shuffled. Report in a clear and obvious message the best poker hand that can be made from the final 5 cards in the hand after the 'Draw' button is pressed.
A player can simply press 'Deal Poker' to start a new game. The final 5 cards in the previous hand should move to the discard list when a new deal occurs. Pressing 'New Deck' is an option, but NOT required until the deck has less than 10 cards. The discard link list should be cleared when 'New Deck' is pressed. It would be nice to start with the buttons on the bottom disabled. Enable the buttons on the bottom AFTER 'Deal Poker' is pressed and disable them again AFTER 'Draw' is pressed. In other words, don't let them use the discard and draw buttons unless a hand is active.
Optional, do NOT attempt unless full game is working. Make it pretty, A green background or a Poker Table graphic below the cards...


You will need to download and unzip the images zip file into the same directory as your project in order to load card images and display them.


Here is the code you should start with.

/***************************************************************
  Project Number 3 - Comp Sci 182 - Data Structures (w/ Swing)
  Start Code - Build your program starting with this code
               Card Game
  Copyright 2005-2016 Christopher C. Ferguson
  This code may only be used with the permission of Christopher C. Ferguson
***************************************************************/
package project3;       // must match your project
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.io.*;

public class Project3 extends JFrame implements ActionListener {

  private static int winxpos=0,winypos=0;      // place window here


  private JButton dealButton, shuffleButton,exitButton, newButton, cheatButton;
  private JButton discard1Button, drawButton;
  private JTextField inputBox;
  private CardList theDeck = null;
  private JPanel northPanel;
  private JPanel southPanel;
  private MyPanel centerPanel;
  private static JFrame myFrame = null;

  ////////////              MAIN      ////////////////////////
  public static void main(String[] args) {
     Project3 tpo = new Project3();
  }

  ////////////            CONSTRUCTOR   /////////////////////
  public Project3 ()
  {
        myFrame = this;                 // need a static variable reference to a JFrame object
        northPanel = new JPanel();
        northPanel.setBackground(Color.white);
        inputBox = new JTextField("5 Card Draw Video Poker",20);
        northPanel.add(inputBox);
        dealButton = new JButton("Deal Poker");
        northPanel.add(dealButton);
        dealButton.addActionListener(this);
        shuffleButton = new JButton("Shuffle");
        northPanel.add(shuffleButton);
        shuffleButton.addActionListener(this);
        newButton = new JButton("New Deck");
        northPanel.add(newButton);
        newButton.addActionListener(this);
        cheatButton = new JButton("Cheat");
        northPanel.add(cheatButton);
        cheatButton.addActionListener(this);
        exitButton = new JButton("Exit");
        northPanel.add(exitButton);
        exitButton.addActionListener(this);
        getContentPane().add("North",northPanel);

        southPanel = new JPanel();
        southPanel.setBackground(Color.white);
        discard1Button = new JButton("Discard 1");
        southPanel.add(discard1Button);
        discard1Button.addActionListener(this);
        southPanel.add(new JLabel(" More buttons here?"));
        drawButton = new JButton("Draw");
        southPanel.add(drawButton);
        drawButton.addActionListener(this);
        getContentPane().add("South",southPanel);

        centerPanel = new MyPanel();
        getContentPane().add("Center",centerPanel);

        theDeck = new CardList(52);
		Card.setBackImage(52);

        setSize(800,800);
        setLocation(winxpos,winypos);

		// Exit when the window is closed. i.e. when top right X box pressed
        addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });

        setVisible(true);
   }


  ////////////   BUTTON CLICKS ///////////////////////////
  public void actionPerformed(ActionEvent e) {

      if (e.getSource()== exitButton) {
        dispose(); System.exit(0);
      }
      if (e.getSource()== dealButton) {
        String inputmsg = inputBox.getText();  // note you CAN use this box for input
        inputBox.setText("DEAL 5 Cards from deck");
        repaint();
      }
       if (e.getSource()== shuffleButton) {
        String inputmsg = inputBox.getText();
        inputBox.setText("Shuffle");
        theDeck.shuffle();
        repaint();
      }
       if (e.getSource()== cheatButton) {
        inputBox.setText("Turn Cheat ON/OFF (show/hide)");
        Card current = theDeck.getFirstCard();
        current.setShowHide();
        repaint();
      }
       if (e.getSource()== newButton) {
        inputBox.setText("New Deck");
        theDeck = new CardList(52);
        repaint();
      }
  }


// This routine will load an image into memory
//
public static Image load_picture(String fname)
{
        // Create a MediaTracker to inform us when the image has
        // been completely loaded.
        Image image;
        MediaTracker tracker = new MediaTracker(myFrame);


        // getImage() returns immediately.  The image is not
        // actually loaded until it is first used.  We use a
        // MediaTracker to make sure the image is loaded
        // before we try to display it.

        image = myFrame.getToolkit().getImage(fname);

        // Add the image to the MediaTracker so that we can wait
        // for it.
        tracker.addImage(image, 0);
        try { tracker.waitForID(0); }
        catch ( InterruptedException e) { System.err.println(e); }

        if (tracker.isErrorID(0)) { image=null;}
        return image;
}
// --------------   end of load_picture ---------------------------

class MyPanel extends JPanel {

 ////////////    PAINT   ////////////////////////////////
  public void paintComponent (Graphics g) {
    //
    int xpos = 25, ypos = 25;
    if (theDeck == null) return;
    g.drawString("This is ALL 52 cards in the Deck!", xpos, ypos-10);
    Card current = theDeck.getFirstCard();
    while (current!=null) {
       Image tempimage = current.getCardImage();
       g.drawImage(tempimage, xpos, ypos, this);
       // note: tempimage member variable must be set BEFORE paint is called
       xpos += 80;
       if (xpos > 700) {
          xpos = 25; ypos += 105;
       }
       current = current.getNextCard();
    } //while
  }
}

}    // End Of class Project3

/*****************************************************************
   Class Link, the base class for a link list of playing cards
   May be placed in a file named Link.java

******************************************************************/
class Link {
  protected Link next;

  public Link getNext() { return next; }
  public void setNext(Link newnext) { next = newnext; }

}  // end class Link

/*****************************************************************
   Class Card, the derived class each card is one object of type Card
   May be placed in a file named Card.java
******************************************************************/

class Card extends Link {
  private static Image backimage = null;   //why static?
  private Image cardimage;                 //why not static?
  private boolean showhide = true;

  public Card (int cardnum) {
    cardimage = Project3.load_picture("images/gbCard" + cardnum + ".gif");
    // code ASSUMES there is an images sub-dir in your project folder
    if (cardimage == null) {
      System.out.println("Error - image failed to load: images/gbCard" + cardnum + ".gif");
      System.exit(-1);
    }

  }
  public Card getNextCard() {
    return (Card)next;
  }
  public Image getCardImage() {
    if (showhide)
		return cardimage;
	else
		return backimage;
  }

  public  void setShowHide() {
    showhide=!showhide;
  }
  public static void setBackImage(int cardnum) {   //why static?
    backimage = Project3.load_picture("images/gbCard" + cardnum + ".gif");
  }
  public static Image getBackImage() {   //why static?
    return backimage;
  }
}  //end class Card

/*****************************************************************
   Class CardList, A Linked list of playing cards
   May be placed in a file named CardList.java

   Note : This class can be used to create a 'hand' of cards
   Just Create another CardList object, and delete cards from
   'theDeck' and insert the into the new CardList object

******************************************************************/

class CardList {
  private Card firstcard = null;
  private int numcards=0;

  public  CardList(int num) {
    numcards = num;   //set numcards in the deck
    for (int i = 0; i < num; i++) {  // load the cards
      Card temp = new Card(i);
      if (firstcard != null) {
        temp.setNext(firstcard);
      }
      firstcard = temp;
    }
  }

  public Card getFirstCard() {
      return firstcard;
  }

  public Card deleteCard(int cardnum) {
    Card target, targetprevious;

    if (cardnum > numcards)
      return null;   // not enough cards to delete that one
    else
      numcards--;

    target = firstcard;
    targetprevious = null;
    while (cardnum-- > 0) {
        targetprevious = target;
        target = target.getNextCard();
        if (target == null) return null;  // error, card not found
    }
    if (targetprevious != null)
      targetprevious.setNext(target.getNextCard());
    else
      firstcard =  target.getNextCard();
    return target;
  }

  public void insertCard(Card target) {
    numcards++;
    if (firstcard != null)
      target.setNext(firstcard);
    else
      target.setNext(null);
    firstcard =  target;
  }

  public void shuffle() {
    for ( int i = 0; i < 300; i++) {
      int rand = (int)(Math.random() * 100) % numcards;
      Card temp = deleteCard(rand);
      if (temp != null) insertCard(temp);
    }  // end for loop
  }   // end shuffle


}    // end class CardList


Here is the image of a card back, it is gbCard52.gif.

Here are 52 card images, they are gbCard0.gif to gbCard51.gif
You can download them individual images with a right click on the image (using the zip file is better):