~mzanetti/machines-vs-machines/qmake-based

#include "engine.h"
#include "levelpacks.h"
#include "levelpack.h"
#include "board.h"
#include "enemies.h"
#include "enemy.h"
#include "field.h"
#include "wave.h"
#include "towerfactory.h"
#include "tower.h"
#include "level.h"

#include <QTimer>
#include <QCoreApplication>

Engine::Engine(QObject *parent) :
    QObject(parent),
    m_levelPacks(nullptr),
    m_levelPack(nullptr),
    m_points(0),
    m_lives(10),
    m_levelCount(0),
    m_level(1),
    m_highestUnlockedLevel(0),
    m_playStatus(PlayStatusNotStarted),
    m_board(new Board(this)),
    m_enemyFactory(new EnemyFactory(this)),
    m_towerFactory(new TowerFactory(this)),
    m_currentWave(0),
    m_money(0),
    m_ticksPerSecond(33),
    m_timer(new QTimer(this)),
    m_gameSpeed(1),
    m_ticksToNextWave(-1),
    m_ticksToNextEnemy(-1)
{
    m_timer->setInterval(1000 / m_ticksPerSecond);
    m_timer->setTimerType(Qt::PreciseTimer);
    connect(m_timer, &QTimer::timeout, this, &Engine::slotTick);

    connect(m_board->enemies(), &Enemies::countChanged, this, &Engine::enemyCountChanged);
}

Engine::~Engine()
{
    delete m_enemyFactory;
    delete m_towerFactory;
}

LevelPacks *Engine::levelPacks()
{
    if (!m_levelPacks) {
        m_levelPacks = new LevelPacks(this);
    }
    return m_levelPacks;
}

int Engine::lives() const
{
    return m_lives;
}

int Engine::level() const
{
    return m_level;
}

Engine::PlayStatus Engine::playStatus() const
{
    return m_playStatus;
}

int Engine::money() const
{
    return m_money;
}

Board *Engine::board() const
{
    return m_board;
}

int Engine::waves() const
{
    return m_waves.count();
}

int Engine::currentWave() const
{
    return m_currentWave;
}

int Engine::gameSpeed() const
{
    return m_gameSpeed;
}

void Engine::setGameSpeed(int gameSpeed)
{
    if (gameSpeed > 0 && m_gameSpeed != gameSpeed) {
        m_gameSpeed = gameSpeed;
        emit gameSpeedChanged();
    }
}

qreal Engine::stepSize() const
{
    return 1.0 / 50;
}

TowerFactory* Engine::towerFactory() const
{
    return m_towerFactory;
}

EnemyFactory *Engine::enemyFactory() const
{
    return m_enemyFactory;
}

void Engine::unlockTower(int availableTowersIndex, int level)
{
    int unlockPoints = m_towerFactory->data(m_towerFactory->index(availableTowersIndex), TowerFactory::RoleUnlockPoints).toInt();
    if (m_points >= unlockPoints) {
        m_points -= unlockPoints;
        m_towerFactory->unlockTower(availableTowersIndex, level);
        emit pointsChanged();
        savePoints();
    }
}

int Engine::levelCount() const
{
    return m_levelCount;
}

int Engine::highestUnlockedLevel() const
{
    return m_highestUnlockedLevel;
}

int Engine::points() const
{
    return m_points;
}

LevelPack *Engine::levelPack() const
{
    return m_levelPack;
}

void Engine::loadLevelPack(const QString &levelPackId)
{
    if (m_playStatus != PlayStatusNotStarted) {
        stopGame();
    }

    m_levelPack = m_levelPacks->levelPack(levelPackId);
    qDebug() << "setting levelpack" << m_levelPack->rowCount(QModelIndex());

    m_levelCount = 0;
    while (QFileInfo(levelFile(m_levelCount+1)).exists()) {
        m_levelCount++;
    }
    emit levelCountChanged();


    if (m_levelPack->rowCount(QModelIndex()) == 0) {
        loadLevels();
    }
    m_levelPack->init();

    loadPoints();
    loadEnemies();
    loadTowers();
    loadHighestUnlockedLevel();

    emit levelPackChanged();
}

