Enemy spawn, Game over (still WIP segfault when try to return to menu)

Next: make the turret work

CMakeLists.txt

@@ -29,6 +29,8 @@ add_executable(Poulpes_de_l_espace_La_derniere_ligne_de_defense ${sourceCode}
         src/Enemy.cpp
         src/Enemy.h
         src/Player.cpp
-        src/Player.h)
+        src/Player.h
+        src/Gameover.cpp
+        src/Gameover.h)
 
 target_link_libraries(Poulpes_de_l_espace_La_derniere_ligne_de_defense PRIVATE Qt6::Widgets Qt6::Sql)

src/Enemy.cpp

@@ -3,11 +3,14 @@
 //
 
 #include "Enemy.h"
+#include <QDebug>
 
-Enemy::Enemy(int health, int shield, int damage, float regenerationRate, int speed, std::string avatarPath, int x, int y, int coinDrop, int weight, Map& gameMap)
-        : Mob(health, shield, damage, regenerationRate, speed, avatarPath, x, y), gameMap(gameMap) {
+Enemy::Enemy(int health, int shield, int damage, float regenerationRate, int speed, std::string avatarPath,
+             int x, int y, int coinDrop, int weight, Map& gameMap, int id, Game& game)
+        : Mob(health, shield, damage, regenerationRate, speed, avatarPath, x, y), gameMap(gameMap), game(game) {
     this->coinDrop = coinDrop;
     this->weight = weight;
+    this->id = id;
     moveTimer = new QTimer();
     QPixmap pixmap(QString::fromStdString(avatarPath));
     if (pixmap.isNull()) {
@@ -45,6 +48,10 @@ Tile* Enemy::getNextPathTile() {
     return nextTile;
 }
 
+Tile* Enemy::getCurrentTile() {
+    return gameMap.getTile(x, y);
+}
+
 void Enemy::moveEnemy() {
     // Move the enemy to the next path tile
     nextStep = getNextPathTile();
@@ -52,6 +59,10 @@ void Enemy::moveEnemy() {
         x = nextStep->gridX();
         y = nextStep->gridY();
         graphics->setPos(x * 50, y * 50);
+        if (getCurrentTile() == gameMap.getEndTile()) {
+            game.player->takeDamage(getDamage());
+            game.removeEnemy(this);
+        }
     }
 }
 

src/Enemy.h

@@ -8,17 +8,22 @@
 #include <QTimer>
 #include "Mob.h"
 #include "Map.h"
+#include "Game.h"
+
+class Game;
 
 class Enemy : public Mob
 {
     Q_OBJECT
 public:
-    Enemy(int health, int shield, int damage, float regenerationRate, int speed, std::string avatarPath, int x, int y, int coinDrop, int weight, Map& gameMap);
+    Enemy(int health, int shield, int damage, float regenerationRate, int speed, std::string avatarPath,
+          int x, int y, int coinDrop, int weight, Map& gameMap, int id, Game& game);
     int getWeight();
     int getCoinDrop();
     QGraphicsPixmapItem* getGraphics();
     void moveEnemy();
     Tile* getNextPathTile();
+    Tile* getCurrentTile();
 
 private slots:
     void onMoveTimerTimeout();
@@ -30,6 +35,8 @@ private:
     QGraphicsPixmapItem* graphics;
     QTimer* moveTimer;
     Tile* nextStep;
+    int id;
+    Game& game;
 };
 
 

src/Game.cpp

@@ -17,7 +17,7 @@ Game::Game(){
     this->setFocusPolicy(Qt::StrongFocus);
 
     // Create the player object
-    player = new Player(100, 0, 10, 10, 1, "../ressources/player.png", 0, 0, gameMap, *this);
+    player = new Player(1, 0, 10, 10, 1, "../ressources/player.png", 0, 0, gameMap, *this);
 
     // Create the text items for the health, gold and wave number
     healthDisplay = new QGraphicsTextItem();
@@ -59,9 +59,19 @@ void Game::start() {
     // Set the wave number
     waveNumber = 1;
 
+    // Get the start tile of the map
+    Tile* startTile = gameMap.getStartTile();
+
+    // Get start tile coordinates
+    x = startTile->gridX();
+    y = startTile->gridY();
+
     // Set the player position to the end tile
     Tile* endTile = gameMap.getEndTile();
-    player->setPosition(endTile);
+
+    int xEnd = endTile->gridX();
+    int yEnd = endTile->gridY();
+    player->setPosition(xEnd, yEnd);
 
     // Start the game timer
     gameTimer.start(1000);
@@ -74,6 +84,10 @@ void Game::start() {
 
     // Spawn the enemies
     spawnEnemies(waveNumber);
+
+    // Start the enemy check timer
+    connect(&enemyCheckTimer, &QTimer::timeout, this, &Game::checkEnemyNumber);
+    enemyCheckTimer.start(1000);
 }
 
 void Game::keyPressEvent(QKeyEvent *event) {
@@ -102,22 +116,77 @@ void Game::updateDisplay() {
 }
 
 void Game::spawnEnemies(int waveNumber) {
-    int totalWeight = 0;
-    int targetWeight = waveNumber * waveNumber;
-    // Get the start tile of the map
-    Tile* startTile = gameMap.getStartTile();
+    totalWeight = 0;
+    targetWeight = waveNumber * waveNumber;
+    int enemyId = 0;
 
-    // Get start tile coordinates
-    int x = startTile->gridX();
-    int y = startTile->gridY();
+    QTimer* spawnTimer = new QTimer();
+    connect(spawnTimer, &QTimer::timeout, [this, waveNumber, &enemyId, spawnTimer](){
+        if(totalWeight < targetWeight){
+            // Create a new enemy on the start tile
+            auto* enemy = new Enemy(100, 0, 10, 0, 1, "../ressources/enemy.png", x, y, 10, 1, gameMap, enemyId, *this);
+            totalWeight += enemy->getWeight();
+            currentEnemies.push_back(enemy);
+            gameMap.addItem(enemy->getGraphics());
+            enemyId++;
+        } else {
+            spawnTimer->stop();
+            spawnTimer->deleteLater();
+        }
+    });
+    spawnTimer->start(1000);
+}
 
-    while (totalWeight < targetWeight){
-        // Create a new enemy on the start tile
-        Enemy* enemy = new Enemy(10, 0, 5, 0, 1, "../ressources/enemy.png", x, y, 1, 1, gameMap);
-        totalWeight += enemy->getWeight();
-        currentEnemies.push_back(enemy);
-        gameMap.addItem(enemy->getGraphics());
-        // Wait for 1 second before spawning the next enemy
-        QThread::sleep(1);
+void Game::checkEnemyNumber() {
+    if (currentEnemies.empty()){
+        waveNumber++;
+        spawnEnemies(waveNumber);
     }
+}
+
+void Game::removeEnemy(Enemy* enemy) {
+    if (enemy->getGraphics()->scene() == &gameMap) {
+        gameMap.removeItem(enemy->getGraphics());
+    }
+    auto it = std::find(currentEnemies.begin(), currentEnemies.end(), enemy);
+    if (it != currentEnemies.end()) {
+        currentEnemies.erase(it);
+    }
+    delete enemy;
+}
+
+void Game::gameOver() {
+    gameTimer.stop();
+    enemyCheckTimer.stop();
+
+    // Remove all the enemies from the game
+    for (auto* enemy : currentEnemies) {
+        if (enemy->getGraphics()->scene() == &gameMap) {
+            gameMap.removeItem(enemy->getGraphics());
+        }
+        delete enemy;
+    }
+    currentEnemies.clear();
+
+    // Remove the player from the game
+    if (player->getGraphics()->scene() == &gameMap) {
+        gameMap.removeItem(player->getGraphics());
+    }
+    delete player;
+
+    // Reset game variables
+    userGold = 0;
+    waveNumber = 0;
+    totalWeight = 0;
+    targetWeight = 0;
+
+    // Show the menu
+    menu->showMenuGO();
+
+    // Delete the game object
+    deleteLater();
+}
+
+Game::~Game() {
+    qDebug() << "Game object deleted";
 }

src/Game.h

@@ -12,11 +12,17 @@
 #include "Map.h"
 #include "Player.h"
 #include "Enemy.h"
+#include "Menu.h"
 
 class Player;
 
+class Enemy;
+
+class Menu;
+
 class Game : public QGraphicsView
 {
+    Q_OBJECT
 public:
     Game();
     void start();
@@ -25,14 +31,24 @@ public:
     void spawnEnemies(int waveNumber);
     int userGold;
     std::vector<Enemy*> currentEnemies;
+    void checkEnemyNumber();
+    void removeEnemy(Enemy* enemy);
+    Player* player;
+    void gameOver();
+    ~Game() override;
 
 private:
     QTimer gameTimer;
     int waveNumber;
-    Player* player;
     QGraphicsTextItem* healthDisplay;
     QGraphicsTextItem* goldDisplay;
     QGraphicsTextItem* waveDisplay;
+    QTimer enemyCheckTimer;
+    int totalWeight;
+    int targetWeight;
+    int x;
+    int y;
+    Menu* menu;
 
 protected:
     void keyPressEvent(QKeyEvent* event) override;

src/Gameover.cpp

@@ -0,0 +1,35 @@
+//
+// Created by breizhhardware on 29/04/24.
+//
+
+#include "Gameover.h"
+
+Gameover::Gameover(QWidget *parent) : QGraphicsScene(parent) {
+    gameOverLabel = new QGraphicsTextItem("Game Over");
+    gameOverLabel->setPos(640, 360);
+    gameOverLabel->setDefaultTextColor(Qt::red);
+    addItem(gameOverLabel);
+
+    auto* layout = new QVBoxLayout();
+    auto* restartButton = new QPushButton("Restart", parent);
+    connect(restartButton, &QPushButton::clicked, this, &Gameover::restartGame);
+    layout->addWidget(restartButton);
+
+    auto* returnButton = new QPushButton("Return to menu", parent);
+    connect(returnButton, &QPushButton::clicked, this, &Gameover::returnToMenu);
+    layout->addWidget(returnButton);
+
+    auto* widget = new QWidget();
+    widget->setLayout(layout);
+
+    auto* proxy = addWidget(widget);
+    proxy->setPos(640, 400);
+}
+
+void Gameover::restartGame() {
+    emit restartGameSignal();
+}
+
+void Gameover::returnToMenu() {
+    emit returnToMenuSignal();
+}

src/Gameover.h

@@ -0,0 +1,33 @@
+//
+// Created by breizhhardware on 29/04/24.
+//
+
+#ifndef POULPES_DE_L_ESPACE_LA_DERNIERE_LIGNE_DE_DEFENSE_GAMEOVER_H
+#define POULPES_DE_L_ESPACE_LA_DERNIERE_LIGNE_DE_DEFENSE_GAMEOVER_H
+#include <QGraphicsScene>
+#include <QGraphicsTextItem>
+#include <QPushButton>
+#include <QVBoxLayout>
+#include <QGraphicsProxyWidget>
+
+class Gameover : public QGraphicsScene
+{
+    Q_OBJECT
+public:
+    Gameover(QWidget* parent = nullptr);
+
+private:
+    QGraphicsTextItem* gameOverLabel;
+
+private slots:
+    void restartGame();
+    void returnToMenu();
+
+signals:
+    void restartGameSignal();
+    void returnToMenuSignal();
+
+};
+
+
+#endif //POULPES_DE_L_ESPACE_LA_DERNIERE_LIGNE_DE_DEFENSE_GAMEOVER_H

src/Leaderboard.cpp

@@ -6,7 +6,8 @@
 #include <QVBoxLayout>
 #include <QSqlDatabase>
 
-Leaderboard::Leaderboard(QWidget *parent) : QWidget(parent) {
+Leaderboard::Leaderboard(QWidget *parent) : QGraphicsScene(parent) {
+    /*
     QVBoxLayout* layout = new QVBoxLayout(this);
 
     leaderboardTable = new QTableView(this);
@@ -26,4 +27,35 @@ Leaderboard::Leaderboard(QWidget *parent) : QWidget(parent) {
     leaderboardModel->select();
 
     leaderboardTable->setModel(leaderboardModel);
+     */
+    QGraphicsTextItem* leaderboardLabel = new QGraphicsTextItem("Leaderboard");
+    leaderboardLabel->setPlainText("Leaderboard");
+    addItem(leaderboardLabel);
+    // Add the table
+    leaderboardTable = new QTableView();
+    QGraphicsProxyWidget* proxy = this->addWidget(leaderboardTable);
+    proxy->setPos(0, leaderboardLabel->boundingRect().height());
+    QSqlDatabase db = QSqlDatabase::addDatabase("QSQLITE");
+    db.setDatabaseName("leaderboard.db");
+    if (!db.open()) {
+        qDebug() << "Error: unable to open database";
+    }
+
+    leaderboardModel = new QSqlTableModel(this, db);
+    leaderboardModel->setTable("leaderboard");
+    // Sort by number of waves completed in descending order
+    leaderboardModel->setSort(2, Qt::DescendingOrder);
+    leaderboardModel->select();
+
+    leaderboardTable->setModel(leaderboardModel);
+    // Add the return to menu button
+    auto* returnButton = new QPushButton("Return to menu");
+    QGraphicsProxyWidget* returnProxy = this->addWidget(returnButton);
+    returnProxy->setPos(0, leaderboardLabel->boundingRect().height() + leaderboardTable->height());
+    // Connect the return to menu button to the returnToMenu slot
+    connect(returnButton, &QPushButton::clicked, this, &Leaderboard::returnToMenu);
+}
+
+void Leaderboard::returnToMenu() {
+    emit returnToMenuSignal();
 }

src/Leaderboard.h

@@ -4,19 +4,29 @@
 
 #ifndef POULPES_DE_L_ESPACE_LA_DERNIERE_LIGNE_DE_DEFENSE_LEADERBOARD_H
 #define POULPES_DE_L_ESPACE_LA_DERNIERE_LIGNE_DE_DEFENSE_LEADERBOARD_H
-#include <QWidget>
+#include <QGraphicsScene>
+#include <QGraphicsTextItem>
+#include <QPushButton>
+#include <QVBoxLayout>
+#include <QGraphicsProxyWidget>
 #include <QTableView>
 #include <QtSql/QSqlTableModel>
 
-class Leaderboard : public QWidget
+class Leaderboard : public QGraphicsScene
 {
-Q_OBJECT
+    Q_OBJECT
 public:
     Leaderboard(QWidget* parent = nullptr);
 
 private:
     QTableView* leaderboardTable;
     QSqlTableModel* leaderboardModel;
+
+private slots:
+    void returnToMenu();
+
+signals:
+    void returnToMenuSignal();
 };
 
 

src/Menu.cpp

@@ -3,7 +3,6 @@
 //
 
 #include "Menu.h"
-#include <iostream>
 
 Menu::Menu(QWidget *parent) : QWidget(parent) {
     game = nullptr;
@@ -70,8 +69,12 @@ void Menu::onRulesButtonClicked() {
 }
 
 void Menu::onLeaderboardButtonClicked() {
+    removeButtons();
     auto* leaderboard = new Leaderboard();
-    leaderboard->show();
+    view->setFixedSize(1280, 720);
+    view->show();
+    view->setScene(leaderboard);
+    QObject::connect(leaderboard, &Leaderboard::returnToMenuSignal, this, &Menu::showMenu);
 }
 
 void Menu::onQuitButtonClicked() {
@@ -79,11 +82,33 @@ void Menu::onQuitButtonClicked() {
 }
 
 void Menu::showMenu() {
-    view->hide();
+    if(view){
+        view->hide();
+    }
     this->setVisible(true);
     this->raise();
     playButton->show();
     rulesButton->show();
     leaderboardButton->show();
     quitButton->show();
-}
+}
+
+void Menu::showMenuGO() {
+    this->setVisible(true);
+    this->raise();
+    playButton->show();
+    rulesButton->show();
+    leaderboardButton->show();
+    quitButton->show();
+}
+
+void Menu::showGameOver() {
+    handleGameOver();
+    qDebug() << "Game Over signal received in Menu::showGameOver()";
+    // Return to the menu
+    showMenu();
+}
+
+void Menu::handleGameOver(){
+    game->deleteLater();
+}

src/Menu.h

@@ -8,20 +8,26 @@
 #include "Rules.h"
 #include "Leaderboard.h"
 #include "MainWindow.h"
+#include "Gameover.h"
 #include <QVBoxLayout>
 #include <QApplication>
 #include <QWidget>
 #include <QPushButton>
 #include <QGraphicsView>
 
+class Game;
+
+class MainWindow;
+
 class Menu : public QWidget {
     Q_OBJECT
-
 public:
-    Menu(QWidget* parent = nullptr);
+    Menu(QWidget *parent = nullptr);
+    void showMenuGO();
 
 public slots:
     void showMenu();
+    void showGameOver();
 
 private slots:
     void onPlayButtonClicked();
@@ -30,14 +36,15 @@ private slots:
     void onQuitButtonClicked();
 
 private:
-    QPushButton* playButton;
-    QPushButton* rulesButton;
-    QPushButton* leaderboardButton;
-    QPushButton* quitButton;
-    QGraphicsView* view;
-    Game* game;
+    QPushButton *playButton;
+    QPushButton *rulesButton;
+    QPushButton *leaderboardButton;
+    QPushButton *quitButton;
+    QGraphicsView *view;
+    Game *game;
     void removeButtons();
+    void handleGameOver();
+
 };
 
-
 #endif //POULPES_DE_L_ESPACE_LA_DERNIERE_LIGNE_DE_DEFENSE_MENU_H

src/Player.cpp

@@ -40,6 +40,9 @@ void Player::setPosition(int x, int y) {
         if (enemy->getX() == x && enemy->getY() == y) {
             // If there is an enemy, call the touchEnemy method
             touchEnemy(enemy);
+            if(health <= 0) {
+                return;
+            }
             break;
         }
     }
@@ -58,18 +61,13 @@ QGraphicsPixmapItem* Player::getGraphics() {
     return graphics;
 }
 
-int Player::getX() {
-    return x;
-}
-
-int Player::getY() {
-    return y;
-}
-
 void Player::touchEnemy(Enemy* enemy) {
     // Subtract the enemy's damage from the player's health
-    health -= enemy->getDamage();
+    takeDamage(enemy->getDamage());
 
+    if(health <= 0) {
+        return;
+    }
     // Add the enemy's coin drop to the player's gold
     game.userGold += enemy->getCoinDrop();
 
@@ -82,3 +80,11 @@ void Player::touchEnemy(Enemy* enemy) {
     delete enemy;
 }
 
+void Player::takeDamage(int damage) {
+    health -= damage;
+    if (health <= 0) {
+        // Game over
+        game.gameOver();
+    }
+}
+

src/Player.h

@@ -15,6 +15,8 @@
 
 class Game;
 
+class Enemy;
+
 class Player : public Mob
 {
     Game& game;
@@ -23,10 +25,9 @@ public:
     void setPosition(Tile* tile);
     void setPosition(int x, int y);
     void getPlayerPosition();
-    int getX();
-    int getY();
     QGraphicsPixmapItem* getGraphics();
     void touchEnemy(Enemy* enemy);
+    void takeDamage(int damage);
 
 private:
     QGraphicsPixmapItem* graphics;

src/Rules.cpp

@@ -3,13 +3,14 @@
 //
 
 #include "Rules.h"
-#include <QVBoxLayout>
-#include <QLayout>
-#include <iostream>
 
 Rules::Rules(QObject* parent) : QGraphicsScene(parent) {
     auto* rulesText = new QGraphicsTextItem();
-    rulesText->setPlainText("Rules are simple:\n - You have to defend your base from the incoming waves of enemies.\n - You can place towers on the map to help you defend.\n - You can also move your personnal ship to help defend using the arrow key.\n - Good luck!");
+    rulesText->setPlainText("Rules are simple:\n"
+                            " - You have to defend your base from the incoming waves of enemies.\n"
+                            " - You can place towers on the map to help you defend.\n"
+                            " - You can also move your personnal ship to help defend using the arrow key.\n"
+                            " - Good luck!");
     addItem(rulesText);
     // Add the return to menu button
     auto* returnButton = new QPushButton("Return to menu");

src/Rules.h

@@ -9,6 +9,7 @@
 #include <QGraphicsScene>
 #include <QPushButton>
 #include <QGraphicsProxyWidget>
+#include <QVBoxLayout>
 
 class Rules : public QGraphicsScene
 {