noncore/games/tictac now fully merged

4 files changed, 12 insertions, 17 deletions

diff --git a/noncore/games/tictac/main.cpp b/noncore/games/tictac/main.cpp
index 0185b8c..cfff683 100644
--- a/noncore/games/tictac/main.cpp
+++ b/noncore/games/tictac/main.cpp
@@ -1,19 +1,13 @@
 /****************************************************************************
-<<<<<<< main.cpp
-** $Id$
-=======
-** $Id$
->>>>>>> 1.1.8.1.2.1
-**
 ** Copyright (C) 1992-2000 Trolltech AS.  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 <qpe/qpeapplication.h>
 #include <opie/oapplicationfactory.h>
 #include "tictac.h"
 
 OPIE_EXPORT_APP( OApplicationFactory<TicTacToe> )
diff --git a/noncore/games/tictac/tictac.cpp b/noncore/games/tictac/tictac.cpp
index 3d727ac..4954ba4 100644
--- a/noncore/games/tictac/tictac.cpp
+++ b/noncore/games/tictac/tictac.cpp
@@ -1,98 +1,98 @@
 /****************************************************************************
- ** $Id$
+ ** tictac.cpp,v 1.3.8.1 2003/08/29 06:50:40 harlekin Exp
  **
  ** Copyright (C) 1992-2000 Trolltech AS.  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 <qpe/qpeapplication.h>
 #include <qpainter.h>
 #include <qdrawutil.h>
 #include <qcombobox.h>
 #include <qcheckbox.h>
 #include <qlabel.h>
 #include <qlayout.h>
 #include <stdlib.h>       // rand() function
 #include <qdatetime.h>        // seed for rand()
 #include <qstringlist.h> //needed for proper internationalization
 
 
 //***************************************************************************
 //* TicTacButton member functions
 //***************************************************************************
 
 // --------------------------------------------------------------------------
 // Creates a TicTacButton
 //
 
 TicTacButton::TicTacButton( QWidget *parent ) : QPushButton( parent )
 {
     t = Blank;          // initial type
 }
 
 // --------------------------------------------------------------------------
 // Paints TicTacButton
 //
 
 void TicTacButton::drawButtonLabel( QPainter *p )
 {
     QRect r = rect();
     p->setPen( QPen( white,2 ) );   // set fat pen
     if ( t == Circle ) {
         p->drawEllipse( r.left()+4, r.top()+4, r.width()-8, r.height()-8 );
     } else if ( t == Cross ) {      // draw cross
         p->drawLine( r.topLeft()   +QPoint(4,4), r.bottomRight()-QPoint(4,4));
         p->drawLine( r.bottomLeft()+QPoint(4,-4),r.topRight()   -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.
 //
 
 TicTacGameBoard::TicTacGameBoard( int n, QWidget *parent, const char *name )
         : QWidget( parent, name )
 {
     showMaximized();
     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
     QGridLayout * grid = new QGridLayout( this, 3, 3, 4 );
     QPalette p( blue );
     for ( int i=0; i<n; i++ ) {     // create and connect buttons
         TicTacButton *ttb = new TicTacButton( this );
         ttb->setPalette( p );
         ttb->setEnabled( FALSE );
         connect( ttb, SIGNAL(clicked()), SLOT(buttonClicked()) );
         grid->addWidget( ttb, i%3, i/3 );
         buttons->insert( i, ttb );
         btArray->at(i) = TicTacButton::Blank; // initial button type
     }
     QTime t = QTime::currentTime();   // set random seed
     srand( t.hour()*12+t.minute()*60+t.second()*60 );
 }
 
 TicTacGameBoard::~TicTacGameBoard()
 {
     delete buttons;
     delete btArray;
 }
 
 
 // --------------------------------------------------------------------------
 // TicTacGameBoard::computerStarts( bool v )
 //
 // Computer starts if v=TRUE. The human starts by default.
@@ -195,187 +195,188 @@ int TicTacGameBoard::checkBoard( TicTacArray *a )
     for ( col=0; col<nBoard && !won; col++ ) {  // check vertical
         t = a->at(col);
         if ( t == TicTacButton::Blank )
             continue;
         row = 1;
         while ( row<nBoard && a->at(row*nBoard+col) == t )
             row++;
         if ( row == nBoard )
             won = TRUE;
     }
     if ( !won ) {       // check diagonal top left
         t = a->at(0);       //   to bottom right
         if ( t != TicTacButton::Blank ) {
             int i = 1;
             while ( i<nBoard && a->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->at(i+j*nBoard);
         if ( t != TicTacButton::Blank ) {
             i++; j--;
             while ( i<nBoard && a->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 TicTacGameBoard::computerMove()
 {
     int numButtons = nBoard*nBoard;
     int *altv = new int[numButtons];    // buttons alternatives
     int altc = 0;
     int stopHuman = -1;
     TicTacArray a = btArray->copy();
     int i;
     for ( i=0; i<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(&a) == a[i] ) {   // computer will win
             st = ComputerWon;
             stopHuman = -1;
             break;
         }
         a[i] = TicTacButton::Circle;    // test if human wins
         if ( checkBoard(&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 >= 0 )     // must stop human from winning
         a[stopHuman] = TicTacButton::Cross;
     else if ( i == numButtons ) {   // tried all alternatives
         if ( altc > 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.
 //
 
-TicTacToe::TicTacToe( int boardSize, QWidget *parent, const char *name )
-        : QWidget( parent, name )
+TicTacToe::TicTacToe( QWidget *parent, const char *name, WFlags fl )
+        : QWidget( parent, name, fl )
 {
     QVBoxLayout * l = new QVBoxLayout( this, 6 );
 
       // Create a message label
+    boardSize = 3;
 
     message = new QLabel( this );
     message->setFrameStyle( QFrame::WinPanel | QFrame::Sunken );
     message->setAlignment( AlignCenter );
     l->addWidget( message );
 
       // Create the game board and connect the signal finished() to this
       // gameOver() slot
 
     board = new TicTacGameBoard( boardSize, this );
     connect( board, SIGNAL(finished()), SLOT(gameOver()) );
     l->addWidget( board );
 
       // Create a horizontal frame line
 
     QFrame *line = new QFrame( this );
     line->setFrameStyle( QFrame::HLine | QFrame::Sunken );
     l->addWidget( line );
 
       // Create the combo box for deciding who should start, and
       // connect its clicked() signals to the buttonClicked() slot
 
     whoStarts = new QComboBox( this );
     whoStarts->insertItem( tr( "Computer starts" ) );
     whoStarts->insertItem( tr( "Human starts" ) );
     l->addWidget( whoStarts );
 
       // Create the push buttons and connect their clicked() signals
       // to this right slots.
 
     newGame = new QPushButton( tr( "Play!" ), this );
     connect( newGame, SIGNAL(clicked()), SLOT(newGameClicked()) );
     quit = new QPushButton( tr( "Quit" ), this );
     connect( quit, SIGNAL(clicked()), qApp, SLOT(quit()) );
     QHBoxLayout * b = new QHBoxLayout;
     l->addLayout( b );
     b->addWidget( newGame );
     b->addWidget( quit );
     showMaximized();
     newState();
 }
 
 
 // --------------------------------------------------------------------------
 // TicTacToe::newGameClicked()      - SLOT
 //
 // This slot is activated when the new game button is clicked.
 //
 
 void TicTacToe::newGameClicked()
 {
     board->computerStarts( whoStarts->currentItem() == 0 );
     board->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 TicTacToe::gameOver()
 {
     newState();         // update text box
 }
 
 
 // --------------------------------------------------------------------------
 // Updates the message to reflect a new state.
 //
 
 void TicTacToe::newState()
 {
     QStringList msg;
     msg << tr( "Click Play to start")
         << tr("Make your move")
         << tr("You won!")
         << tr("Computer won!")
         << tr("It's a draw");
     message->setText( msg[board->state()] );
     return;
 }
diff --git a/noncore/games/tictac/tictac.h b/noncore/games/tictac/tictac.h
index ec6c79c..bb0b485 100644
--- a/noncore/games/tictac/tictac.h
+++ b/noncore/games/tictac/tictac.h
@@ -1,108 +1,111 @@
 /****************************************************************************
-** $Id$
+** tictac.h,v 1.1.10.1 2003/08/29 06:50:40 harlekin Exp
 **
 ** Copyright (C) 1992-2000 Trolltech AS.  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 <qpushbutton.h>
 #include <qvector.h>
 
 class QComboBox;
 class QLabel;
 
 
 // --------------------------------------------------------------------------
 // TicTacButton implements a single tic-tac-toe button
 //
 
 class TicTacButton : public QPushButton
 {
     Q_OBJECT
 public:
     TicTacButton( QWidget *parent );
     enum Type { Blank, Circle, Cross };
             Type        type() const    { return t; }
             void        setType( Type type ){ t = type; repaint(); }
     QSizePolicy sizePolicy() const
     { return QSizePolicy( QSizePolicy::Preferred, QSizePolicy::Preferred ); }
     QSize sizeHint() const { return QSize( 32, 32 ); }
     QSize minimumSizeHint() const { return QSize( 10, 10 ); }
 protected:
             voiddrawButtonLabel( QPainter * );
 private:
     Type t;
 };
 
 // Using template vector to make vector-class of TicTacButton.
 // This vector is used by the TicTacGameBoard class defined below.
 
         typedef QVector<TicTacButton>TicTacButtons;
         typedef QArray<int>     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 QWidget
 {
     Q_OBJECT
 public:
     TicTacGameBoard( int n, QWidget *parent=0, const char *name=0 );
    ~TicTacGameBoard();
             enumState { Init, HumansTurn, HumanWon, ComputerWon, NobodyWon };
             State       state() const   { return st; }
             voidcomputerStarts( bool v );
     void        newGame();
 signals:
             void        finished();             // game finished
 private slots:
             voidbuttonClicked();
 private:
     void        setState( State state ) { st = state; }
             voidupdateButtons();
             int  checkBoard( TicTacArray * );
             void computerMove();
             Statest;
             int         nBoard;
             boolcomp_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 QWidget
 {
     Q_OBJECT
 public:
-    TicTacToe( int boardSize=3, QWidget *parent=0, const char *name=0 );
+    TicTacToe( QWidget *parent=0, const char *name=0, WFlags fl = 0 );
+    static QString appName() { return QString::fromLatin1("tictac"); }
+
 private slots:
             voidnewGameClicked();
             voidgameOver();
 private:
             voidnewState();
             QComboBox*whoStarts;
     QPushButton *newGame;
     QPushButton *quit;
             QLabel*message;
     TicTacGameBoard *board;
+    int boardSize;
 };
 
 
 #endif // TICTAC_H
diff --git a/noncore/games/tictac/tictac.pro b/noncore/games/tictac/tictac.pro
index eb0705e..5cbdbdc 100644
--- a/noncore/games/tictac/tictac.pro
+++ b/noncore/games/tictac/tictac.pro
@@ -1,32 +1,29 @@
-TEMPLATE  = app
-CONFIG    += qt warn_on release
+CONFIG    += qt warn_on release quick-app
 HEADERS   = tictac.h
 SOURCES   = main.cpp \
       tictac.cpp
-TARGET    = tictac
 INCLUDEPATH += $(OPIEDIR)/include
 DEPENDPATH  += $(OPIEDIR)/include
 LIBS            += -lqpe
-DESTDIR   = $(OPIEDIR)/bin
+
+        TARGET  = tictac
 
 TRANSLATIONS = ../../../i18n/de/tictac.ts \
          ../../../i18n/nl/tictac.ts \
          ../../../i18n/da/tictac.ts \
          ../../../i18n/xx/tictac.ts \
          ../../../i18n/en/tictac.ts \
          ../../../i18n/es/tictac.ts \
          ../../../i18n/fr/tictac.ts \
          ../../../i18n/hu/tictac.ts \
          ../../../i18n/ja/tictac.ts \
          ../../../i18n/ko/tictac.ts \
          ../../../i18n/no/tictac.ts \
          ../../../i18n/pl/tictac.ts \
          ../../../i18n/pt/tictac.ts \
          ../../../i18n/pt_BR/tictac.ts \
          ../../../i18n/sl/tictac.ts \
          ../../../i18n/zh_CN/tictac.ts \
          ../../../i18n/zh_TW/tictac.ts
 
-
-
 include ( $(OPIEDIR)/include.pro )