GameEngine.cpp - master - imurzich/shulte

GameEngine.cpp
142 строки4 KB
Igor Murzich
Добавить проверку размера поля: verifyFieldSize в GameEngine
18 июл 2026, 13:09
18 июл 2026, 13:099d8a55f
#include "GameEngine.h"
#include <QRandomGenerator>
#include <algorithm>

GameEngine::GameEngine(QObject *parent)
    : QObject(parent)
{
    m_timer.setInterval(200);
    connect(&m_timer, &QTimer::timeout, this, &GameEngine::tick);
    newGame();
}

int GameEngine::gridSize() const { return m_gridSize; }

void GameEngine::setGridSize(int size)
{
    if (size < 3 || size > 10 || size == m_gridSize) return;
    m_gridSize = size;
    emit gridSizeChanged();
    newGame();
}

QList<int> GameEngine::cells() const { return m_cells; }
int GameEngine::nextNumber() const { return m_next; }
bool GameEngine::playing() const { return m_playing; }
bool GameEngine::finished() const { return m_finished; }
int GameEngine::elapsedSeconds() const { return m_elapsed; }
int GameEngine::lastCorrect() const { return m_lastCorrect; }

QString GameEngine::timeString() const
{
    int s = m_elapsed;
    int min = s / 60;
    int sec = s % 60;
    return QStringLiteral("%1:%2")
        .arg(min)
        .arg(sec, 2, 10, QLatin1Char('0'));
}

void GameEngine::newGame()
{
    m_next = 1;
    m_playing = false;
    m_finished = false;
    m_elapsed = 0;
    m_lastCorrect = -1;
    m_timer.stop();

    int total = m_gridSize * m_gridSize;
    m_cells.resize(total);
    for (int i = 0; i < total; ++i) m_cells[i] = i + 1;
    shuffle();

    emit cellsChanged();
    emit nextNumberChanged();
    emit playingChanged();
    emit finishedChanged();
    emit timeChanged();
    emit lastCorrectChanged();
}

void GameEngine::clickCell(int index)
{
    if (m_finished || index < 0 || index >= m_cells.size()) return;

    if (!m_playing) {
        m_playing = true;
        m_elapsedTimer.start();
        m_timer.start();
        emit playingChanged();
    }

    if (m_cells[index] == m_next) {
        m_lastCorrect = index;
        emit lastCorrectChanged();
        m_next++;
        emit nextNumberChanged();

        if (m_next > m_gridSize * m_gridSize) {
            m_finished = true;
            m_playing = false;
            m_timer.stop();
            m_elapsed = static_cast<int>(m_elapsedTimer.elapsed() / 1000);
            emit finishedChanged();
            emit playingChanged();
            emit timeChanged();
            emit gameFinished(m_elapsed);
        }
    } else {
        emit wrongCell(index);
    }
}

void GameEngine::tick()
{
    if (!m_playing) return;
    m_elapsed = static_cast<int>(m_elapsedTimer.elapsed() / 1000);
    emit timeChanged();
}

void GameEngine::shuffle()
{
    auto *rng = QRandomGenerator::global();
    for (int i = m_cells.size() - 1; i > 0; --i) {
        int j = rng->bounded(i + 1);
        std::swap(m_cells[i], m_cells[j]);
    }
}

double GameEngine::fieldSizeCm() const { return m_fieldSizeCm; }

void GameEngine::setFieldSizeCm(double cm)
{
    if (cm <= 0 || qFuzzyCompare(cm, m_fieldSizeCm)) return;
    m_fieldSizeCm = cm;
    emit fieldSizeCmChanged();
}

void GameEngine::setWindow(QQuickWindow *window)
{
    if (m_window)
        return;
    m_window = window;
}

double GameEngine::mmToPixels(double mm) const
{
    if (!m_window) return mm * 3.78;
    QScreen *screen = m_window->screen();
    if (!screen) return mm * 3.78;
    double dpi = screen->physicalDotsPerInch();
    return mm / 25.4 * dpi;
}

void GameEngine::verifyFieldSize(double actualCm) const
{
    if (qAbs(actualCm - m_fieldSizeCm) > m_fieldSizeCm * 0.01) {
        fprintf(stderr, "Field size mismatch: configured %.1f cm, actual %.1f cm (dpi=%.1f)\n",
                m_fieldSizeCm, actualCm,
                m_window ? m_window->screen()->physicalDotsPerInch() : 96.0);
    }
}