TDE
/
tdegames
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/tdegames
0
0
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '1c4b43b712'
${ noResults }
tdegames/kreversi/kreversi.cpp

842 lines
20 KiB
Raw Blame History

/*
*******************************************************************
*******************************************************************
*
*
* 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 <tdeapplication.h>
#include <kdebug.h>
#include <tdeconfig.h>
#include <kstandarddirs.h>
#include <kstatusbar.h>
#include <tdelocale.h>
#include <tdemessagebox.h>
#include <tdeaction.h>
#include <kstdgameaction.h>
#include <kkeydialog.h>
#include <tdeconfigdialog.h>
#include <knotifyclient.h>
#include <knotifydialog.h>
#include <highscore/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) \
TDEGlobal::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.
createTDEActions();
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 TDEActions used in KReversi.
//
void KReversi::createTDEActions()
{
// 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 TDEAction(i18n("&Stop Thinking"), "game_stop", TQt::Key_Escape,
TQT_TQOBJECT(this), TQT_SLOT(slotInterrupt()), actionCollection(),
"game_stop");
continueAction = new TDEAction(i18n("&Continue Thinking"), "reload", 0,
TQT_TQOBJECT(this), TQT_SLOT(slotContinue()), actionCollection(),
"game_continue");
new TDEAction(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 TDEToggleAction(i18n("Show Last Move"), "lastmoves", 0,
TQT_TQOBJECT(this), TQT_SLOT(slotShowLastMove()),
actionCollection(),
"show_last_move");
showLegalMovesAction = new TDEToggleAction(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 TDEActions
// 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()
{
TDEConfig *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()
{
TDEConfig *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(TDEConfig *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(TDEConfig *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(TDEConfig *c)
{
saveGame(c);
}
void KReversi::readProperties(TDEConfig *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 (TDEConfigDialog::showDialog("settings"))
return;
TDEConfigDialog *dialog = new TDEConfigDialog(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();
}
View Git Blame Copy Permalink