Passage de Game plutôt que Level

include/block.hpp

@@ -5,6 +5,9 @@
 #include <memory>
 #include "object.hpp"
 
+class Game;
+class Level;
+
 class Block : public Object {
 public:
     typedef std::shared_ptr<Block> Ptr;
@@ -59,7 +62,7 @@ public:
     /**
      * Appelé lorsque le bloc est activé par un objet
      */
-    virtual void activate(Level& level, Object* object);
+    virtual void activate(Game& game, Object* object);
 
     /**
      * Appelé lorsque le bloc a été tué. Si cette fonction

include/finish_block.hpp

@@ -4,7 +4,7 @@
 #include <SFML/Graphics.hpp>
 #include <memory>
 #include "block.hpp"
-#include "level.hpp"
+#include "game.hpp"
 
 class FinishBlock : public Block {
 public:
@@ -39,7 +39,7 @@ public:
     /**
      * Appelé lorsque le bloc d'arrivée est activé par un objet
      */
-    virtual void activate(Level& level, Object* object);
+    virtual void activate(Game& game, Object* object);
 
     /**
      * Récupère l'identifiant de type des blocs d'arrivée

include/game.hpp

@@ -15,6 +15,11 @@ public:
      */
     enum class Mode {NORMAL, PAUSED, WON, LOST};
 
+    /**
+     * Les différentes raisons de mort
+     */
+    enum class DeathCause {NONE, OUT_OF_BOUNDS, KILLED, TIME_OUT};
+
 private:
     WidgetTimer widget_timer;
     sf::Time next_frame_time;
@@ -25,6 +30,7 @@ private:
 
     std::shared_ptr<Editor> return_state;
     Mode mode;
+    DeathCause death_cause;
 
     /**
      * Met à jour les objets du jeu pour
@@ -84,11 +90,13 @@ public:
      * Récupère le mode actuel de jeu
      */
     Mode getMode();
+    DeathCause getDeathCause();
 
     /**
      * Modifie le mode actuel de jeu
      */
     void setMode(Mode set_mode);
+    void setDeathCause(DeathCause set_death_cause);
 };
 
 #endif

include/gravity_block.hpp

@@ -4,7 +4,7 @@
 #include <SFML/Graphics.hpp>
 #include <memory>
 #include "block.hpp"