void Engine::unloadLevelPack()
{
    m_levelPack = nullptr;
    emit levelPackChanged();
}

void Engine::addTower(int fieldIndex, int towerTemplateId)
{
    if (m_money < m_towerFactory->cost(towerTemplateId)) {
        qWarning() << "not enough money. sorry";
        return;
    }

    Field *field = m_board->field(fieldIndex);
    if (!field) {
        qWarning() << "No such field" << fieldIndex;
        return;
    }

    if (field->isOnPath()) {
        qWarning() << "Cannot create tower on path";
        return;
    }
    if (field->tower()) {
        qWarning() << "Field already has a tower";
        return;
    }

    m_money -= m_towerFactory->cost(towerTemplateId);
    emit moneyChanged();

    field->addTower(m_towerFactory->createTower(towerTemplateId));
}

void Engine::upgradeTower(Tower *tower)
{
    if (tower->level() >= tower->levels() - 1) {
        qWarning() << "Can't upgrade this tower further";
        return;
    }
    if (tower->configs().at(tower->level()+1).locked) {
        qWarning() << "Can't upgrade this tower. Next level is locked.";
        return;
    }
    if (m_money < tower->configs().at(tower->level()+1).cost) {
        qWarning() << "Not enough money...";
        return;
    }
    m_money -= tower->configs().at(tower->level() + 1).cost;
    emit moneyChanged();
    tower->upgrade();
}

void Engine::destroyTower(int fieldIndex)
{
    Field *field = m_board->field(fieldIndex);
    if (field->tower()) {
        m_money += field->tower()->configs().at(field->tower()->level()).destroyReward;
        emit moneyChanged();
        field->destroyTower();
    }
}

void Engine::slotTick()
{
    if (m_ticksToNextWave > 0) {
        m_ticksToNextWave = qMax(0, m_ticksToNextWave - m_gameSpeed);
    }
    if (m_ticksToNextEnemy > 0) {
        m_ticksToNextEnemy = qMax(0, m_ticksToNextEnemy - m_gameSpeed);
    }

    if (m_ticksToNextWave == 0) {
        m_ticksToNextWave = -1;
        nextWave();
    }
    if (m_ticksToNextEnemy == 0) {
        m_ticksToNextEnemy = -1;
        nextEnemy();
    }
    emit tick();
}

void Engine::startNewGame(int level)
{
    qDebug() << "starting new game" << level;
    if (m_highestUnlockedLevel < level) {
        qWarning() << "Can't start level" << level << ". Not unlocked yet.";
        return;
    }

    m_money = 0;
    emit moneyChanged();

    m_lives = 10;
    emit livesChanged();

    m_currentWave = -1;
    emit currentWaveChanged();

    m_level = level;
    if (!loadLevel(m_level)) {
        return;
    }
    emit levelChanged();

    m_timer->start();
    m_playStatus = PlayStatusRunning;
    emit playStatusChanged();

    emit wavesChanged();
    m_ticksToNextWave = 5 * m_ticksPerSecond;
}

void Engine::pauseGame()
{
    m_playStatus = PlayStatusPaused;
    m_timer->stop();
    emit playStatusChanged();
}

void Engine::resumeGame()
{
    m_playStatus = PlayStatusRunning;
    m_timer->start();
    emit playStatusChanged();
}

void Engine::stopGame()
{
    m_timer->stop();
    m_board->enemies()->clear();
    m_playStatus = PlayStatusNotStarted;
    emit playStatusChanged();
}

void Engine::nextWave()
{
    m_currentWave++;
    emit currentWaveChanged();
    Wave wave = m_waves.at(m_currentWave);
    qDebug() << "starting wave" << wave.enemies();
    m_ticksToNextEnemy = 1;
}

