You use pens to draw lines and curves. Complex graphics are made up of polygons, and those polygons are made of lines, and those lines are generated by pens. Pens have properties such as

You get the idea: You use pens to draw things. These properties are used by the pens to determine how things are drawn.

Text is painted with a combination of fonts and brushes. Just like pens, the Font class uses brushes to fill in the lines of a text operation.

System.Drawing.Text has collections of all the fonts installed in the system running your program, or installed as part of your application. System.Drawing.Font has all the properties of the typography, such as

The Graphics object, again, provides the writing of the text on the palette.

using PrintForm printForm = new PrintForm
    .Form =TheFormIWantPrinted
    .PrintAction = PrintToPrinter
    .Print()
end using

Cribbage is a card game where hands are counted up into points, and the first player to score 121 points wins. It's up to the players to count up the points, and the score is kept on a board.

Cribbage boards are made up of two lines of holes for pegs, usually totaling 120, but sometimes 60 holes are used and you play through twice. Figure 5-1 shows a typical cribbage board. Cribbage boards come in a bunch of styles — check out www.cribbage.org if you're curious; it has a great gallery of almost 100 boards, from basic to whimsical.

Figure 5-1. A traditional cribbage board.

For this example, I create the board image for an application that keeps score of a cribbage game — but it wouldn't be beyond C# to write the cards into the game too!

So the board for this application has 40 holes on each of three pairs of lines, which is the standard board setup for two players playing to 120, as shown in Figure 5-2. The first task is to draw the board, and then to draw the pegs as the players' scores — entered in text boxes — change.

The premise is this: The players play a hand and enter the resulting scores in the text box below their respective names (refer to Figure 5-2). When the score for each hand is entered, the score next to the player's name is updated, and the peg is moved on the board. The next time that same player scores a hand, the peg is moved forward, and the back peg is moved into its place. Did I mention the back peg? Oh, yes, the inventor of cribbage was paranoid of cheating — if you're unfamiliar with cribbage, you may want to check out the rules at www.cribbage.org.

Figure 5-2. The digital cribbage board.

To begin, create a playing surface. I set up the board shown in Figure 5-2 without drawing the board itself — I show you how to paint it on later with System.Drawing. My board looked a lot like Figure 5-3 when I was ready to start with the business rules.

Figure 5-3. The basic board.

I used a little subroutine to handle score changes by calling it from the two text boxes' OnChange events. Here's the code that calls the subroutine:

private void HandleScore(TextBox scoreBox, Label points, Label otherPlayer)
{
    try {
        if (0 > (int)scoreBox.Text | (int)scoreBox.Text > 27) {
            ScoreCheck.SetError(scoreBox, "Score must be between 0 and 27");
            scoreBox.Focus();
        }

else {
                ScoreCheck.SetError(scoreBox, "");
                //Add the score written to the points
                points.Text = (int)points.Text + (int)scoreBox.Text;
            }
        }
        catch (System.InvalidCastException ext) {
            //Something other than a number
            if (scoreBox.Text.Length > 0) {
                ScoreCheck.SetError(scoreBox, "Score must be a number");
            }
        }
        catch (Exception ex) {
            //Eek!
            MessageBox.Show("Something went wrong! " + ex.Message);
        }
        //Check the score
        if ((int)points.Text > 120) {
            if ((int)points.Text / (int)otherPlayer.Text > 1.5) {
                WinMessage.Text = scoreBox.Name.Substring(0, scoreBox.Name.Length −
        6) + " Skunked 'em!!!";
           }
           else {
              WinMessage.Text = scoreBox.Name.Substring(0, scoreBox.Name.Length −
        6) + " Won!!";
           }
           WinMessage.Visible = true;
        }
}

All this changing of screen values causes the Paint event of the form to fire — every time C# needs to change the look of a form for any reason, this event fires — so I just tossed a little code in that event handler that would draw my board for me:

private void CribbageBoard_Paint(object sender, PaintEventArgs e)
{
    PaintBoard(BillsPoints, GabriellesPoints);
}

From that point on, my largest concern is drawing the board itself.

I need to paint right on a form to create the image of the board for my crib-bage application, so I use the CreateGraphics method of the form control. From there, I need to complete these tasks:

To that end, I came up with the PaintBoard method, which accepts the labels that contain the standing scores for both players. It's shown in Listing 5-1.

private void PaintBoard(ref Label Bill, ref Label Gabrielle)
{
    Graphics palette = this.CreateGraphics;
    SolidBrush brownBrush = new SolidBrush(Color.Brown);
    palette.FillRectangle(brownBrush, new Rectangle(20, 20, 820, 180));
    //OK, now I need to paint the little holes.
    //There are 244 little holes in the board.
    //Three rows of 40 times two, with the little starts and stops on either end.
    //Let's start with the 240.
    int rows = 0;
    int columns = 0;
    int scoreBeingDrawn = 0;
    Pen blackPen = new Pen(System.Drawing.Color.Black, 1);
    SolidBrush blackBrush = new SolidBrush(Color.Black);
    SolidBrush redBrush = new SolidBrush(Color.Red);

    //There are 6 rows, then, at 24 and 40, 80 and 100, then 140 and 160.
    for (rows = 40; rows <= 160; rows += 60) {
        //There are 40 columns. They are every 20
        for (columns = 40; columns <= 820; columns += 20) {
            //Calculate score being drawn
            scoreBeingDrawn = ((columns - 20) / 20) + ((((rows + 20) / 60) - 1) *
    40);
            //Draw Bill
            //If score being drawn = bill fill, otherwise draw
            if (scoreBeingDrawn == (int)Bill.Text) {
                palette.FillEllipse(blackBrush, columns - 2, rows - 2, 6, 6);
            }
            else if (scoreBeingDrawn == BillsLastTotal) {
                palette.FillEllipse(redBrush, columns - 2, rows - 2, 6, 6);
            {
            else {
               palette.DrawEllipse(blackPen, columns - 2, rows - 2, 4, 4);
            }
            //Draw Gabrielle
            //If score being drawn = Gabrielle fill, otherwise draw
            if (scoreBeingDrawn == (int)Gabrielle.Text) {
                palette.FillEllipse(blackBrush, columns - 2, rows + 16, 6, 6);
            }
            else if (scoreBeingDrawn == GabriellesLastTotal) {
               palette.FillEllipse(redBrush, columns - 2, rows + 16, 6, 6); }
            else {
                palette.DrawEllipse(blackPen, columns - 2, rows + 16, 4, 4);
            }
        }
    }
    palette.Dispose();
    brownBrush.Dispose();
    blackPen.Dispose();
}

Aside from the math, note the decision making. If the score being drawn is the score in the label, fill in the hole with a red peg. If it's the last score drawn, fill in the hole with a black peg. Otherwise, well, just draw a circle.

It's tough to fathom, but this is exactly how large-scale games are written. Admittedly, big graphics engines make many more If-Then decisions, but the premise is the same.

Also, large games use bitmap images sometimes, rather than drawing all the time. For the cribbage scoring application, for example, you could use a bitmap image of a peg rather than fill an ellipse with a black or red brush!