Mais c'est la mort qui t'a assassinée

include/block.hpp

@@ -58,7 +58,13 @@ public:
     /**
      * Appelé lorsque le bloc est activé par un objet
      */
-    virtual void activated(Level& level, Object* object);
+    virtual void activate(Level& level, Object* object);
+
+    /**
+     * Appelé lorsque le bloc a été tué. Si cette fonction
+     * est appelé, le bloc sera supprimé à la frame suivante
+     */
+    virtual void kill(Game& game);
 
     /**
      * Récupère l'identifiant de type des blocs

include/game.hpp

@@ -18,6 +18,8 @@ public:
 private:
     WidgetTimer widget_timer;
     sf::Time next_frame_time;
+    std::vector<Object::Ptr> pending_kill;
+
     bool test_mode;
     std::shared_ptr<Editor> return_state;
     Mode mode;
@@ -28,6 +30,12 @@ private:
      */
     void update();
 
+    /**
+     * Vérifie si l'objet donné se trouve dans
+     * la zone de jeu ou non
+     */
+    bool isInZone(Object::Ptr object);
+
 protected:
     /**
      * Dessine tous les objets, le fond et

include/gravity_block.hpp

@@ -42,7 +42,7 @@ public:
     /**
      * Appelé lorsque le bloc de gravité est activé par un objet
      */
-    virtual void activated(Level& level, Object* object);
+    virtual void activate(Level& level, Object* object);
 
     /**
      * Récupère l'identifiant de type des blocs de gravité

include/level.hpp

@@ -171,6 +171,7 @@ public:
      * Supprime l'objet donné
      */
     void removeObject(Object::Ptr object);
+    void removeObject(Object* object);
 
     /**
      * Récupère la zone du niveau

include/object.hpp

@@ -9,6 +9,7 @@
 #include "resource_manager.hpp"
 
 class Level;
+class Game;
 
 class Object {
 public:
@@ -78,7 +79,13 @@ public:
     /**
      * Appelé lorsque l'objet est activé par un autre
      */
-    virtual void activated(Level& level, Object* object) = 0;
+    virtual void activate(Level& level, Object* object) = 0;
+
+    /**
+     * Appelé lorsque l'objet a été tué. Si cette fonction
+     * est appelé, l'objet sera supprimé à la frame suivante
+     */
+    virtual void kill(Game& game) = 0;
 
     /**
      * Récupère l'identifiant de type de cet objet

include/player.hpp

@@ -57,7 +57,13 @@ public:
     /**
      * Appelé lorsque le joueur est activé par un objet
      */
-    virtual void activated(Level& level, Object* object);
+    virtual void activate(Level& level, Object* object);
+
+    /**
+     * Appelé lorsque le jouer a été tué. Si cette fonction
+     * est appelé, le joueur sera supprimé à la frame suivante
+     */
+    virtual void kill(Game& game);
 
     /**
      * Récupère l'identifiant de type des joueurs

src/block.cpp

@@ -73,12 +73,16 @@ void Block::draw(Level& level) {
     }
 }
 
-void Block::activated(Level& level, Object* object) {
+void Block::activate(Level& level, 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
 }
 
+void Block::kill(Game& game) {
+    // rien à faire de plus si le bloc a été tué
+}
+
 sf::FloatRect Block::getAABB() const {
     return sf::FloatRect(
         getPosition().x - Constants::GRID / 2,

src/game.cpp

@@ -1,4 +1,5 @@
 #include <cmath>
+#include <iostream>
 #include "game.hpp"
 #include "player.hpp"
 #include "constants.hpp"
@@ -120,6 +121,23 @@ void Game::update() {
     std::vector<CollisionData> colliding;
     std::vector<Object::Ptr>& objects = getObjects();
 
+    // on tue les objets qui étaient déjà planifiés pour mourir
+    for (auto it = pending_kill.begin(); it != pending_kill.end(); it++) {
+        removeObject(*it);
+    }
+
+    pending_kill.empty();
+
+    // détection des objets en dehors de la zone de jeu
+    for (auto it = objects.begin(); it != objects.end(); it++) {
+        if (!isInZone(*it)) {
+            // l'objet est sorti de la zone, on le signale et on
+            // planifie sa mort à la prochaine frame
+            (*it)->kill(*this);
+            pending_kill.push_back(*it);
+        }
+    }
+
     // détection des objets en collision
     for (unsigned int i = 0; i < objects.size(); i++) {
         Object::Ptr obj_a = objects[i];
@@ -162,6 +180,27 @@ void Game::update() {
     }
 }
 
+/**
+ * Implémentation tirée de
+ * http://stackoverflow.com/a/2922778/3452708
+ */
+bool Game::isInZone(Object::Ptr object) {
+    std::vector<sf::Vector2f>& zone = getZone();
+    sf::Vector2f pos = object->getPosition();
+    unsigned int vertices = getZone().size();
+    bool result = false;
+
+    for (unsigned int i = 0, j = vertices - 1; i < vertices; j = i++) {
+        if (((zone[i].y > pos.y) != (zone[j].y > pos.y)) &&
+           (pos.x < (zone[j].x - zone[i].x) * (pos.y - zone[i].y) /
+           (zone[j].y - zone[i].y) + zone[i].x)) {
+            result = !result;
+        }
+    }
+
+    return result;
+}
+
 bool Game::getTestMode() {
     return test_mode;
 }

src/gravity_block.cpp

@@ -35,8 +35,8 @@ std::string GravityBlock::getTexture() {
     return texture_name + ".tga";
 }
 
-void GravityBlock::activated(Level& level, Object* object) {
-    Block::activated(level, object);
+void GravityBlock::activate(Level& level, Object* object) {
+    Block::activate(level, object);
 
     // lorsque le bloc est activé, il transmet son
     // sens de gravité au niveau

src/object.cpp

@@ -234,8 +234,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
-    activated(level, obj.get());
-    obj->activated(level, this);
+    activate(level, obj.get());
+    obj->activate(level, this);
 
     // on utilise le plus petit coefficient de friction entre les
     // deux objets comme le coefficient de la collision

src/player.cpp

@@ -1,4 +1,5 @@
 #include "player.hpp"
+#include "game.hpp"
 #include "level.hpp"
 #include "block.hpp"
 #include "constants.hpp"
@@ -89,12 +90,16 @@ void Player::draw(Level& level) {
     level.getWindow().draw(sprite);
 }
 
-void Player::activated(Level& level, Object* object) {
+void Player::activate(Level& level, 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
 }
 
+void Player::kill(Game& game) {
+    game.setMode(Game::Mode::LOST);
+}
+
 void Player::updatePosition() {
     // calcul de la différence de position pour connaître
     // (approximativement) la rotation de la balle