void Engine::nextEnemy()
{
    qDebug() << "next enemy";
    QList<int> enemies = m_waves.at(m_currentWave).enemies();
    Enemy *enemy = m_enemyFactory->createEnemy(enemies.takeFirst());
    m_waves[m_currentWave].setEnemies(enemies);
    connect(enemy, &Enemy::exited, this, &Engine::liveLost);
    connect(enemy, &Enemy::died, this, &Engine::enemyDied);
    m_board->addEnemy(enemy);

    qDebug() << "got more enemies?" << enemies.count();
    if (enemies.count() > 0) {
        m_ticksToNextEnemy = 1.0 * m_waves.at(m_currentWave).interval() / 1000 * m_ticksPerSecond;
    }
}

void Engine::liveLost()
{
    m_lives--;
    emit livesChanged();
    m_rewardPoints -= m_levelPack->get(m_level)->rewardPoints() / 10;

    if (m_lives == 0) {
        m_timer->stop();
        m_playStatus = PlayStatusLost;
        emit playStatusChanged();
    }
}

void Engine::enemyCountChanged()
{
    if (m_board->enemies()->count() == 0) {
        if (m_currentWave == m_waves.count() - 1) {
            qDebug() << "level completed!";
            m_points += m_rewardPoints;
            m_levelPack->get(m_level)->setHighscore(m_rewardPoints);
            saveLevelHighscore(m_level, m_rewardPoints);

            emit pointsChanged();
            savePoints();
            m_rewardPoints = 0;

            if (m_level == m_highestUnlockedLevel) {
                m_highestUnlockedLevel++;
                emit highestUnlockedLevelChanged();
                saveHighestUnlockedLevel();
            }
            m_playStatus = PlayStatusWon;
            emit playStatusChanged();

        } else {
            m_ticksToNextWave = 2 * m_ticksPerSecond;
        }
    }
}

void Engine::enemyDied()
{
    Enemy *enemy = static_cast<Enemy*>(sender());

    m_money += enemy->reward();
    emit moneyChanged();
}

QString Engine::levelFile(int level)
{
    return QCoreApplication::applicationDirPath() + QString("/data/levelpacks/" + m_levelPack->id() + "/level%1/level.json").arg(level);
}

bool Engine::loadLevel(int index)
{
    qDebug() << "loading level" << index;
    Level *level = m_levelPack->get(index);
    qDebug() << "have levels:" << m_levelPack->rowCount(QModelIndex());
    qDebug() << "level:" << level;

    qDebug() << "init board:" << m_board->enemies()->count();
    if (!m_board->init(level->rows(), level->columns(), level->fieldsOnPath())) {
        qWarning() << "Error loading board. Entrance/Exit not found.";
        return false;
    }

    m_rewardPoints = level->rewardPoints();
    m_waves = level->waves();
    m_currentWave = -1;
    qDebug() << "loaded level with" << m_waves.count() << "waves";

    m_money = level->startMoney();
    emit moneyChanged();

    return true;
}

void Engine::loadEnemies()
{
    m_enemyFactory->clear();
    QFile enemyfile(QCoreApplication::applicationDirPath() + "/data/levelpacks/" + m_levelPack->id() + "/enemies/enemies.json");
    if (!enemyfile.open(QFile::ReadOnly)) {
        qWarning() << "couldn't open" << enemyfile.fileName();
        return;
    }

    QJsonParseError error;
    QJsonDocument jsonDoc = QJsonDocument::fromJson(enemyfile.readAll(), &error);
    if (error.error != QJsonParseError::NoError) {
        qWarning() << "Failed to parse" << enemyfile.fileName();
        return;
    }

    foreach (const QVariant &enemyVariant, jsonDoc.toVariant().toList()) {
        m_enemyFactory->createTemplate(enemyVariant.toMap());
    }
}

