Introduction to Object Oriented Programming, 3rd Ed

Timothy A. Budd

Chapter 9

The Solitaire Game

Outline

1. The Solitaire Game
2. The class PlayingCard
   1. Some Features to Note
3. Separation of Data and View
   1. The CardView is Eventually Implemented
4. The Game -- Klondike
5. Card Piles
   1. The Class CardPile
   2. Some Features to Note
   3. Power of Inheritance
   4. Suit Piles
   5. Deck Pile
   6. Discard Pile
   7. Tableau Piles
6. The Polymorphic Game
   1. Some Features to Note
7. The Main Program
8. Chapter summary

Source

• The source and executable applet for the application described in this chapter. (Not available on CD, see explanation)

Other Material

• A printer friendly copy of all slides
• A C++ version of the program as it appeared in An Introduction to Object-Oriented Programming (1st edition, Addison-Wesley, 1991).
• A rewriting of the application from my book Understanding Object-Oriented Programming with Java (Addison-Wesley, 1998).
• Yet another rewriting in C++, from my book C++ for Java Programmers, published by Addison-Wesley, 1999.

Intro OOP, Chapter 9, Outline

The Solitare Game

• A good example of the use of inheritance and overriding

• Also useful to illustrate programming in C#

• Built out of classes for cards, card piles, and the game application.

Intro OOP, Chapter 9, Slide 01

The Class PlayingCard

public class PlayingCard 
{
	public PlayingCard (Suits sv, int rv)
		{ s = sv; r = rv; faceUp = false; }

	public bool isFaceUp 
	{
		get { return faceUp; }
	}
	
	public void flip () 
	{ 
		faceUp = ! faceUp;
	}

	public int rank
	{
		get { return r; }
	}

	public Suits suit
	{
		get { return s; }
	}
		
	public Color color
	{
		get
		{
			if ( suit == Suits.Heart || suit == Suits.Diamond )
				{ return Color.Red; }
			return Color.Black;
		}
	}

	private bool faceUp;
	private int r;
	private Suits s;
}

Intro OOP, Chapter 9, Slide 02

Some Features to Note

• The constructor for the class

• Properties for faceup, rank and suit

• Qualification of Enumerated Data Types

• This class has no explicit information about application, can be easily moved to new applications.

Intro OOP, Chapter 9, Slide 03

Separation of Data and View

• Allows views to be easily changed

• Data has no idea how it is viewed

• We do this in two steps, an abstract card view and an implementation of the class

public abstract class CardView
{
	public abstract void display (PlayingCard aCard, int x, int y);

	public static int Width = 50;
	public static int Height = 70;
}

Intro OOP, Chapter 9, Slide 04

The CardView is Eventually Implemented

public class WinFormsCardView : CardView {
	public WinFormsCardView (Graphics aGraphicsObject) {
		g = aGraphicsObject;
	}

	public override void display (PlayingCard aCard,int x,int y) {
		if  (aCard == null) {
			Pen myPen = new Pen(Color.Black,2);
			Brush myBrush = new SolidBrush (Color.White);
			g.FillRectangle(myBrush,x,y,CardView.Width,CardView.Height);
			g.DrawRectangle(myPen,x,y,CardView.Width,CardView.Height);
		} else {
			paintCard (aCard,x,y);
		}
	}

	private void paintCard (PlayingCard aCard,int x,int y) {
		...
	}
}

Intro OOP, Chapter 9, Slide 05

The Game -- Klondike

Intro OOP, Chapter 9, Slide 06

Card Piles

• We abstract the common behavior and place it into a parent class (for example, managing the pile of cards).

• We use overriding to specialize the behavior that is specific to each class. (for example, what it means when the pile is selected).

• Since some piles share behavior that in other piles is overridden, the parent class can provide a default behavior that can sometimes be changed (for example, drawing).

Intro OOP, Chapter 9, Slide 07

The Class CardPile

public class CardPile {
	public CardPile (int xl, int yl )
		{ x = xl; y = yl; pile = new Stack(); }

	public PlayingCard top 
		{ get { return (PlayingCard) pile.Peek (); } }

	public bool isEmpty 
		{ get { return pile.Count == 0; }	}

	public PlayingCard pop 
		{ get { return (PlayingCard) pile.Pop (); } }
		
