Sophie: qt3-devel-3.3.8b-6ark i586

qt3-devel-3.3.8b-6ark.i586.rpm

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<!-- /home/espenr/tmp/qt-3.3.8-espenr-2499/qt-x11-free-3.3.8/examples/tictac/tictac.doc:4 -->
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Tic Tac Toe</title>
<style type="text/css"><!--
fn { margin-left: 1cm; text-indent: -1cm; }
a:link { color: #004faf; text-decoration: none }
a:visited { color: #672967; text-decoration: none }
body { background: #ffffff; color: black; }
--></style>
</head>
<body>

<table border="0" cellpadding="0" cellspacing="0" width="100%">
<tr bgcolor="#E5E5E5">
<td valign=center>
 <a href="index.html">
<font color="#004faf">Home</font></a>
 | <a href="classes.html">
<font color="#004faf">All&nbsp;Classes</font></a>
 | <a href="mainclasses.html">
<font color="#004faf">Main&nbsp;Classes</font></a>
 | <a href="annotated.html">
<font color="#004faf">Annotated</font></a>
 | <a href="groups.html">
<font color="#004faf">Grouped&nbsp;Classes</font></a>
 | <a href="functions.html">
<font color="#004faf">Functions</font></a>
</td>
<td align="right" valign="center"><img src="logo32.png" align="right" width="64" height="32" border="0"></td></tr></table><h1 align=center>Tic Tac Toe</h1>

   
<p> 
This is an implementation of the Tic-tac-toe game.
<p> We didn't put much effort in making a clever algorithm so it's not a
challenge to play against the computer. Instead, study the source code
to see how you can make reusable components such as the <em>TicTacGameBoard</em>
widget.
<p> <hr>
<p> Header file:
<p> <pre>/****************************************************************************
** $Id: qt/tictac.h   3.3.8   edited Jan 11 14:37 $
**
** Copyright (C) 1992-2007 Trolltech ASA.  All rights reserved.
**
** This file is part of an example program for Qt.  This example
** program may be used, distributed and modified without limitation.
**
*****************************************************************************/

#ifndef TICTAC_H
#define TICTAC_H


#include &lt;<a href="qpushbutton-h.html">qpushbutton.h</a>&gt;
#include &lt;<a href="qptrvector-h.html">qptrvector.h</a>&gt;

class QComboBox;
class QLabel;


// --------------------------------------------------------------------------
// TicTacButton implements a single tic-tac-toe button
//

class TicTacButton : public <a href="qpushbutton.html">QPushButton</a>
{
    <a href="metaobjects.html#Q_OBJECT">Q_OBJECT</a>
public:
    TicTacButton( <a href="qwidget.html">QWidget</a> *parent );
    enum Type { Blank, Circle, Cross };
    Type        type() const            { return t; }
    void        setType( Type type )    { t = type; repaint(); }
    <a href="qsizepolicy.html">QSizePolicy</a> sizePolicy() const
    { return QSizePolicy( QSizePolicy::Preferred, QSizePolicy::Preferred ); }
    <a href="qsize.html">QSize</a> sizeHint() const { return QSize( 32, 32 ); }
    <a href="qsize.html">QSize</a> minimumSizeHint() const { return QSize( 10, 10 ); }
protected:
    void        drawButtonLabel( <a href="qpainter.html">QPainter</a> * );
private:
    Type t;
};

// Using template vector to make vector-class of TicTacButton.
// This vector is used by the TicTacGameBoard class defined below.

typedef QPtrVector&lt;TicTacButton&gt;        TicTacButtons;
typedef QMemArray&lt;int&gt;          TicTacArray;


// --------------------------------------------------------------------------
// TicTacGameBoard implements the tic-tac-toe game board.
// TicTacGameBoard is a composite widget that contains N x N TicTacButtons.
// N is specified in the constructor.
//

class TicTacGameBoard : public <a href="qwidget.html">QWidget</a>
{
    Q_OBJECT
public:
    TicTacGameBoard( int n, QWidget *parent=0, const char *name=0 );
   ~TicTacGameBoard();
    enum        State { Init, HumansTurn, HumanWon, ComputerWon, NobodyWon };
    State       state() const           { return st; }
    void        computerStarts( bool v );
    void        newGame();
signals:
    void        finished();                     // game finished
private slots:
    void        buttonClicked();
private:
    void        setState( State state ) { st = state; }
    void        updateButtons();
    int checkBoard( TicTacArray * );
    void        computerMove();
    State       st;
    int         nBoard;
    bool        comp_starts;
    TicTacArray *btArray;
    TicTacButtons *buttons;
};


// --------------------------------------------------------------------------
// TicTacToe implements the complete game.
// TicTacToe is a composite widget that contains a TicTacGameBoard and
// two push buttons for starting the game and quitting.
//

class TicTacToe : public <a href="qwidget.html">QWidget</a>
{
    Q_OBJECT
public:
    TicTacToe( int boardSize=3, QWidget *parent=0, const char *name=0 );
private slots:
    void        newGameClicked();
    void        gameOver();
private:
    void        newState();
    <a href="qcombobox.html">QComboBox</a>   *whoStarts;
    <a href="qpushbutton.html">QPushButton</a> *newGame;
    <a href="qpushbutton.html">QPushButton</a> *quit;
    <a href="qlabel.html">QLabel</a>      *message;
    TicTacGameBoard *board;
};


#endif // TICTAC_H
</pre>

<p> <hr>
<p> Implementation:
<p> <pre>/****************************************************************************
** $Id: qt/tictac.cpp   3.3.8   edited Jan 11 14:37 $
**
** Copyright (C) 1992-2007 Trolltech ASA.  All rights reserved.
**
** This file is part of an example program for Qt.  This example
** program may be used, distributed and modified without limitation.
**
*****************************************************************************/

#include "tictac.h"
#include &lt;<a href="qapplication-h.html">qapplication.h</a>&gt;
#include &lt;<a href="qpainter-h.html">qpainter.h</a>&gt;
#include &lt;<a href="qdrawutil-h.html">qdrawutil.h</a>&gt;
#include &lt;<a href="qcombobox-h.html">qcombobox.h</a>&gt;
#include &lt;<a href="qcheckbox-h.html">qcheckbox.h</a>&gt;
#include &lt;<a href="qlabel-h.html">qlabel.h</a>&gt;
#include &lt;<a href="qlayout-h.html">qlayout.h</a>&gt;
#include &lt;stdlib.h&gt;                             // rand() function
#include &lt;<a href="qdatetime-h.html">qdatetime.h</a>&gt;                          // seed for rand()


//***************************************************************************
//* TicTacButton member functions
//***************************************************************************

// --------------------------------------------------------------------------
// Creates a TicTacButton
//

<a name="f188"></a>TicTacButton::TicTacButton( <a href="qwidget.html">QWidget</a> *parent ) : <a href="qpushbutton.html">QPushButton</a>( parent )
{
    t = Blank;                                  // initial type
}

// --------------------------------------------------------------------------
// Paints TicTacButton
//

<a name="x31"></a>void TicTacButton::<a href="qbutton.html#drawButtonLabel">drawButtonLabel</a>( <a href="qpainter.html">QPainter</a> *p )
{
    <a href="qrect.html">QRect</a> r = <a href="qwidget.html#rect">rect</a>();
    p-&gt;<a href="qpainter.html#setPen">setPen</a>( QPen( white,2 ) );               // set fat pen
    if ( t == Circle ) {
<a name="x36"></a><a name="x35"></a><a name="x28"></a>        p-&gt;<a href="qpainter.html#drawEllipse">drawEllipse</a>( r.<a href="qrect.html#left">left</a>()+4, r.<a href="qrect.html#top">top</a>()+4, r.<a href="qrect.html#width">width</a>()-8, r.<a href="qrect.html#height">height</a>()-8 );
    } else if ( t == Cross ) {                  // draw cross
<a name="x37"></a><a name="x33"></a>        p-&gt;<a href="qpainter.html#drawLine">drawLine</a>( r.<a href="qrect.html#topLeft">topLeft</a>()   +QPoint(4,4), r.<a href="qrect.html#bottomRight">bottomRight</a>()-QPoint(4,4));
<a name="x38"></a><a name="x32"></a>        p-&gt;<a href="qpainter.html#drawLine">drawLine</a>( r.<a href="qrect.html#bottomLeft">bottomLeft</a>()+QPoint(4,-4),r.<a href="qrect.html#topRight">topRight</a>()   -QPoint(4,-4));
    }
}


//***************************************************************************
//* TicTacGameBoard member functions
//***************************************************************************

// --------------------------------------------------------------------------
// Creates a game board with N x N buttons and connects the "clicked()"
// signal of all buttons to the "buttonClicked()" slot.
//

<a name="f189"></a>TicTacGameBoard::TicTacGameBoard( int n, QWidget *parent, const char *name )
    : <a href="qwidget.html">QWidget</a>( parent, name )
{
    st = Init;                                  // initial state
    nBoard = n;
    n *= n;                                     // make square
    comp_starts = FALSE;                        // human starts
    buttons = new TicTacButtons(n);             // create real buttons
    btArray = new TicTacArray(n);               // create button model
    <a href="qgridlayout.html">QGridLayout</a> * grid = new <a href="qgridlayout.html">QGridLayout</a>( this, nBoard, nBoard, 4 );
    <a href="qpalette.html">QPalette</a> p( blue );
    for ( int i=0; i&lt;n; i++ ) {                 // create and connect buttons
        TicTacButton *ttb = new TicTacButton( this );
<a name="x45"></a>        ttb-&gt;<a href="qwidget.html#setPalette">setPalette</a>( p );
        ttb-&gt;<a href="qwidget.html#setEnabled">setEnabled</a>( FALSE );
        <a href="qobject.html#connect">connect</a>( ttb, SIGNAL(<a href="qbutton.html#clicked">clicked</a>()), SLOT(buttonClicked()) );
        grid-&gt;<a href="qgridlayout.html#addWidget">addWidget</a>( ttb, i%nBoard, i/nBoard );
        buttons-&gt;insert( i, ttb );
        btArray-&gt;at(i) = TicTacButton::Blank;   // initial button type
    }
<a name="x40"></a>    <a href="qtime.html">QTime</a> t = QTime::<a href="qtime.html#currentTime">currentTime</a>();             // set random seed
<a name="x43"></a><a name="x42"></a><a name="x41"></a>    srand( t.<a href="qtime.html#hour">hour</a>()*12+t.<a href="qtime.html#minute">minute</a>()*60+t.<a href="qtime.html#second">second</a>()*60 );
}

TicTacGameBoard::~TicTacGameBoard()
{
    delete buttons;
    delete btArray;
}


// --------------------------------------------------------------------------
// TicTacGameBoard::computerStarts( bool v )
//
// Computer starts if v=TRUE. The human starts by default.
//

void <a name="f190"></a>TicTacGameBoard::computerStarts( bool v )
{
    comp_starts = v;
}


// --------------------------------------------------------------------------
// TicTacGameBoard::newGame()
//
// Clears the game board and prepares for a new game
//

void <a name="f191"></a>TicTacGameBoard::newGame()
{
    st = HumansTurn;
    for ( int i=0; i&lt;nBoard*nBoard; i++ )
        btArray-&gt;at(i) = TicTacButton::Blank;
    if ( comp_starts )
        computerMove();
    else
        updateButtons();
}


// --------------------------------------------------------------------------
// TicTacGameBoard::buttonClicked()             - SLOT
//
// This slot is activated when a TicTacButton emits the signal "clicked()",
// i.e. the user has clicked on a TicTacButton.
//

void <a name="f192"></a>TicTacGameBoard::buttonClicked()
{
    if ( st != HumansTurn )                     // not ready
        return;
    int i = buttons-&gt;findRef( (TicTacButton*)<a href="qobject.html#sender">sender</a>() );
    TicTacButton *b = buttons-&gt;at(i);           // get piece that was pressed
    if ( b-&gt;type() == TicTacButton::Blank ) {   // empty piece?
        btArray-&gt;at(i) = TicTacButton::Circle;
        updateButtons();
        if ( checkBoard( btArray ) == 0 )       // not a winning move?
            computerMove();
        int s = checkBoard( btArray );
        if ( s ) {                              // any winners yet?
            st = s == TicTacButton::Circle ? HumanWon : ComputerWon;
            emit finished();
        }
    }
}


// --------------------------------------------------------------------------
// TicTacGameBoard::updateButtons()
//
// Updates all buttons that have changed state
//

void <a name="f193"></a>TicTacGameBoard::updateButtons()
{
    for ( int i=0; i&lt;nBoard*nBoard; i++ ) {
        if ( buttons-&gt;at(i)-&gt;type() != btArray-&gt;at(i) )
            buttons-&gt;at(i)-&gt;setType( (TicTacButton::Type)btArray-&gt;at(i) );
        buttons-&gt;at(i)-&gt;setEnabled( buttons-&gt;at(i)-&gt;type() ==
                                    TicTacButton::Blank );
    }
}


// --------------------------------------------------------------------------
// TicTacGameBoard::checkBoard()
//
// Checks if one of the players won the game, works for any board size.
//
// Returns:
//  - TicTacButton::Cross  if the player with X buttons won
//  - TicTacButton::Circle if the player with O buttons won
//  - Zero (0) if there is no winner yet
//

int <a name="f194"></a>TicTacGameBoard::checkBoard( TicTacArray *a )
{
    int  t = 0;
    int  row, col;
    bool won = FALSE;
    for ( row=0; row&lt;nBoard &amp;&amp; !won; row++ ) {  // check horizontal
        t = a-&gt;at(row*nBoard);
        if ( t == TicTacButton::Blank )
            continue;
        col = 1;
        while ( col&lt;nBoard &amp;&amp; a-&gt;at(row*nBoard+col) == t )
            col++;
        if ( col == nBoard )
            won = TRUE;
    }
    for ( col=0; col&lt;nBoard &amp;&amp; !won; col++ ) {  // check vertical
        t = a-&gt;at(col);
        if ( t == TicTacButton::Blank )
            continue;
        row = 1;
        while ( row&lt;nBoard &amp;&amp; a-&gt;at(row*nBoard+col) == t )
            row++;
        if ( row == nBoard )
            won = TRUE;
    }
    if ( !won ) {                               // check diagonal top left
        t = a-&gt;at(0);                           //   to bottom right
        if ( t != TicTacButton::Blank ) {
            int i = 1;
            while ( i&lt;nBoard &amp;&amp; a-&gt;at(i*nBoard+i) == t )
                i++;
            if ( i == nBoard )
                won = TRUE;
        }
    }
    if ( !won ) {                               // check diagonal bottom left
        int j = nBoard-1;                       //   to top right
        int i = 0;
        t = a-&gt;at(i+j*nBoard);
        if ( t != TicTacButton::Blank ) {
            i++; j--;
            while ( i&lt;nBoard &amp;&amp; a-&gt;at(i+j*nBoard) == t ) {
                i++; j--;
            }
            if ( i == nBoard )
                won = TRUE;
        }
    }
    if ( !won )                                 // no winner
        t = 0;
    return t;
}


// --------------------------------------------------------------------------
// TicTacGameBoard::computerMove()
//
// Puts a piece on the game board. Very, very simple.
//

void <a name="f195"></a>TicTacGameBoard::computerMove()
{
    int numButtons = nBoard*nBoard;
    int *altv = new int[numButtons];            // buttons alternatives
    int altc = 0;
    int stopHuman = -1;
    TicTacArray a = btArray-&gt;copy();
    int i;
    for ( i=0; i&lt;numButtons; i++ ) {            // try all positions
        if ( a[i] != TicTacButton::Blank )      // already a piece there
            continue;
        a[i] = TicTacButton::Cross;             // test if computer wins
        if ( checkBoard(&amp;a) == a[i] ) {         // computer will win
            st = ComputerWon;
            stopHuman = -1;
            break;
        }
        a[i] = TicTacButton::Circle;            // test if human wins
        if ( checkBoard(&amp;a) == a[i] ) {         // oops...
            stopHuman = i;                      // remember position
            a[i] = TicTacButton::Blank;         // restore button
            continue;                           // computer still might win
        }
        a[i] = TicTacButton::Blank;             // restore button
        altv[altc++] = i;                       // remember alternative
    }
    if ( stopHuman &gt;= 0 )                       // must stop human from winning
        a[stopHuman] = TicTacButton::Cross;
    else if ( i == numButtons ) {               // tried all alternatives
        if ( altc &gt; 0 )                         // set random piece
            a[altv[rand()%(altc--)]] = TicTacButton::Cross;
        if ( altc == 0 ) {                      // no more blanks
            st = NobodyWon;
            emit finished();
        }
    }
    *btArray = a;                               // update model
    updateButtons();                            // update buttons
    delete[] altv;
}


//***************************************************************************
//* TicTacToe member functions
//***************************************************************************

// --------------------------------------------------------------------------
// Creates a game widget with a game board and two push buttons, and connects
// signals of child widgets to slots.
//

<a name="f196"></a>TicTacToe::TicTacToe( int boardSize, QWidget *parent, const char *name )
    : <a href="qwidget.html">QWidget</a>( parent, name )
{
    <a href="qvboxlayout.html">QVBoxLayout</a> * l = new <a href="qvboxlayout.html">QVBoxLayout</a>( this, 6 );

    // Create a message label

    message = new <a href="qlabel.html">QLabel</a>( this );
<a name="x24"></a>    message-&gt;<a href="qframe.html#setFrameStyle">setFrameStyle</a>( QFrame::WinPanel | QFrame::Sunken );
    message-&gt;<a href="qlabel.html#setAlignment">setAlignment</a>( AlignCenter );
    l-&gt;<a href="qboxlayout.html#addWidget">addWidget</a>( message );

    // Create the game board and connect the signal finished() to this
    // gameOver() slot

    board = new TicTacGameBoard( boardSize, this );
    <a href="qobject.html#connect">connect</a>( board, SIGNAL(finished()), SLOT(gameOver()) );
    l-&gt;<a href="qboxlayout.html#addWidget">addWidget</a>( board );

    // Create a horizontal frame line

    <a href="qframe.html">QFrame</a> *line = new <a href="qframe.html">QFrame</a>( this );
    line-&gt;<a href="qframe.html#setFrameStyle">setFrameStyle</a>( QFrame::HLine | QFrame::Sunken );
    l-&gt;<a href="qboxlayout.html#addWidget">addWidget</a>( line );

    // Create the combo box for deciding who should start, and
    // connect its clicked() signals to the buttonClicked() slot

    whoStarts = new <a href="qcombobox.html">QComboBox</a>( this );
<a name="x23"></a>    whoStarts-&gt;<a href="qcombobox.html#insertItem">insertItem</a>( "Computer starts" );
    whoStarts-&gt;<a href="qcombobox.html#insertItem">insertItem</a>( "Human starts" );
    l-&gt;<a href="qboxlayout.html#addWidget">addWidget</a>( whoStarts );

    // Create the push buttons and connect their clicked() signals
    // to this right slots.

    newGame = new <a href="qpushbutton.html">QPushButton</a>( "Play!", this );
    <a href="qobject.html#connect">connect</a>( newGame, SIGNAL(<a href="qbutton.html#clicked">clicked</a>()), SLOT(newGameClicked()) );
    quit = new <a href="qpushbutton.html">QPushButton</a>( "Quit", this );
    <a href="qobject.html#connect">connect</a>( quit, SIGNAL(<a href="qbutton.html#clicked">clicked</a>()), qApp, SLOT(<a href="qapplication.html#quit">quit</a>()) );
    <a href="qhboxlayout.html">QHBoxLayout</a> * b = new <a href="qhboxlayout.html">QHBoxLayout</a>;
<a name="x19"></a>    l-&gt;<a href="qboxlayout.html#addLayout">addLayout</a>( b );
    b-&gt;<a href="qboxlayout.html#addWidget">addWidget</a>( newGame );
    b-&gt;<a href="qboxlayout.html#addWidget">addWidget</a>( quit );

    newState();
}


// --------------------------------------------------------------------------
// TicTacToe::newGameClicked()                  - SLOT
//
// This slot is activated when the new game button is clicked.
//

void <a name="f197"></a>TicTacToe::newGameClicked()
{
<a name="x22"></a>    board-&gt;computerStarts( whoStarts-&gt;<a href="qcombobox.html#currentItem">currentItem</a>() == 0 );
    board-&gt;newGame();
    newState();
}


// --------------------------------------------------------------------------
// TicTacToe::gameOver()                        - SLOT
//
// This slot is activated when the TicTacGameBoard emits the signal
// "finished()", i.e. when a player has won or when it is a draw.
//

void <a name="f198"></a>TicTacToe::gameOver()
{
    newState();                                 // update text box
}


// --------------------------------------------------------------------------
// Updates the message to reflect a new state.
//

void <a name="f199"></a>TicTacToe::newState()
{
    static const char *msg[] = {                // TicTacGameBoard::State texts
        "Click Play to start", "Make your move",
        "You won!", "Computer won!", "It's a draw" };
    message-&gt;<a href="qlabel.html#setText">setText</a>( msg[board-&gt;state()] );
    return;
}
</pre>

<p> <hr>
<p> Main:
<p> <pre>/****************************************************************************
** $Id: qt/main.cpp   3.3.8   edited Jan 11 14:37 $
**
** Copyright (C) 1992-2007 Trolltech ASA.  All rights reserved.
**
** This file is part of an example program for Qt.  This example
** program may be used, distributed and modified without limitation.
**
*****************************************************************************/

#include &lt;<a href="qapplication-h.html">qapplication.h</a>&gt;
#include &lt;stdlib.h&gt;
#include "tictac.h"


int main( int argc, char **argv )
{
    <a href="qapplication.html">QApplication</a> a( argc, argv );
    int n = 3;
    if ( argc == 2 )                            // get board size n
        n = atoi(argv[1]);
    if ( n &lt; 3 || n &gt; 10 ) {                    // out of range
        <a href="qapplication.html#qWarning">qWarning</a>( "%s: Board size must be from 3x3 to 10x10", argv[0] );
        return 1;
    }
    TicTacToe ttt( n );                         // create game
    a.<a href="qapplication.html#setMainWidget">setMainWidget</a>( &amp;ttt );
    ttt.<a href="qwidget.html#setCaption">setCaption</a>("Qt Example - TicTac");
    ttt.<a href="qwidget.html#show">show</a>();                                 // show widget
    return a.<a href="qapplication.html#exec">exec</a>();                            // go
}
</pre>

<p>See also <a href="examples.html">Examples</a>.

<!-- eof -->
<p><address><hr><div align=center>
<table width=100% cellspacing=0 border=0><tr>
<td>Copyright &copy; 2007
<a href="troll.html">Trolltech</a><td align=center><a href="trademarks.html">Trademarks</a>
<td align=right><div align=right>Qt 3.3.8</div>
</table></div></address></body>
</html>