void Engine::loadTowers()
{
    m_towerFactory->clear();
    QFile towerfile(QCoreApplication::applicationDirPath() + "/data/levelpacks/" + m_levelPack->id() + "/towers/towers.json");
    if (!towerfile.open(QFile::ReadOnly)) {
        qWarning() << "couldn't open" << towerfile.fileName();
        return;
    }

    QJsonParseError error;
    QJsonDocument jsonDoc = QJsonDocument::fromJson(towerfile.readAll(), &error);
    if (error.error != QJsonParseError::NoError) {
        qWarning() << "Failed to parse" << towerfile.fileName();
        return;
    }

    foreach (const QVariant &towerVariant, jsonDoc.toVariant().toList()) {
        m_towerFactory->createTemplate(towerVariant.toMap());
    }
}

void Engine::loadLevels()
{
    int levelIndex = -1;
    while (QFileInfo(levelFile(++levelIndex + 1)).exists()) {
        QFile file(levelFile(levelIndex + 1));
        if (!file.open(QFile::ReadOnly)) {
            qWarning() << "Can't open level file" << levelFile(levelIndex + 1);
            continue;
        }

        QByteArray levelJson = file.readAll();
        file.close();

        QJsonParseError error;
        QJsonDocument jsonDoc = QJsonDocument::fromJson(levelJson, &error);
        if (error.error != QJsonParseError::NoError) {
            qWarning() << "failed to parse level file" << error.errorString();
            continue;
        }

        QVariantMap levelData = jsonDoc.toVariant().toMap();
        if (!levelData.contains("board")
                || !levelData.value("board").toMap().contains("rows")
                || !levelData.value("board").toMap().contains("columns")
                || !levelData.value("board").toMap().contains("fieldsOnPath")) {
            qWarning() << "level file doesn't contain a valid board description.";
            continue;
        }

        if (!levelData.contains("waves")) {
            qWarning() << "Waves not found in level file";
            continue;
        }

        if (!levelData.contains("rewardPoints")) {
            qWarning() << "rewardPoints not fount in level file.";
            continue;
        }

        Level *level = m_levelPack->addLevel(levelData);
        level->setHighscore(loadLevelHighscore(levelIndex));
        qDebug() << "loaded level highscore" << level->highscore() << levelIndex << loadLevelHighscore(levelIndex);
    }
}

void Engine::savePoints()
{
    QSettings settings("com.ubuntu.developer.mzanetti.ubuntudefence", "ubuntudefence");
    settings.beginGroup(m_levelPack->id());
    settings.beginGroup("scores");
    settings.setValue("points", m_points);
}

void Engine::loadPoints()
{
    QSettings settings("com.ubuntu.developer.mzanetti.ubuntudefence", "ubuntudefence");
    settings.beginGroup(m_levelPack->id());
    settings.beginGroup("scores");
    m_points = settings.value("points").toInt();
    emit pointsChanged();
}

void Engine::loadHighestUnlockedLevel()
{
    QSettings settings("com.ubuntu.developer.mzanetti.ubuntudefence", "ubuntudefence");
    settings.beginGroup(m_levelPack->id());
    settings.beginGroup("scores");
    m_highestUnlockedLevel = settings.value("highestUnlockedLevel").toInt();
    emit highestUnlockedLevelChanged();
}

void Engine::saveHighestUnlockedLevel()
{
    QSettings settings("com.ubuntu.developer.mzanetti.ubuntudefence", "ubuntudefence");
    settings.beginGroup(m_levelPack->id());
    settings.beginGroup("scores");
    settings.setValue("highestUnlockedLevel", m_highestUnlockedLevel);
}

int Engine::loadLevelHighscore(int level)
{
    QSettings settings("com.ubuntu.developer.mzanetti.ubuntudefence", "ubuntudefence");
    settings.beginGroup(m_levelPack->id());
    settings.beginGroup("scores");
    return settings.value("highscore-level" + QString::number(level)).toInt();
}

void Engine::saveLevelHighscore(int level, int highscore)
{
    QSettings settings("com.ubuntu.developer.mzanetti.ubuntudefence", "ubuntudefence");
    settings.beginGroup(m_levelPack->id());
    settings.beginGroup("scores");
    settings.setValue("highscore-level" + QString::number(level), highscore);
}