		// the following are sometimes overridden
	public virtual bool includes (int tx, int ty ) {
		return( ( x <= tx ) && ( tx <= x + CardView.Width ) &&
		    ( y <= ty ) && ( ty <= y + CardView.Height ) );
	}

	public virtual void select (int tx, int ty ) {
		// do nothing--override
	}

	public virtual void addCard (PlayingCard aCard )
		{ pile.Push(aCard); }

	public virtual void display (CardView cv) {
		if ( isEmpty ) {
			cv.display(null, x, y);
		} else {
			cv.display((PlayingCard) pile.Peek(), x, y );
		}
	}

	public virtual bool canTake (PlayingCard aCard)
		{ return false; }

	protected int x, y; // coordinates of the card pile
	protected Stack pile; // card pile data
}

Intro OOP, Chapter 9, Slide 008

Some Features to Note

• The keyword virtual indicating which methods may be overridden.

• Potentially overridden methods have nevertheless been given a default behavior

• We have written isEmpty and pop as properties

• The data fields have been protected

Intro OOP, Chapter 9, Slide 09

Power of Inheritance

	CardPile	SuitPile	DeckPile	DiscardPile	TableauPile
includes	X				X
canTake	X	X			X
addCard	X			X
display	X				X
select	X		X	X	X

Intro OOP, Chapter 9, Slide 10

Suit Piles

public class SuitPile : CardPile {
	public SuitPile (int x, int y) : base(x, y) {	}

	public override bool canTake (PlayingCard aCard ) {
		if( isEmpty ) 
			{ return( aCard.rank == 0 ); }
		PlayingCard topCard = top;
		return( ( aCard.suit == topCard.suit ) &&
		   ( aCard.rank == topCard.rank + 1 ) );
	}
}

Intro OOP, Chapter 9, Slide 11

DeckPile

public class DeckPile : CardPile {
	public DeckPile (int x, int y) : base(x, y) {
		// create the new deck
		// first put cards into a local array
		ArrayList aList = new ArrayList ();
		for( int i = 0; i <= 12; i++) {
			aList.Add(new PlayingCard(Suits.Heart, i));
			aList.Add(new PlayingCard(Suits.Diamond, i));
			aList.Add(new PlayingCard(Suits.Spade, i));
			aList.Add(new PlayingCard(Suits.Club, i));
		}
			// then pull them out randomly
		Random myRandom = new Random( );
		for(int count = 0; count < 52; count++) {
			int index = myRandom.Next(aList.Count);
			addCard( (PlayingCard) aList [index] );
			aList.RemoveAt(index);
		}
	}

	public override void select (int tx, int ty) {
		if ( isEmpty ) { return; }
		Game.discardPile().addCard( pop );
	}
}

Intro OOP, Chapter 9, Slide 12

The Discard Pile

public class DiscardPile : CardPile {
	public DiscardPile (int x, int y ) : base(x, y) { }

	public override void addCard (PlayingCard aCard) {
		if( ! aCard.isFaceUp )
			{ aCard.flip(); }
		base.addCard( aCard );
	}

	public override void select (int tx, int ty) {
		if( isEmpty ) { return; }
		PlayingCard topCard = pop;
		for( int i = 0; i < 4; i++ ) {
			if( Game.suitPile(i).canTake( topCard ) ) {
				Game.suitPile(i).addCard( topCard );
				return;
			}
		}

		for( int i = 0; i < 7; i++ ) {
			if( Game.tableau(i).canTake( topCard ) ) {
				Game.tableau(i).addCard( topCard );
				return;
			}
		}
		// nobody can use it, put it back on our stack
		addCard(topCard);
	}
}

Intro OOP, Chapter 9, Slide 13

Tableau Piles

public class TablePile : CardPile {
	public TablePile (int x, int y, int c) : base(x, y) {
		// initialize our pile of cards
		for(int i = 0; i < c; i++ ) {
			addCard(Game.deckPile().pop);
		}	
		top.flip();
	}

	public override bool canTake (PlayingCard aCard ) {
		if( isEmpty ) { return(aCard.rank == 12); }
		PlayingCard topCard = top;
		return( ( aCard.color != topCard.color ) &&
			( aCard.rank    == topCard.rank - 1 ) );
	}

	public override bool includes (int tx, int ty) {
		return( ( x <= tx ) && ( tx <= x + CardView.Width ) &&
				( y <= ty ) );
	}

