Module 8: Stacks, Queues, ADT's

// This card game is a variation of the War card game described
// in the book "Object-Oriented Data Structures Using Java" by
// N.Dale, D.T.Joyce and C.Weems.

import java.util.*;

public class StrangeCardGame {

    public static void main (String[] argv)
    {
        // Use cards numbered 0,..,9 and deal 5 cards to each player.
	playGame (5, 10);
    }


    static void playGame (int dealSize, int numCards)
    {
        // Cards dealt out to player 1:
	LinkedList<Integer> player1 = new LinkedList<Integer>();
        // Cards dealt out to player 2:
	LinkedList<Integer> player2 = new LinkedList<Integer>();

        // The pile between the two players:
	LinkedList<Integer> pile = new LinkedList<Integer>();


        // Make the cards and shuffle them randomly.
	int[] cards = new int [numCards];
	for (int i=0; i<cards.length; i++) {
	    cards[i] = i;
	}
	shuffle (cards);

	// Deal cards to each player.
	int cardCount = 0;
	for (int k=0; k<dealSize; k++) {
	    player1.add (cards[cardCount]);
	    player2.add (cards[cardCount+1]);
	    cardCount += 2;                         	    // Note: += operator.
	}

	// Now play.
	boolean done = false;
	int round = 0;

	while (! done) {

	    // Each player plays their first card.
	    int player1first = player1.removeFirst ();
	    pile.add (player1first);
	    int player2first = player2.removeFirst ();
	    pile.add (player2first);

	    System.out.println ("Round 0: player1's card=" + player1first + "  player2's card=" + player2first);

	    if (player1first > player2first+2) {
		// Add pile into player 1's cards.
		addListToList (pile, player1);
		System.out.println ("  ⇒ player1 gets pile");
	    }
	    else if (player2first > player1first+2) {
		// Add pile into player 2's cards.
		addListToList (pile, player2);
		System.out.println ("  ⇒ player2 gets pile");
	    }
	    else {
		System.out.println ("  ⇒ both cards added to pile");
	    }

	    if (player1.isEmpty()) {
		System.out.println ("Player 2 wins!");
		done = true;
	    }
	    else if (player2.isEmpty()) {
		System.out.println ("Player 1 wins!");
		done = true;
	    }

	} //end-while

    }


    static void shuffle (int[] A)
    {
       // ... random permutation ...
    }


    static void addListToList (LinkedList<Integer> list1, LinkedList<Integer> list2)
    {
        // ... Extract every item in list1 and add them to list2 ...
    }

}

In-Class Exercise 12: Download, compile and try out AntEater.java. Click rapidly in the screen in a few different places and watch the anteater scour for ants.

Here's the program

// Various import's needed for GUI's.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
import java.util.*;            // This we need for LinkedList.


class AntEaterPanel extends JPanel {

    // We'll put all the ant-clicks into a queue, from which the anteater 
    // will pull out the next target.
    LinkedList<Point> antQueue = new LinkedList<Point>();

    Point antEater;    // The current position of the anteater.
    Point nextAnt;     // The position of the current ant being chased.


    // Constructor.

    public AntEaterPanel () 
    {
        // Listen to mouseclicks.
        this.addMouseListener (
            new MouseAdapter () {
                public void mouseClicked (MouseEvent e) 
                {
                    handleClick (e.getX(), e.getY());
                }
            }
                                    
        );
        
        // The anteater will run in a separate thread.
        Thread t = new Thread () {
                public void run () 
                {
                    move ();
                }
            };
        t.start ();
    }



    public void paintComponent (Graphics g)
    {
        super.paintComponent (g);

        // Clear drawing area.
        g.setColor (Color.white);
        Dimension D = this.getSize();
        g.fillRect (0,0, D.width, D.height);

        // Draw the ants.
        g.setColor (Color.gray);
        if (nextAnt != null) {
            g.fillOval (nextAnt.x-2,nextAnt.y-2, 4, 4);
        }
        for (Iterator<Point> iter=antQueue.iterator(); iter.hasNext(); ) {
            Point p = iter.next();
            g.fillOval (p.x-2,p.y-2, 4, 4);
        }

        // AntEater.
        g.setColor (Color.red);
        g.fillOval (antEater.x-10,antEater.y-10, 20, 20);
    }
    
    
    void draw ()
    {
        // Place a call to paintComponent(). 
        this.repaint ();
    }


    void handleClick (int x, int y)
    {
        // Add a new ant to the queue.
        antQueue.add (new Point(x,y));
        draw ();
    }
    

    void move ()
    {
        // This is where we'll start the anteater.
        antEater = new Point (0,0);
        
        while (true) {

            // Anteater sleeps 100 milliseconds.
            try {
                Thread.sleep (100);
            }
            catch (InterruptedException e) {
            }

            if (nextAnt == null) {
                if (! antQueue.isEmpty() ) {
                    // See if there's an ant to chase.                    
                    nextAnt = antQueue.removeFirst();
                }
            }
            else {
                if ( distance(nextAnt, antEater) < 10 ) {
                    // Eat the ant.
                    nextAnt = null;
                }
                else {
                    // Otherwise, step towards ant.
                    double theta = Math.atan2 ((nextAnt.y - antEater.y), (nextAnt.x - antEater.x));
                    double stepsize = 10.0;
                    antEater.x = (int) (antEater.x + stepsize*Math.cos(theta));
                    antEater.y = (int) (antEater.y + stepsize*Math.sin(theta));
                    draw ();
                }
            }
        }
    }


    double distance (Point p, Point q)
    {
        double distSq = (p.x-q.x)*(p.x-q.x) + (p.y-q.y)*(p.y-q.y);
        return Math.sqrt (distSq);
    }

} //end-panel



class AntEaterFrame extends JFrame {
    
    public AntEaterFrame ()
    {
        this.setTitle ("AntEater");
        this.setSize (300, 300);

        // The frame only consists of the panel.
        AntEaterPanel panel = new AntEaterPanel ();
        this.getContentPane().add (panel);

        this.setVisible (true);
    }

} //end-frame



public class AntEater {

    public static void main (String[] argv)
    {
        AntEaterFrame f = new AntEaterFrame ();
    }

}

• Let's point out a few things from the GUI code:
  • There are three parts to it: main(), the frame (AntEaterFrame) and the drawing area (AntEaterPanel).
  • main() is very simple: we merely create an instance of the frame.
  • The frame too is quite simple: we set the size, place an instance of the panel inside and make it visible.
  • All the work is done inside the panel.
  • To draw on the panel, we need to extend Java's JPanel class to override the paintComponent() method.
         ⇒ This is what is called for drawing to occur.
         ⇒ It's where we put our drawing code.
  • The panel also listens for mouseclicks, which are placed in the queue.
  • The panel also has the "logic" (anteater movement).

• Let's focus on the use of a queue:
  • Each click creates a new ant, which is placed in the queue (the add() operation).
  • Once the anteater eats an ant, we look at the queue for the next ant (the removeFirst() operation).
  • We also need to test whether the queue is empty.

In-Class Exercise 13: Modify the code above to print the number of ants eaten and to print the total distance travelled by the anteater.

In-Class Exercise 14: Consider how the anteater selects the next ant to pursue after it's finished with the current ant. In the program above, it goes after the next in queue order. What would we have to change, and how, to get the anteater to go after the nearest ant from among those in the queue? Write down pseudocode on paper and then try to implement it. What "queue rules" are we violating in doing this? Can you think of an alternative data structure for this variation of the problem?