-#include "level.hpp"
+#include "game.hpp"
 
 class GravityBlock : public Block {
 public:
@@ -42,7 +42,7 @@ public:
     /**
      * Appelé lorsque le bloc de gravité est activé par un objet
      */
-    virtual void activate(Level& level, Object* object);
+    virtual void activate(Game& game, Object* object);
 
     /**
      * Récupère l'identifiant de type des blocs de gravité

include/kill_block.hpp

@@ -4,7 +4,7 @@
 #include <SFML/Graphics.hpp>
 #include <memory>
 #include "block.hpp"
-#include "level.hpp"
+#include "game.hpp"
 
 class KillBlock : public Block {
 public:
@@ -39,7 +39,7 @@ public:
     /**
      * Appelé lorsque le bloc tueur est activé par un objet
      */
-    virtual void activate(Level& level, Object* object);
+    virtual void activate(Game& game, Object* object);
 
     /**
      * Récupère l'identifiant de type des blocs tueurs

include/object.hpp

@@ -34,7 +34,7 @@ protected:
     /**
      * Calcule les forces appliquées à l'objet
      */
-    virtual sf::Vector2f getForces(const Level& level) const;
+    virtual sf::Vector2f getForces(const Game& game) const;
 
     /**
      * Initialisation des propriétés communes à tous les objets
@@ -79,7 +79,7 @@ public:
     /**
      * Appelé lorsque l'objet est activé par un autre
      */
-    virtual void activate(Level& level, Object* object) = 0;
+    virtual void activate(Game& game, Object* object) = 0;
 
     /**
      * Appelé lorsque l'objet a été tué. Si cette fonction
@@ -106,7 +106,7 @@ public:
      * Met à jour la vitesse de l'objet selon les
      * forces qui lui sont appliquées
      */
-    virtual void updateVelocity(const Level& level);
+    virtual void updateVelocity(const Game& game);
 
     /**
      * Met à jour la position de l'objet selon sa
@@ -125,7 +125,7 @@ public:
      * et l'objet passé en paramètre selon la normale
      * donnée
      */
-    virtual void solveCollision(Level& level, Object::Ptr obj, const sf::Vector2f& normal);
+    virtual void solveCollision(Game& game, Object::Ptr obj, const sf::Vector2f& normal);
 
     /**
      * Application de la correction positionnelle sur

include/player.hpp

@@ -17,7 +17,7 @@ protected:
     /**
      * Calcule les forces appliquées au joueur
      */
-    virtual sf::Vector2f getForces(const Level& level) const;
+    virtual sf::Vector2f getForces(const Game& game) const;
 
     /**
      * Initialisation des propriétés du joueur donné
@@ -57,7 +57,7 @@ public:
     /**
      * Appelé lorsque le joueur est activé par un objet
      */
-    virtual void activate(Level& level, Object* object);
+    virtual void activate(Game& game, Object* object);
 
     /**
      * Appelé lorsque le jouer a été tué. Si cette fonction

include/switch_block.hpp

@@ -4,7 +4,7 @@
 #include <SFML/Graphics.hpp>
 #include <memory>
 #include "block.hpp"
-#include "level.hpp"
+#include "game.hpp"
 
 class SwitchBlock : public Block {
 public:
@@ -39,7 +39,7 @@ public:
     /**
      * Appelé lorsque le bloc changeur est activé par un objet
      */
-    virtual void activate(Level& level, Object* object);
+    virtual void activate(Game& game, Object* object);
 
     /**
      * Récupère l'identifiant de type des blocs changeurs

src/block.cpp

@@ -1,5 +1,6 @@
 #include "block.hpp"
 #include "level.hpp"
+#include "game.hpp"
 #include "player.hpp"
 #include "constants.hpp"
 #include "resource_manager.hpp"
@@ -74,7 +75,7 @@ void Block::draw(Level& level) {
     }
 }
 
-void Block::activate(Level& level, Object* object) {
+void Block::activate(Game& game, Object* object) {
     // ne rien faire si le bloc est activé.
     // Ceci est un bloc de base qui n'a pas a réagir
     // aux activations

src/finish_block.cpp

@@ -1,5 +1,5 @@
 #include "finish_block.hpp"
-#include "level.hpp"
+#include "game.hpp"
 
 const unsigned int FinishBlock::TYPE_ID = 4;
 
@@ -16,8 +16,8 @@ void FinishBlock::prepareDraw(ResourceManager& resources) {
     sprite.setTexture(resources.getTexture("finish_block.tga"), true);
 }
 
-void FinishBlock::activate(Level& level, Object* object) {
+void FinishBlock::activate(Game& game, Object* object) {
-    Block::activate(level, object);
+    Block::activate(game, object);
     // TODO: implémenter le comportmeent des blocs d'arrivée
 }
 

src/game.cpp

@@ -21,6 +21,8 @@ void Game::begin() {
     }
 
     mode = Game::Mode::NORMAL;
+    death_cause = Game::DeathCause::NONE;
+
     time_left = getTotalTime();
     getWindow().setFramerateLimit(0);
 }
@@ -65,6 +67,39 @@ void Game::frame() {
         // si on est en mode normal
         if (getMode() == Game::Mode::NORMAL) {
             update();
+        } else {
+            // TODO: pour le débogage affichage du mode actuel
+            switch (getMode()) {
+            case Game::Mode::NORMAL:
+                std::cout << "<< Reprise >>" << std::endl;
+                break;
+            case Game::Mode::PAUSED:
+                std::cout << "<< En pause >>" << std::endl;
+                break;
+            case Game::Mode::WON:
+                std::cout << "<< Gagné ! >>" << std::endl;
+                break;
+            case Game::Mode::LOST:
+                std::cout << "<< Perdu : ";
+
+                switch (getDeathCause()) {
+                case Game::DeathCause::NONE:
+                    std::cout << "sans aucune raison";
+                    break;
+                case Game::DeathCause::OUT_OF_BOUNDS:
+                    std::cout << "sortie du cadre";
+                    break;
+                case Game::DeathCause::KILLED:
+                    std::cout << "tué par bloc";
+                    break;
+                case Game::DeathCause::TIME_OUT:
+                    std::cout << "temps écoulé";
+                    break;
+                }
+
+                std::cout << " !" << std::endl;
+                break;
+            }
         }
 
         // on s'assure que la caméra soit centrée sur nos joueurs
@@ -129,6 +164,7 @@ void Game::update() {
     // on a perdu
     if (time_left <= 0) {
         setMode(Game::Mode::LOST);
+        setDeathCause(Game::DeathCause::TIME_OUT);
         return;
     } else {
         time_left -= Manager::FRAME_TIME.asSeconds();
@@ -222,23 +258,14 @@ Game::Mode Game::getMode() {
     return mode;
 }
 
+Game::DeathCause Game::getDeathCause() {
+    return death_cause;
+}
+
 void Game::setMode(Game::Mode set_mode) {
     mode = set_mode;
-
+}
-    // TODO: pour le débogage
+
-    // affichage du mode actuel
+void Game::setDeathCause(Game::DeathCause set_death_cause) {
-    switch (set_mode) {
+    death_cause = set_death_cause;
-    case Game::Mode::NORMAL:
-        std::cout << "<< Reprise >>" << std::endl;
-        break;
-    case Game::Mode::PAUSED:
-        std::cout << "<< En pause >>" << std::endl;
-        break;
-    case Game::Mode::WON:
-        std::cout << "<< Gagné ! >>" << std::endl;
-        break;
-    case Game::Mode::LOST:
-        std::cout << "<< Perdu ! >>" << std::endl;
-        break;
-    }
 }

src/gravity_block.cpp

@@ -1,5 +1,5 @@
 #include "gravity_block.hpp"
-#include "level.hpp"
+#include "game.hpp"
 
 const unsigned int GravityBlock::TYPE_ID = 3;
 
@@ -35,12 +35,12 @@ void GravityBlock::prepareDraw(ResourceManager& resources) {
     sprite.setTexture(resources.getTexture(texture_name + ".tga"));
 }
 
-void GravityBlock::activate(Level& level, Object* object) {
+void GravityBlock::activate(Game& game, Object* object) {
-    Block::activate(level, object);
+    Block::activate(game, object);
 
     // lorsque le bloc est activé, il transmet son
     // sens de gravité au niveau
-    level.setGravityDirection(gravity_direction);
+    game.setGravityDirection(gravity_direction);
 }
 
 unsigned int GravityBlock::getTypeId() const {

src/kill_block.cpp

@@ -1,5 +1,5 @@
 #include "kill_block.hpp"
-#include "level.hpp"
+#include "game.hpp"
 
 const unsigned int KillBlock::TYPE_ID = 5;
 
@@ -15,8 +15,8 @@ void KillBlock::prepareDraw(ResourceManager& resources) {
     sprite.setTexture(resources.getTexture("kill_block.tga"));
 }
 
-void KillBlock::activate(Level& level, Object* object) {
+void KillBlock::activate(Game& game, Object* object) {
-    Block::activate(level, object);
+    Block::activate(game, object);
     // TODO: implémenter le comportmeent des blocs tueurs
 }
 

src/object.cpp

@@ -1,5 +1,5 @@
 #include "object.hpp"
-#include "level.hpp"
+#include "game.hpp"
 #include "constants.hpp"
 #include "collision.hpp"
 #include <cmath>
@@ -145,12 +145,12 @@ void Object::save(std::ofstream& file) const {
     file.write(&null_byte, 1);
 }
 
-sf::Vector2f Object::getForces(const Level& level) const {
+sf::Vector2f Object::getForces(const Game& game) const {
     sf::Vector2f forces(0, 0);
-    const std::vector<Object::Ptr>& objects = level.getObjects();
+    const std::vector<Object::Ptr>& objects = game.getObjects();
 
     // force de gravité
-    forces += getMass() * level.getGravity();
+    forces += getMass() * game.getGravity();
 
     // force d'attraction entre objets chargés
     if (getCharge() != 0) {
@@ -188,8 +188,8 @@ sf::Vector2f Object::getForces(const Level& level) const {
     return forces;
 }
 
-void Object::updateVelocity(const Level& level) {
+void Object::updateVelocity(const Game& game) {
-    acceleration = getForces(level) * getMassInvert();
+    acceleration = getForces(game) * getMassInvert();
     velocity += acceleration * Manager::FRAME_TIME.asSeconds();
 }
 
@@ -221,7 +221,7 @@ bool Object::detectCollision(Object::Ptr obj, CollisionData& data) const {
     return getCollisionData(data);
 }
 
-void Object::solveCollision(Level& level, Object::Ptr obj, const sf::Vector2f& normal) {
+void Object::solveCollision(Game& game, Object::Ptr obj, const sf::Vector2f& normal) {
     // si les deux objets sont de masse infinie, réinitialisation
     // des vitesses en tant que collision
     if (getMassInvert() == 0 && obj->getMassInvert() == 0) {
@@ -241,8 +241,8 @@ void Object::solveCollision(Level& level, Object::Ptr obj, const sf::Vector2f& n
 
     // en ce point, on est bertins qu'une collision a eu lieu.
     // activation réciproque des deux objets
-    activate(level, obj.get());
+    activate(game, obj.get());
-    obj->activate(level, this);
+    obj->activate(game, this);
 
     // on utilise le plus petit coefficient de friction entre les
     // deux objets comme le coefficient de la collision

src/player.cpp

@@ -1,6 +1,6 @@
 #include "player.hpp"
 #include "game.hpp"
-#include "level.hpp"
+#include "game.hpp"
 #include "block.hpp"
 #include "constants.hpp"
 #include <array>
@@ -36,27 +36,27 @@ void Player::save(std::ofstream& file) const {
     Object::save(file);
 }
 
-sf::Vector2f Player::getForces(const Level& level) const {
+sf::Vector2f Player::getForces(const Game& game) const {
-    sf::Vector2f forces = Object::getForces(level);
+    sf::Vector2f forces = Object::getForces(game);
 
     // déplacement de la balle après appui sur les touches de direction
     if (getPlayerNumber() == 0) {
-        if (level.getManager().isKeyPressed(sf::Keyboard::Left)) {
+        if (game.getManager().isKeyPressed(sf::Keyboard::Left)) {
-            forces += level.getLeftDirection();
+            forces += game.getLeftDirection();
         }
 
-        if (level.getManager().isKeyPressed(sf::Keyboard::Right)) {
+        if (game.getManager().isKeyPressed(sf::Keyboard::Right)) {
-            forces += level.getRightDirection();
+            forces += game.getRightDirection();
         }
     }
 
     if (getPlayerNumber() == 1) {
-        if (level.getManager().isKeyPressed(sf::Keyboard::Q)) {
+        if (game.getManager().isKeyPressed(sf::Keyboard::Q)) {
-            forces += level.getLeftDirection();
+            forces += game.getLeftDirection();
         }
 
-        if (level.getManager().isKeyPressed(sf::Keyboard::D)) {
+        if (game.getManager().isKeyPressed(sf::Keyboard::D)) {
-            forces += level.getRightDirection();
+            forces += game.getRightDirection();
         }
     }
 
@@ -90,7 +90,7 @@ void Player::draw(Level& level) {
     level.getWindow().draw(sprite);
 }
 
-void Player::activate(Level& level, Object* object) {
+void Player::activate(Game& game, Object* object) {
     // ne rien faire si le joueur est activé.
     // en règle générale, c'est l'objet activé par le joueur
     // qui s'occupe de la réponse

src/switch_block.cpp

@@ -1,5 +1,5 @@
 #include "switch_block.hpp"
-#include "level.hpp"
+#include "game.hpp"
 
 const unsigned int SwitchBlock::TYPE_ID = 6;
 
@@ -15,8 +15,8 @@ void SwitchBlock::prepareDraw(ResourceManager& resources) {
     sprite.setTexture(resources.getTexture("switch_block.tga"));
 }
 
-void SwitchBlock::activate(Level& level, Object* object) {
+void SwitchBlock::activate(Game& game, Object* object) {
-    Block::activate(level, object);
+    Block::activate(game, object);
     // TODO: implémenter le comportmeent des blocs changeurs
 }