	public override void select (int tx, int ty) {
		if( isEmpty ) { return; }
		// if face down, then flip
		PlayingCard topCard = top;
		if( ! topCard.isFaceUp ) {
			topCard.flip();
			return;
		}
		// else see if any suit pile can take card
		topCard = pop;
		for(int i = 0; i < 4; i++ ) {
			if( Game.suitPile(i).canTake( topCard ) ) {
				Game.suitPile(i).addCard( topCard );
				return;
			}
		}
		// else see if any other table pile can take card
		for(int i = 0; i < 7; i++ ) {
			if( Game.tableau(i).canTake( topCard ) ) {
				Game.tableau(i).addCard( topCard );
				return;
			}
		}
		addCard( topCard );
	}

	public override void display (CardView cv) {
		Object [ ] cardArray = pile.ToArray();
		int size = pile.Count;
		int hs = CardView.Height / 2; // half size
		int ty = y;
		for (int i = pile.Count - 1; i >= 0; i--) {
			cv.display((PlayingCard) cardArray[i], x, ty);
			ty += hs;
		}
	}
}

Intro OOP, Chapter 9, Slide 14

The Polymorphic Game

public class Game {
	static Game () {
		allPiles = new CardPile[ 13 ];
		allPiles[0] = new DeckPile(335, 5 );
		allPiles[1] = new DiscardPile(268, 5 );
		for( int i = 0; i < 4; i++ ) {
			allPiles[2 + i] = new SuitPile(15 + 60 * i, 5);
		}
		for( int i = 0; i < 7; i++ ) {
			allPiles[6+i] = new TablePile(5+55*i, 80, i+1);
		}	
	}

	public static void paint (CardView cv) {
		for( int i = 0; i < 13; i++ ) {
			allPiles[i].display(cv );
		}
	}

	public static void mouseDown (int x, int y) {
		for( int i = 0; i < 13; i++ ) {
			if( allPiles[i].includes(x, y) ) { 
				allPiles [i].select(x, y);
			}	
		}
	}

	public static CardPile deckPile () { return allPiles[0]; }

	public static CardPile discardPile () { return allPiles[1]; }

	public static CardPile tableau (int index) { return allPiles[6+index]; }

	public static CardPile suitPile (int index) { return allPiles[2+index]; }

	private static CardPile[] allPiles;
}

Intro OOP, Chapter 9, Slide 15

Features to Note

• Note that the array allPiles is declared as an array of CardPile, but holds values from child classes

• When paint is called, the method display invoked will be the appropriate one for each type of pile, not the method in CardPile.

• Similarly, in mouseDown, different piles will use different implementations of includes and select

• Because these methods are static, they can be accessed using only the class name (we saw this earlier). There actually is no instance of Game, only the one class object.

Intro OOP, Chapter 9, Slide 16

The Main Program

public class Solitaire : System.WinForms.Form {
		// start of automatically generated code
        private System.ComponentModel.Container components;

        public Solitaire() { 
            InitializeComponent();
        }

        public override void Dispose() { 
            base.Dispose();
            components.Dispose();
        }

        private void InitializeComponent() { 
		this.components = new System.ComponentModel.Container ();
		this.Text = "Solitaire";
		this.AutoScaleBaseSize = new System.Drawing.Size (5, 13);
		this.ClientSize = new System.Drawing.Size (392, 373);
	}
		// end of automatically generated code

	protected override void OnMouseDown (MouseEventArgs e ) { 
		Game.mouseDown(e.X, e.Y); 
		this.Invalidate(); // force screen redraw
		}
		
	protected override void OnPaint (PaintEventArgs pe ) {
		Graphics g = pe.Graphics;
		CardView cv = new WinFormsCardView(g);
		Game.paint(cv);
	}

	public static void Main(string[] args) 
		{ Application.Run(new Solitaire()); }
}

Intro OOP, Chapter 9, Slide 17

Chapter Summary

• The use of inheritance and overriding in the card piles:
  • Reduces code developement
  • Insures common behavior
  • Makes possible the polymorphic evaluation of draw and select

• The way we have isolated the card data and the card view
  • An abstract class for views
  • An implementation of the abstract class for .new specific implementation

• How we have isolated the .net specific interface from the rest of the application.

Intro OOP, Chapter 9, Slide 18