~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 <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_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
{
    qDebug() << "playstatus" << this;
    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 unlockPoints = m_towerFactory->data(m_towerFactory->index(availableTowersIndex), TowerFactory::RoleUnlockPoints).toInt();
    if (m_points >= unlockPoints) {
        m_points -= unlockPoints;
        m_towerFactory->unlockTower(availableTowersIndex);
        emit pointsChanged();
        savePoints();
    }
}

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

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

LevelPack *Engine::levelPack() const
{
    qDebug() << "levelPack" << this;
    return m_levelPack;
}

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

    qDebug() << "setting levelpack";
    m_levelPack = m_levelPacks->levelPack(levelPackId);
    emit levelPackChanged();

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

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

    m_levelPack->init();
}

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 (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::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)
{

    m_money = 0;
    emit moneyChanged();

    m_lives = 10;
    emit livesChanged();

    m_currentWave = -1;
    emit currentWaveChanged();

    m_level = level + 1;
    if (!loadLevelFile(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";
    Wave *wave = m_waves.at(m_currentWave);
    QList<int> enemies = wave->enemies();
    Enemy *enemy = m_enemyFactory->createEnemy(enemies.takeFirst());
    wave->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 * wave->interval() / 1000 * m_ticksPerSecond;
    }
}

void Engine::liveLost()
{
    m_lives--;
    emit livesChanged();

    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;
            emit pointsChanged();
            savePoints();
            m_rewardPoints = 0;

            QFileInfo fi(levelFile(m_level + 1));
            if (!fi.exists()) {
                m_playStatus = PlayStatusWon;
                emit playStatusChanged();
                return;
            }

            if (loadLevelFile(++m_level)) {
                emit levelChanged();
                emit wavesChanged();
                m_ticksToNextWave = 5 * m_ticksPerSecond;
            }
        } 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::loadLevelFile(int level)
{
    QFile file(levelFile(level));
    if (!file.open(QFile::ReadOnly)) {
        qWarning() << "cannot read level file:" << file.fileName();
        return false;
    }
    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();
        return false;
    }
    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.";
        return false;
    }

    QVariantMap boardData = levelData.value("board").toMap();

    QList<int> fieldsOnPath;
    foreach (const QVariant &variant, boardData.value("fieldsOnPath").toList()) {
        fieldsOnPath.append(variant.toInt());
    }

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

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

    if (!levelData.contains("rewardPoints")) {
        qWarning() << "rewardPoints not fount in level file.";
        return false;
    }
    m_rewardPoints = levelData.value("rewardPoints").toInt();

    qDebug() << "deleting all waves..." << m_waves.count();
    qDeleteAll(m_waves);
    m_waves.clear();
    foreach (const QVariant &waveData, levelData.value("waves").toList()) {
        QList<int> enemies;
        foreach (const QVariant &enemyId, waveData.toMap().value("enemies").toList()) {
            enemies.append(enemyId.toInt());
            qDebug() << "appending enemy:" << enemyId.toInt();
        }
        Wave *wave = new Wave(waveData.toMap().value("interval").toInt(), enemies);
        m_waves.append(wave);
    }
    m_currentWave = -1;

    m_money += levelData.value("startMoney", 0).toInt();
    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::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();
}