HELP... How can i implement this into my code

Question

Hello :) I'm writing a simple game here is the code now all it does right now is it writes out the values of the cards on the screen in an applet however I want it to display card images from http://www.waste.org/~oxymoron/cards
i can't get it to use the string values and give me the card images instead of simple text... please help a woman in trouble ;O) thank you
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.*;
//import java.applet.*;
///import java.util.*;
public class HighLowGUI extends JApplet {
   public void init() {
         // The init() method lays out the applet.
         // A HighLowCanvas occupies the CENTER position of the layout.
         // On the bottom is a panel that holds three buttons.  The
         // HighLowCanvas object listens for ActionEvents from the
         // buttons and does all the real work of the program.
      setBackground( new Color(130,50,40) );
      HighLowCanvas board = new HighLowCanvas();
      getContentPane().add(board, BorderLayout.CENTER);
      JPanel buttonPanel = new JPanel();
      buttonPanel.setBackground( new Color(220,200,180) );
      getContentPane().add(buttonPanel, BorderLayout.SOUTH);
      JButton higher = new JButton( "Deal" );
      higher.addActionListener(board);
      buttonPanel.add(higher);
      JButton newGame = new JButton( "New Game" );
      newGame.addActionListener(board);
      buttonPanel.add(newGame);
   }  // end init()
   class HighLowCanvas extends JPanel implements ActionListener {
        // A nested class that displays the cards and does all the work
         // of keeping track of the state and responding to user events.
      Deck deck;       // A deck of cards to be used in the game.
      Hand hand;       // The cards that have been dealt.
      String message;  // A message drawn on the canvas, which changes
                       //    to reflect the state of the game.
      boolean gameInProgress;  // Set to true when a game begins and to false
                               //   when the game ends.
      Font bigFont;      // Font that will be used to display the message.
      Font smallFont;    // Font that will be used to draw the cards.
      HighLowCanvas() {
            // Constructor.  Creates sets the foreground and
            // background colors, and starts the first game.
      setBackground( new Color(0,120,0) );
         setForeground( Color.yellow);
                 //  smallFont = new Font("SansSerif", Font.PLAIN, 12);
                  // bigFont = new Font("Serif", Font.BOLD, 14);
        doNewGame();
      } // end constructor
      public void actionPerformed(ActionEvent evt) {
             // Respond when the user clicks on a button by calling
             // the appropriate procedure.  Note that the canvas is
             // registered as a listener in applet's init() method.
         String command = evt.getActionCommand();
         if (command.equals("Deal"))
            doDeal();
         else if (command.equals("New Game"))
            doNewGame();
      } // end actionPerformed()
      void doDeal() {
               // Called by actionPerformmed() when user clicks "Higher" button.
               // Check the user's prediction.  Game ends if user guessed
               // wrong or if the user has made three correct predictions.
         if (gameInProgress == false) {
               // If the game has ended, it was an error to click "Higher",
               // So set up an error message and abort processing.
            message = "Click \"New Game\" to start a new game!";
            repaint();
            return;
         hand.addCard( deck.dealCard() );     // Deal a card to the hand.
         int cardCt = hand.getCardCount();
         Card thisCard = hand.getCard( cardCt - 1 );  // Card just dealt.
         Card prevCard = hand.getCard( cardCt - 2 );  // The previous card.
         if ( thisCard.getValue() < prevCard.getValue() ) {
            gameInProgress = false;
            message = "Too bad! You lose.";
         else if ( thisCard.getValue() == prevCard.getValue() ) {
            gameInProgress = false;
            message = "Too bad!  You lose"; // on ties
         else if ( cardCt == 4) {    //CHANGED+++++++++++++++++=
            gameInProgress = false;
           message = "You win! Hurra! ";
         else {
            message = "Got it right!  Try for " + cardCt + " Press  -Deal- ";
         repaint();
      } // end
      void doNewGame() {
             // Called by the constructor, and called by actionPerformed() if
             // the use clicks the "New Game" button.  Start a new game.
         if (gameInProgress) {
                 // If the current game is not over, it is an error to try
                 // to start a new game.
            message = "You still have to finish this game! Press   -Deal-";
            repaint();
            return;
         deck = new Deck();   // Create the deck and hand to use for this game.
         hand = new Hand();
         deck.shuffle();
         hand.addCard( deck.dealCard() );  // Deal the first card into the hand.
         message = "Deal your cards";
         gameInProgress = true;
         repaint();
      } // end doNewGame()
      public void paintComponent(Graphics g) {
            // This method draws the message at the bottom of the
            // canvas, and it draws all of the dealt cards spread out
            // across the canvas.  If the game is in progress, an
            // extra card is dealt representing the card to be dealt next.
         super.paintComponent(g);
              g.setFont(bigFont);
              g.drawString(message,10,135);
              g.setFont(smallFont);
         int cardCt = hand.getCardCount();
              for (int i = 0; i < cardCt; i++)
                    drawCard(g, hand.getCard(i), 10 + i * 90, 10);
         if (gameInProgress)
            drawCard(g, null, 10 + cardCt * 90, 10);
      } // end paintComponent()
      void drawCard(Graphics g, Card card, int x, int y) {
              // Draws a card as a 80 by 100 rectangle with
              // upper left corner at (x,y).  The card is drawn
              // in the graphics context g.  If card is null, then
              // a face-down card is drawn.  (The cards are
              // rather primitive.)
         if (card == null) {      // Draw a face-down card
            g.setColor(Color.blue);
            g.fillRect(x,y,80,100);
            g.setColor(Color.white);
            g.drawRect(x+3,y+3,73,93);
            g.drawRect(x+4,y+4,71,91);
         else {
            g.setColor(Color.white);
            g.fillRect(x,y,80,100);
            g.setColor(Color.gray);
            g.drawRect(x,y,79,99);
            g.drawRect(x+1,y+1,77,97);
         if (card.getSuit() == Card.DIAMONDS || card.getSuit() == Card.HEARTS)
            g.setColor(Color.red);
         else
            g.setColor(Color.black);
            g.drawString(card.getValueAsString(), x + 10, y + 30);
            g.drawString("of", x+ 10, y + 50);
            g.drawString(card.getSuitAsString(), x + 10, y + 70);
      } // end drawCard()
   } // end nested class HighLowCanvas
} // end class HighLowGUI
   An object of class card represents one of the 52 cards in a
   standard deck of playing cards.  Each card has a suit and
   a value.
public class Card {
    public final static int SPADES = 0,       // Codes for the 4 suits.
                            HEARTS = 1,
                            DIAMONDS = 2,
                            CLUBS = 3;
    public final static int ACE = 1,          // Codes for the non-numeric cards.
                            JACK = 11,        //   Cards 2 through 10 have their
                            QUEEN = 12,       //   numerical values for their codes.
                            KING = 13;
    private final int suit;   // The suit of this card, one of the constants
                              //    SPADES, HEARTS, DIAMONDS, CLUBS.
    private final int value;  // The value of this card, from 1 to 11.
    public Card(int theValue, int theSuit) {
            // Construct a card with the specified value and suit.
            // Value must be between 1 and 13.  Suit must be between
            // 0 and 3.  If the parameters are outside these ranges,
            // the constructed card object will be invalid.
        value = theValue;
        suit = theSuit;
    public int getSuit() {
            // Return the int that codes for this card's suit.
        return suit;
    public int getValue() {
            // Return the int that codes for this card's value.
        return value;
    public String getSuitAsString() {
            // Return a String representing the card's suit.
            // (If the card's suit is invalid, "??" is returned.)
        switch ( suit ) {
           case SPADES:   return "Spades";
           case HEARTS:   return "Hearts";
           case DIAMONDS: return "Diamonds";
           case CLUBS:    return "Clubs";
           default:       return "??";
    public String getValueAsString() {
            // Return a String representing the card's value.
            // If the card's value is invalid, "??" is returned.
        switch ( value ) {
           case 1:   return "A";
           case 2:   return "2";
           case 3:   return "3";
           case 4:   return "4";
           case 5:   return "5";
           case 6:   return "6";
           case 7:   return "7";
           case 8:   return "8";
           case 9:   return "9";
           case 10:  return "10";
           case 11:  return "J";
           case 12:  return "Q";
           case 13:  return "K";
           default:  return "??";
    public String toString() {
           // Return a String representation of this card, such as
           // "10 of Hearts" or "Queen of Spades".
        return getValueAsString() + " of " + getSuitAsString();
} // end class Card
    An object of type Deck represents an ordinary deck of 52 playing cards.
    The deck can be shuffled, and cards can be dealt from the deck.
public class Deck {
    private Card[] deck;   // An array of 52 Cards, representing the deck.
    private int cardsUsed; // How many cards have been dealt from the deck.
    public Deck() {       // Create an unshuffled deck of cards.
       deck = new Card[52];
       int cardCt = 0;    // How many cards have been created so far.
       for ( int suit = 0; suit <= 3; suit++ ) {
          for ( int value = 1; value <= 13; value++ ) {
             deck[cardCt] = new Card(value,suit);
             cardCt++;
       cardsUsed = 0;
    public void shuffle() {
          // Put all the used cards back into the deck, and shuffle it into
          // a random order.
        for ( int i = 51; i > 0; i-- ) {
            int rand = (int)(Math.random()*(i+1));
            Card temp = deck;
deck[i] = deck[rand];
deck[rand] = temp;
cardsUsed = 0;
public int cardsLeft() {
// As cards are dealt from the deck, the number of cards left
// decreases. This function returns the number of cards that
// are still left in the deck.
return 52 - cardsUsed;
public Card dealCard() {
// Deals one card from the deck and returns it.
if (cardsUsed == 52)
shuffle();
cardsUsed++;
return deck[cardsUsed - 1];
} // end class Deck
An object of type Hand represents a hand of cards. The maximum number of
cards in the hand can be specified in the constructor, but by default
is 5. A utility function is provided for computing the value of the
hand in the game of Blackjack.
import java.util.Vector;
public class Hand {
private Vector hand; // The cards in the hand.
public Hand() {
// Create a Hand object that is initially empty.
hand = new Vector();
public void clear() {
// Discard all the cards from the hand.
hand.removeAllElements();
public void addCard(Card c) {
// Add the card c to the hand. c should be non-null. (If c is
// null, nothing is added to the hand.)
if (c != null)
hand.addElement(c);
public void removeCard(Card c) {
// If the specified card is in the hand, it is removed.
hand.removeElement(c);
public void removeCard(int position) {
// If the specified position is a valid position in the hand,
// then the card in that position is removed.
if (position >= 0 && position < hand.size())
hand.removeElementAt(position);
public int getCardCount() {
// Return the number of cards in the hand.
return hand.size();
public Card getCard(int position) {
// Get the card from the hand in given position, where positions
// are numbered starting from 0. If the specified position is
// not the position number of a card in the hand, then null
// is returned.
if (position >= 0 && position < hand.size())
return (Card)hand.elementAt(position);
else
return null;
public void sortBySuit() {
// Sorts the cards in the hand so that cards of the same suit are
// grouped together, and within a suit the cards are sorted by value.
// Note that aces are considered to have the lowest value, 1.
Vector newHand = new Vector();
while (hand.size() > 0) {
int pos = 0; // Position of minimal card.
Card c = (Card)hand.elementAt(0); // Minumal card.
for (int i = 1; i < hand.size(); i++) {
Card c1 = (Card)hand.elementAt(i);
if ( c1.getSuit() < c.getSuit() ||
(c1.getSuit() == c.getSuit() && c1.getValue() < c.getValue()) ) {
pos = i;
c = c1;
hand.removeElementAt(pos);
newHand.addElement(c);
hand = newHand;
public void sortByValue() {
// Sorts the cards in the hand so that cards of the same value are
// grouped together. Cards with the same value are sorted by suit.
// Note that aces are considered to have the lowest value, 1.
Vector newHand = new Vector();
while (hand.size() > 0) {
int pos = 0; // Position of minimal card.
Card c = (Card)hand.elementAt(0); // Minumal card.
for (int i = 1; i < hand.size(); i++) {
Card c1 = (Card)hand.elementAt(i);
if ( c1.getValue() < c.getValue() ||
(c1.getValue() == c.getValue() && c1.getSuit() < c.getSuit()) ) {
pos = i;
c = c1;
hand.removeElementAt(pos);
newHand.addElement(c);
hand = newHand;

Answer 1

Please don't crosspost. It cuts down on the effectiveness of responses, leads to people wasting their time answering what others have already answered, makes for difficult discussion, and is generally just annoying and bad form.