Chess::Move ChessGame::bookMove(Chess::Side side)
{
Q_ASSERT(!side.isNull());
if (m_book[side] == nullptr
|| m_moves.size() >= m_bookDepth[side] * 2)
return Chess::Move();
Chess::GenericMove bookMove = m_book[side]->move(m_board->key());
Chess::Move move = m_board->moveFromGenericMove(bookMove);
if (move.isNull())
return Chess::Move();
if (!m_board->isLegalMove(move))
{
qWarning("Illegal opening book move for %s: %s",
qPrintable(side.toString()),
qPrintable(m_board->moveString(move, Chess::Board::LongAlgebraic)));
return Chess::Move();
}
if (m_board->isRepetition(move))
return Chess::Move();
return move;
}
MainWindow::MainWindow(ChessGame* game)
: m_game(nullptr),
m_closing(false),
m_readyToClose(false)
{
setAttribute(Qt::WA_DeleteOnClose, true);
QHBoxLayout* clockLayout = new QHBoxLayout();
for (int i = 0; i < 2; i++)
{
m_chessClock[i] = new ChessClock();
clockLayout->addWidget(m_chessClock[i]);
Chess::Side side = Chess::Side::Type(i);
m_chessClock[i]->setPlayerName(side.toString());
}
clockLayout->insertSpacing(1, 20);
m_gameViewer = new GameViewer;
m_gameViewer->setContentsMargins(6, 6, 6, 6);
m_moveList = new MoveList(this);
m_tagsModel = new PgnTagsModel(this);
new ModelTest(m_tagsModel, this);
QVBoxLayout* mainLayout = new QVBoxLayout();
mainLayout->addLayout(clockLayout);
mainLayout->addWidget(m_gameViewer);
// The content margins look stupid when used with dock widgets
mainLayout->setContentsMargins(0, 0, 0, 0);
QWidget* mainWidget = new QWidget(this);
mainWidget->setLayout(mainLayout);
setCentralWidget(mainWidget);
setStatusBar(new QStatusBar());
createActions();
createMenus();
createToolBars();
createDockWindows();
connect(m_moveList, SIGNAL(moveClicked(int)),
m_gameViewer, SLOT(viewMove(int)));
connect(m_moveList, SIGNAL(commentClicked(int, QString)),
this, SLOT(editMoveComment(int, QString)));
connect(m_gameViewer, SIGNAL(moveSelected(int)),
m_moveList, SLOT(selectMove(int)));
connect(CuteChessApplication::instance()->gameManager(),
SIGNAL(finished()), this, SLOT(onGameManagerFinished()),
Qt::QueuedConnection);
addGame(game);
}
void GameAdjudicator::addEval(const Chess::Board* board, const MoveEvaluation& eval)
{
Chess::Side side = board->sideToMove().opposite();
// Tablebase adjudication
if (m_tbEnabled)
{
m_result = board->tablebaseResult();
if (!m_result.isNone())
return;
}
// Moves forced by the user (eg. from opening book or played by user)
if (eval.depth() <= 0)
{
m_drawScoreCount = 0;
m_resignScoreCount[side] = 0;
return;
}
// Draw adjudication
if (m_drawMoveNum > 0)
{
if (qAbs(eval.score()) <= m_drawScore)
m_drawScoreCount++;
else
m_drawScoreCount = 0;
if (board->plyCount() / 2 >= m_drawMoveNum
&& m_drawScoreCount >= m_drawMoveCount * 2)
{
m_result = Chess::Result(Chess::Result::Adjudication, Chess::Side::NoSide);
return;
}
}
// Resign adjudication
if (m_resignMoveCount > 0)
{
int& count = m_resignScoreCount[side];
if (eval.score() <= m_resignScore)
count++;
else
count = 0;
if (count >= m_resignMoveCount)
m_result = Chess::Result(Chess::Result::Adjudication,
side.opposite());
}
}
NewGameDialog::PlayerType NewGameDialog::playerType(Chess::Side side) const
{
Q_ASSERT(!side.isNull());
if (side == Chess::Side::White)
return (ui->m_whitePlayerHumanRadio->isChecked()) ? Human : CPU;
else
return (ui->m_blackPlayerHumanRadio->isChecked()) ? Human : CPU;
}
int NewGameDialog::selectedEngineIndex(Chess::Side side) const
{
Q_ASSERT(!side.isNull());
int i;
if (side == Chess::Side::White)
i = ui->m_whiteEngineComboBox->currentIndex();
else
i = ui->m_blackEngineComboBox->currentIndex();
return m_proxyModel->mapToSource(m_proxyModel->index(i, 0)).row();
}
void ChessGame::setOpeningBook(const OpeningBook* book,
Chess::Side side,
int depth)
{
Q_ASSERT(!m_gameInProgress);
if (side.isNull())
{
setOpeningBook(book, Chess::Side::White, depth);
setOpeningBook(book, Chess::Side::Black, depth);
}
else
{
m_book[side] = book;
m_bookDepth[side] = depth;
}
}
void ChessGame::setPlayer(Chess::Side side, ChessPlayer* player)
{
Q_ASSERT(!side.isNull());
Q_ASSERT(player != nullptr);
m_player[side] = player;
}
void GameWall::addGame(ChessGame* game)
{
Q_ASSERT(game != nullptr);
QWidget* widget = new QWidget(this);
ChessClock* clock[2] = { new ChessClock(), new ChessClock() };
QHBoxLayout* clockLayout = new QHBoxLayout();
for (int i = 0; i < 2; i++)
{
clock[i] = new ChessClock();
clockLayout->addWidget(clock[i]);
Chess::Side side = Chess::Side::Type(i);
clock[i]->setPlayerName(side.toString());
}
clockLayout->insertSpacing(1, 20);
BoardScene* scene = new BoardScene();
BoardView* view = new BoardView(scene);
QVBoxLayout* mainLayout = new QVBoxLayout();
mainLayout->addLayout(clockLayout);
mainLayout->addWidget(view);
mainLayout->setContentsMargins(0, 0, 0, 0);
widget->setLayout(mainLayout);
layout()->addWidget(widget);
game->lockThread();
connect(game, SIGNAL(fenChanged(QString)),
scene, SLOT(setFenString(QString)));
connect(game, SIGNAL(moveMade(Chess::GenericMove, QString, QString)),
scene, SLOT(makeMove(Chess::GenericMove)));
connect(game, SIGNAL(humanEnabled(bool)),
view, SLOT(setEnabled(bool)));
for (int i = 0; i < 2; i++)
{
ChessPlayer* player(game->player(Chess::Side::Type(i)));
if (player->isHuman())
connect(scene, SIGNAL(humanMove(Chess::GenericMove, Chess::Side)),
player, SLOT(onHumanMove(Chess::GenericMove, Chess::Side)));
clock[i]->setPlayerName(player->name());
connect(player, SIGNAL(nameChanged(QString)),
clock[i], SLOT(setPlayerName(QString)));
clock[i]->setInfiniteTime(player->timeControl()->isInfinite());
if (player->state() == ChessPlayer::Thinking)
clock[i]->start(player->timeControl()->activeTimeLeft());
else
clock[i]->setTime(player->timeControl()->timeLeft());
connect(player, SIGNAL(startedThinking(int)),
clock[i], SLOT(start(int)));
connect(player, SIGNAL(stoppedThinking()),
clock[i], SLOT(stop()));
}
scene->setBoard(game->pgn()->createBoard());
scene->populate();
foreach (const Chess::Move& move, game->moves())
scene->makeMove(move);
game->unlockThread();
view->setEnabled(!game->isFinished() &&
game->playerToMove()->isHuman());
m_games[game] = widget;
cleanupWidgets();
}