/* Yo Emacs, this is -*- C++ -*- ******************************************************************* ******************************************************************* * * * KREVERSI * * ******************************************************************* * * A Reversi (or sometimes called Othello) game * ******************************************************************* * * created 1997 by Mario Weilguni <mweilguni@sime.com> * ******************************************************************* * * This file is part of the KDE project "KREVERSI" * * KREVERSI is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2, or (at your option) * any later version. * * KREVERSI is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with KREVERSI; see the file COPYING. If not, write to * the Free Software Foundation, 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. * ******************************************************************* */ #include <unistd.h> #include <tqlayout.h> #include <tqlabel.h> #include <tqlistbox.h> #include <kapplication.h> #include <kdebug.h> #include <kconfig.h> #include <kstandarddirs.h> #include <kstatusbar.h> #include <klocale.h> #include <kmessagebox.h> #include <kaction.h> #include <kstdgameaction.h> #include <kkeydialog.h> #include <kconfigdialog.h> #include <knotifyclient.h> #include <knotifydialog.h> #include <kexthighscore.h> #include "Score.h" #include "kreversi.h" // Automatically generated headers #include "prefs.h" #include "settings.h" #include "kreversi.moc" // ================================================================ // class KReversi #ifndef PICDATA #define PICDATA(x) \ KGlobal::dirs()->findResource("appdata", TQString("pics/") + x) #endif KReversi::KReversi() : KZoomMainWindow(10, 300, 5, "kreversi"), m_gameOver(false) { TQWidget *w; TQGridLayout *top; KNotifyClient::startDaemon(); // The game. m_game = new QReversiGame(); m_cheating = false; m_gameOver = false; m_humanColor = Black; // The Engine m_engine = new Engine(); setStrength(1); // The visual stuff w = new TQWidget(this); setCentralWidget(w); top = new TQGridLayout(w, 2, 2); // The reversi game view. m_gameView = new QReversiGameView(w, m_game); top->addMultiCellWidget(m_gameView, 0, 1, 0, 0); // Populate the GUI. createKActions(); addWidget(m_gameView); // Connect the signals from the game with slots of the view // // The only part of the view that is left in this class is the // indicator of whose turn it is in the status bar. The rest is // in the game view. connect(m_game, TQT_SIGNAL(sig_newGame()), TQT_TQOBJECT(this), TQT_SLOT(showTurn())); connect(m_game, TQT_SIGNAL(sig_move(uint, Move&)), TQT_TQOBJECT(this), TQT_SLOT(handleMove(uint, Move&))); // Calls showTurn(). connect(m_game, TQT_SIGNAL(sig_update()), TQT_TQOBJECT(this), TQT_SLOT(showTurn())); connect(m_game, TQT_SIGNAL(sig_gameOver()), TQT_TQOBJECT(this), TQT_SLOT(slotGameOver())); // Signal that is sent when the user clicks on the board. connect(m_gameView, TQT_SIGNAL(signalSquareClicked(int, int)), TQT_TQOBJECT(this), TQT_SLOT(slotSquareClicked(int, int))); loadSettings(); setupGUI(); init("popup"); m_gameView->start(); slotNewGame(); } KReversi::~KReversi() { delete m_game; delete m_engine; } // Create all KActions used in KReversi. // void KReversi::createKActions() { // Standard Game Actions. KStdGameAction::gameNew(TQT_TQOBJECT(this), TQT_SLOT(slotNewGame()), actionCollection(), "game_new"); KStdGameAction::load(TQT_TQOBJECT(this), TQT_SLOT(slotOpenGame()), actionCollection()); KStdGameAction::save(TQT_TQOBJECT(this), TQT_SLOT(slotSave()), actionCollection()); KStdGameAction::quit(TQT_TQOBJECT(this), TQT_SLOT(close()), actionCollection()); KStdGameAction::hint(TQT_TQOBJECT(this), TQT_SLOT(slotHint()), actionCollection(), "game_hint"); KStdGameAction::undo(TQT_TQOBJECT(this), TQT_SLOT(slotUndo()), actionCollection(), "game_undo"); // Non-standard Game Actions: Stop, Continue, Switch sides stopAction = new KAction(i18n("&Stop Thinking"), "game_stop", TQt::Key_Escape, TQT_TQOBJECT(this), TQT_SLOT(slotInterrupt()), actionCollection(), "game_stop"); continueAction = new KAction(i18n("&Continue Thinking"), "reload", 0, TQT_TQOBJECT(this), TQT_SLOT(slotContinue()), actionCollection(), "game_continue"); new KAction(i18n("S&witch Sides"), 0, 0, TQT_TQOBJECT(this), TQT_SLOT(slotSwitchSides()), actionCollection(), "game_switch_sides"); // Some more standard game actions: Highscores, Settings. KStdGameAction::highscores(TQT_TQOBJECT(this), TQT_SLOT(showHighScoreDialog()), actionCollection()); KStdAction::preferences(TQT_TQOBJECT(this), TQT_SLOT(slotEditSettings()), actionCollection()); // Actions for the view(s). showLastMoveAction = new KToggleAction(i18n("Show Last Move"), "lastmoves", 0, TQT_TQOBJECT(this), TQT_SLOT(slotShowLastMove()), actionCollection(), "show_last_move"); showLegalMovesAction = new KToggleAction(i18n("Show Legal Moves"), "legalmoves", 0, TQT_TQOBJECT(this), TQT_SLOT(slotShowLegalMoves()), actionCollection(), "show_legal_moves"); } // ---------------------------------------------------------------- // Methods for the engine // Set the strength for the engine. We keep track of the lowest // strength that was used during a game and if the user wins, this is // the strength that we will store in the highscore file. void KReversi::setStrength(uint strength) { // FIXME: 7 should be MAXSTRENGTH or something similar. Q_ASSERT( 1 <= strength && strength <= 7 ); strength = TQMAX(TQMIN(strength, 7), 1); m_engine->setStrength(strength); if (m_lowestStrength < strength) m_lowestStrength = strength; KExtHighscore::setGameType(m_lowestStrength-1); } // ---------------------------------------------------------------- // Slots for KActions // A slot that is called when the user wants a new game. // void KReversi::slotNewGame() { // If already playing, ask the player if he wants to abort the old game. if ( isPlaying() ) { if (KMessageBox ::warningYesNo(0, i18n("You are already running an unfinished game. " "If you abort the old game to start a new one, " "the old game will be registered as a loss in " "the highscore file.\n" "What do you want to do?"), i18n("Abort Current Game?"), i18n("Abort Old Game"), i18n("Continue Old Game")) == KMessageBox::No) return; KExtHighscore::submitScore(KExtHighscore::Lost, this); } m_gameOver = false; m_cheating = false; m_game->newGame(); m_competitiveGame = Prefs::competitiveGameChoice(); m_lowestStrength = strength(); //kdDebug() << "Competitive: " << m_competitiveGame << endl; // Set the state to waiting for the humans move. setState(Ready); // Black always makes first move. if (m_humanColor == White) computerMakeMove(); } // Open an earlier saved game from the config file. // // FIXME: Should give a choice to load from an ordinary file (SGF?) // void KReversi::slotOpenGame() { KConfig *config = kapp->config(); config->setGroup("Savegame"); if (loadGame(config)) Prefs::setSkill(m_engine->strength()); m_gameView->setHumanColor(humanColor()); } // Save a game to the config file. // // FIXME: Should give a choice to save as an ordinary file (SGF?) // void KReversi::slotSave() { KConfig *config = kapp->config(); config->setGroup("Savegame"); saveGame(config); KMessageBox::information(this, i18n("Game saved.")); } void KReversi::slotHint() { Move move; if (state() != Ready) return; setState(Thinking); move = m_engine->computeMove(m_game, m_competitiveGame); setState(Hint); m_gameView->showHint(move); setState(Ready); } // Takes back last set of moves // void KReversi::slotUndo() { if (state() != Ready) return; // Can't undo anything if no moves are made. if (m_game->moveNumber() == 0) return; // Undo all moves of the same color as the last one. Color last_color = m_game->lastMove().color(); while (m_game->moveNumber() != 0 && last_color == m_game->lastMove().color()) { m_game->undoMove(); m_gameView->removeMove(m_game->moveNumber()); } // Take back one more move. if (m_game->moveNumber() > 0) { m_game->undoMove(); m_gameView->removeMove(m_game->moveNumber()); // FIXME: Call some method in m_gameView. m_gameView->setCurrentMove(m_game->moveNumber() - 1); } if (m_game->toMove() == computerColor()) { // Must repaint so that the new move is not shown before the old // one is removed on the screen. m_gameView->repaint(); computerMakeMove(); } else m_gameView->update(); } // Interrupt thinking of game engine. // void KReversi::slotInterrupt() { m_engine->setInterrupt(TRUE); // Indicate that the computer was interrupted. showTurn(); } // Continues a move if it was interrupted earlier. // void KReversi::slotContinue() { if (interrupted()) computerMakeMove(); } // Turn on or off showing of legal moves in the board view. void KReversi::slotShowLastMove() { m_gameView->setShowLastMove(showLastMoveAction->isChecked()); } // Turn on or off showing of legal moves in the board view. void KReversi::slotShowLegalMoves() { m_gameView->setShowLegalMoves(showLegalMovesAction->isChecked()); } void KReversi::slotSwitchSides() { if (state() != Ready) return; if (interrupted()) { KMessageBox::information(this, i18n("You cannot switch sides in the middle of the computer's move."), i18n("Notice")); return; } // It's ok to change sides before the first move. if (m_game->moveNumber() != 0) { int res = KMessageBox::warningContinueCancel(this, i18n("If you switch side, your score will not be added to the highscores."), TQString(), TQString(), "switch_side_warning"); if ( res==KMessageBox::Cancel ) return; m_cheating = true; } m_humanColor = opponent(m_humanColor); // Update the human color in the window. m_gameView->setHumanColor(m_humanColor); kapp->processEvents(); computerMakeMove(); } // ---------------------------------------------------------------- // Slots for the game IO // Handle mouse clicks. // void KReversi::slotSquareClicked(int row, int col) { // Can't move when it is the computers turn. if ( interrupted() ) { illegalMove(); return; } if (state() == Ready) humanMakeMove(row, col); else if (state() == Hint) { m_gameView->quitHint(); setState(Ready); } else illegalMove(); } // ---------------------------------------------------------------- // Slots for the game view // Show the move in the move view. // FIXME: Move this to the gameview. void KReversi::handleMove(uint /*moveno*/, Move& /*move*/) { showTurn(); } // A slot that is called when it is time to show whose turn it is. // void KReversi::showTurn() { showTurn(m_game->toMove()); } void KReversi::showTurn(Color color) { // If we are not playing, do nothing. if (m_gameOver) return; if (color == humanColor()) statusBar()->message(i18n("Your turn")); else if (color == computerColor()) { TQString message = i18n("Computer's turn"); // We can't use the interrupted() test here since we might be in a // middle state when called from slotInterrupt(). if (m_state == Thinking) message += i18n(" (interrupted)"); statusBar()->message(message); } else statusBar()->clear(); } // A slot that is called when the game ends. // void KReversi::slotGameOver() { uint black = m_game->score(Black); uint white = m_game->score(White); setState(Ready); if (black > white) showGameOver(Black); else if (black < white) showGameOver(White); else showGameOver(Nobody); showTurn(Nobody); } // ---------------------------------------------------------------- // Private methods // Handle the humans move. // void KReversi::humanMakeMove(int row, int col) { if (state() != Ready) return; Color color = m_game->toMove(); // Create a move from the mouse click and see if it is legal. // If it is, then make a human move. Move move(color, col + 1, row + 1); if (m_game->moveIsLegal(move)) { // Do the move. The view is automatically updated. m_game->doMove(move); if (!m_game->moveIsAtAllPossible()) { setState(Ready); slotGameOver(); return; } if (color != m_game->toMove()) computerMakeMove(); } else illegalMove(); } // Make a computer move. // void KReversi::computerMakeMove() { MoveList moves; // Check if the computer can move. Color color = m_game->toMove(); Color opponent = ::opponent(color); if (!m_game->moveIsPossible(color)) return; // Make computer moves until the human can play or until the game is over. setState(Thinking); do { Move move; if (!m_game->moveIsAtAllPossible()) { setState(Ready); slotGameOver(); return; } move = m_engine->computeMove(m_game, m_competitiveGame); if (move.x() == -1) { setState(Ready); return; } usleep(300000); // Pretend we have to think hard. // Do the move on the board. The view is automatically updated. //playSound("click.wav"); m_game->doMove(move); } while (!m_game->moveIsPossible(opponent)); setState(Ready); if (!m_game->moveIsAtAllPossible()) { slotGameOver(); return; } } // Handle an attempt to make an illegal move by the human. void KReversi::illegalMove() { KNotifyClient::event(winId(), "illegal_move", i18n("Illegal move")); } // Show things when the game is over. // void KReversi::showGameOver(Color color) { // If the game already was over, do nothing. if (m_gameOver) return; statusBar()->message(i18n("End of game")); // Get the scores. uint human = m_game->score(humanColor()); uint computer = m_game->score(computerColor()); KExtHighscore::Score score; score.setScore(m_game->score(humanColor())); // Show the winner in a messagebox. if ( color == Nobody ) { KNotifyClient::event(winId(), "draw", i18n("Draw!")); TQString s = i18n("Game is drawn!\n\nYou : %1\nComputer: %2") .arg(human).arg(computer); KMessageBox::information(this, s, i18n("Game Ended")); score.setType(KExtHighscore::Draw); } else if ( humanColor() == color ) { KNotifyClient::event(winId(), "won", i18n("Game won!")); TQString s = i18n("Congratulations, you have won!\n\nYou : %1\nComputer: %2") .arg(human).arg(computer); KMessageBox::information(this, s, i18n("Game Ended")); score.setType(KExtHighscore::Won); } else { KNotifyClient::event(winId(), "lost", i18n("Game lost!")); TQString s = i18n("You have lost the game!\n\nYou : %1\nComputer: %2") .arg(human).arg(computer); KMessageBox::information(this, s, i18n("Game Ended")); score.setType(KExtHighscore::Lost); } // Store the result in the highscore file if no cheating was done, // and only if the game was competitive. if (!m_cheating && m_competitiveGame) { KExtHighscore::submitScore(score, this); } m_gameOver = true; } // Saves the game in the config file. // // Only one game at a time can be saved. // void KReversi::saveGame(KConfig *config) { // Stop thinking. slotInterrupt(); // Write the data to the config file. config->writeEntry("State", state()); config->writeEntry("Strength", strength()); config->writeEntry("Competitive", (int) m_competitiveGame); config->writeEntry("HumanColor", (int) m_humanColor); // Write the moves of the game to the config object. This object // saves itself all at once so we don't have to write the moves // to the file ourselves. config->writeEntry("NumberOfMoves", m_game->moveNumber()); for (uint i = 0; i < m_game->moveNumber(); i++) { Move move = m_game->move(i); TQString moveString; TQString idx; moveString.sprintf("%d %d %d", move.x(), move.y(), (int) move.color()); idx.sprintf("Move_%d", i + 1); config->writeEntry(idx, moveString); } // Actually write the data to file. config->sync(); // Continue with the move if applicable. slotContinue(); } // Loads the game. Only one game at a time can be saved. bool KReversi::loadGame(KConfig *config) { slotInterrupt(); // stop thinking uint nmoves = config->readNumEntry("NumberOfMoves", 0); if (nmoves==0) return false; m_game->newGame(); uint movenumber = 1; while (nmoves--) { // Read one move. TQString idx; idx.sprintf("Move_%d", movenumber++); TQStringList s = config->readListEntry(idx, ' '); uint x = (*s.at(0)).toUInt(); uint y = (*s.at(1)).toUInt(); Color color = (Color)(*s.at(2)).toInt(); Move move(color, x, y); m_game->doMove(move); } m_humanColor = (Color) config->readNumEntry("HumanColor"); m_competitiveGame = (bool) config->readNumEntry("Competitive"); m_gameView->updateBoard(TRUE); setState(State(config->readNumEntry("State"))); setStrength(config->readNumEntry("Strength", 1)); if (interrupted()) slotContinue(); else { // Computer makes first move. if (m_humanColor != m_game->toMove()) computerMakeMove(); } return true; } // ---------------------------------------------------------------- void KReversi::saveProperties(KConfig *c) { saveGame(c); } void KReversi::readProperties(KConfig *config) { loadGame(config); m_gameOver = false; m_cheating = false; // FIXME: Is this true? It isn't saved. } void KReversi::showHighScoreDialog() { KExtHighscore::show(this); } void KReversi::slotEditSettings() { // If we are already editing the settings, then do nothing. if (KConfigDialog::showDialog("settings")) return; KConfigDialog *dialog = new KConfigDialog(this, "settings", Prefs::self(), KDialogBase::Swallow); Settings *general = new Settings(0, "General"); dialog->addPage(general, i18n("General"), "package_settings"); connect(dialog, TQT_SIGNAL(settingsChanged()), TQT_TQOBJECT(this), TQT_SLOT(loadSettings())); dialog->show(); } void KReversi::configureNotifications() { KNotifyDialog::configure(this); } void KReversi::loadSettings() { m_humanColor = (Color) Prefs::humanColor(); setStrength(Prefs::skill()); // m_competitiveGame is set at the start of a game and can only be // downgraded during the game, never upgraded. if ( !Prefs::competitiveGameChoice() ) m_competitiveGame = false; m_gameView->loadSettings(); // Update the color of the human and the computer. m_gameView->setHumanColor(humanColor()); } bool KReversi::isPlaying() const { return ( m_game->moveNumber() != 0 && !m_gameOver ); } void KReversi::setState(State newState) { m_state = newState; if (m_state == Thinking){ kapp->setOverrideCursor(waitCursor); stopAction->setEnabled(true); } else { kapp->restoreOverrideCursor(); stopAction->setEnabled(false); } continueAction->setEnabled(interrupted()); } bool KReversi::queryExit() { if ( isPlaying() ) KExtHighscore::submitScore(KExtHighscore::Lost, this); return KZoomMainWindow::queryExit(); } void KReversi::writeZoomSetting(uint zoom) { Prefs::setZoom(zoom); Prefs::writeConfig(); } uint KReversi::readZoomSetting() const { return Prefs::zoom(); } void KReversi::writeMenubarVisibleSetting(bool visible) { Prefs::setMenubarVisible(visible); Prefs::writeConfig(); } bool KReversi::menubarVisibleSetting() const { return Prefs::menubarVisible(); }