diff --git a/include/editor.hpp b/include/editor.hpp
index b5c04e9..c6a325b 100644
--- a/include/editor.hpp
+++ b/include/editor.hpp
@@ -1,10 +1,11 @@
 #ifndef __PTF_EDITOR_HPP__
 #define __PTF_EDITOR_HPP__
 
-#include <unordered_map>
 #include "level.hpp"
 #include "widget_timer.hpp"
 #include "widget_toolbar.hpp"
+#include <unordered_map>
+#include <memory>
 
 /**
  * La classe Editor permet l'édition de
@@ -93,11 +94,6 @@ public:
     Editor(Manager& manager);
     virtual ~Editor();
 
-    /**
-     * Appelé par le manager lorsque l'état est utilisé
-     */
-    virtual void begin();
-
     /**
      * Traite l'événement donné
      */
diff --git a/include/game.hpp b/include/game.hpp
index 8044c2d..b01bed2 100644
--- a/include/game.hpp
+++ b/include/game.hpp
@@ -25,7 +25,6 @@ private:
     sf::Time next_frame_time;
     std::vector<Object::Ptr> pending_kill;
 
-    bool test_mode;
     float time_left;
 
     std::shared_ptr<Editor> return_state;
@@ -60,11 +59,6 @@ public:
     Game(Manager& manager);
     virtual ~Game();
 
-    /**
-     * Appelé par le manager lorsque l'état est utilisé
-     */
-    virtual void begin();
-
     /**
      * Traite l'événement donné
      */
@@ -80,17 +74,6 @@ public:
      */
     void kill(Object::Ptr object);
 
-    /**
-     * Récupère si on est en mode test ou pas
-     */
-    bool getTestMode();
-
-    /**
-     * Mise en mode test : l'appui sur espace renvoie
-     * vers l'éditeur donné
-     */
-    void setTestMode(std::shared_ptr<Editor> set_return_state);
-
     /**
      * Récupère le mode actuel de jeu
      */
diff --git a/include/level.hpp b/include/level.hpp
index fa87a44..e9733a2 100644
--- a/include/level.hpp
+++ b/include/level.hpp
@@ -85,11 +85,6 @@ public:
      */
     void save(std::string path);
 
-    /**
-     * Appelé par le manager lorsque l'état est utilisé
-     */
-    virtual void begin();
-
     /**
      * Traite l'événement donné
      */
diff --git a/include/manager.hpp b/include/manager.hpp
index bc7a4d7..0712f1f 100644
--- a/include/manager.hpp
+++ b/include/manager.hpp
@@ -4,6 +4,7 @@
 #include "resource_manager.hpp"
 #include "state.hpp"
 #include <memory>
+#include <stack>
 
 /**
  * Gestionnaire principal de tous les états, vues et
@@ -18,10 +19,7 @@ private:
     sf::View gui_view;
     sf::String title;
 
-    std::shared_ptr<State> state;
-    std::shared_ptr<State> next_state;
-
-    bool running;
+    std::stack<std::unique_ptr<State>> states;
 
 public:
     /**
@@ -47,19 +45,14 @@ public:
     void start();
 
     /**
-     * Termine la boucle principale et quitte le jeu
+     * Empile l'état donné
      */
-    void quit();
+    void pushState(std::unique_ptr<State> set_state);
 
     /**
-     * Renvoie l'état actuel du jeu
+     * Dépile l'état actuel
      */
-    std::shared_ptr<State> getState();
-
-    /**
-     * Charge l'état donné dans le jeu
-     */
-    void setState(std::shared_ptr<State> set_state);
+    void popState();
 
     /**
      * Renvoie la fenêtre actuellement utilisée pour le dessin
diff --git a/include/menu.hpp b/include/menu.hpp
index 37cd940..2503e8a 100644
--- a/include/menu.hpp
+++ b/include/menu.hpp
@@ -46,11 +46,6 @@ public:
     Menu(Manager& manager);
     virtual ~Menu();
 
-    /**
-     * Appelé par le manager lorsque l'état est utilisé
-     */
-    virtual void begin();
-
     /**
      * Traite l'événement donné
      */
diff --git a/include/state.hpp b/include/state.hpp
index db25b59..517cc87 100644
--- a/include/state.hpp
+++ b/include/state.hpp
@@ -18,11 +18,6 @@ public:
     State(Manager& manager);
     virtual ~State();
 
-    /**
-     * Appelé par le manager lorsque l'état est utilisé
-     */
-    virtual void begin() = 0;
-
     /**
      * Traite l'événement donné
      */
diff --git a/res/textures/regles_jeu.png b/res/textures/bg_rules.png
similarity index 100%
rename from res/textures/regles_jeu.png
rename to res/textures/bg_rules.png
diff --git a/src/editor.cpp b/src/editor.cpp
index 24c4098..5566707 100644
--- a/src/editor.cpp
+++ b/src/editor.cpp
@@ -29,17 +29,14 @@ inline sf::Vector2f roundVectorToGrid(sf::Vector2f input) {
 Editor::Editor(Manager& manager) : Level(manager),
     drag_control_point(nullptr), drag_mode(Editor::DragMode::NONE),
     widget_timer(manager, true, std::bind(&Editor::setTotalTime, this, std::placeholders::_1)),
-    widget_toolbar(manager) {}
-
-Editor::~Editor() {}
-
-void Editor::begin() {
-    Level::begin();
+    widget_toolbar(manager) {
 
     getResourceManager().playMusic("editor.ogg");
     getWindow().setFramerateLimit(Manager::FPS);
 }
 
+Editor::~Editor() {}
+
 void Editor::processEvent(const sf::Event& event) {
     Level::processEvent(event);
 
@@ -475,7 +472,7 @@ void Editor::selectAll() {
 }
 
 void Editor::test() {
-    std::shared_ptr<Game> game = std::shared_ptr<Game>(new Game(getManager()));
+    auto game = std::unique_ptr<Game>(new Game(getManager()));
     clearSelection();
 
     // copie des propriétés
@@ -498,7 +495,5 @@ void Editor::test() {
         game->getZone().push_back(*it);
     }
 
-    // mise en mode test
-    game->setTestMode(std::dynamic_pointer_cast<Editor>(getManager().getState()));
-    getManager().setState(game);
+    getManager().pushState(std::move(game));
 }
diff --git a/src/game.cpp b/src/game.cpp
index b295826..4215831 100644
--- a/src/game.cpp
+++ b/src/game.cpp
@@ -6,13 +6,7 @@
 
 Game::Game(Manager& manager) : Level(manager),
     widget_timer(manager, false),
-    next_frame_time(manager.getCurrentTime()),
-    test_mode(false), return_state(nullptr) {}
-
-Game::~Game() {}
-
-void Game::begin() {
-    Level::begin();
+    next_frame_time(manager.getCurrentTime()) {
 
     if (getMusic() != "") {
         getResourceManager().playMusic(getMusic());
@@ -27,19 +21,15 @@ void Game::begin() {
     getWindow().setFramerateLimit(0);
 }
 
+Game::~Game() {}
+
 void Game::processEvent(const sf::Event& event) {
     Level::processEvent(event);
 
     if (event.type == sf::Event::KeyPressed) {
-        // appui sur espace en mode test : retour à l'éditeur
-        if (event.key.code == sf::Keyboard::Space && test_mode) {
-            test_mode = false;
-
-            // on s'assure que la position de la caméra reste la même
-            return_state->setCamera(getCamera());
-
-            getManager().setState(return_state);
-            return_state = nullptr;
+        // appui sur espace : retour
+        if (event.key.code == sf::Keyboard::Space) {
+            getManager().popState();
         }
 
         // appui sur échap : échange entre le mode pause et normal
@@ -254,15 +244,6 @@ bool Game::isInZone(Object::Ptr object) {
     return result;
 }
 
-bool Game::getTestMode() {
-    return test_mode;
-}
-
-void Game::setTestMode(std::shared_ptr<Editor> set_return_state) {
-    return_state = set_return_state;
-    test_mode = true;
-}
-
 Game::Mode Game::getMode() {
     return mode;
 }
diff --git a/src/level.cpp b/src/level.cpp
index 7aa25bd..87cbc69 100644
--- a/src/level.cpp
+++ b/src/level.cpp
@@ -146,7 +146,12 @@ void loadLevel(
 }
 
 Level::Level(Manager& manager) : State(manager) {
+    sf::Vector2u window_size = getWindow().getSize();
+    gravity_direction = GravityDirection::SOUTH;
+
+    camera.setSize(window_size.x, window_size.y);
     camera.setCenter(0, 0);
+    camera_angle = 180.f;
 }
 
 Level::~Level() {}
@@ -264,13 +269,6 @@ void Level::save() {
     save(current_path);
 }
 
-void Level::begin() {
-    sf::Vector2u window_size = getWindow().getSize();
-    camera.setSize(window_size.x, window_size.y);
-    camera_angle = 180.f;
-    gravity_direction = GravityDirection::SOUTH;
-}
-
 void Level::processEvent(const sf::Event& event) {
     // lorsque la fenêtre est redimensionnée, mise à jour
     // de la taille de la caméra
diff --git a/src/main.cpp b/src/main.cpp
index 5432d0a..9ea798f 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -7,10 +7,10 @@
 
 int main() {
     Manager manager;
-    std::shared_ptr<Menu> menu = std::shared_ptr<Menu>(new Menu(manager));
+    auto menu = std::unique_ptr<Menu>(new Menu(manager));
 
     try {
-        manager.setState(menu);
+        manager.pushState(std::move(menu));
         manager.start();
     } catch (const std::exception& exception) {
         std::cerr << "Le programme a quitté après une erreur d'exécution." << std::endl;
diff --git a/src/manager.cpp b/src/manager.cpp
index cb5900e..acae3ea 100644
--- a/src/manager.cpp
+++ b/src/manager.cpp
@@ -3,7 +3,7 @@
 const unsigned int Manager::FPS = 60;
 const sf::Time Manager::FRAME_TIME = sf::seconds(1.f / Manager::FPS);
 
-Manager::Manager() : title(sf::String(L"")), state(NULL), next_state(NULL), running(false) {
+Manager::Manager() : title(sf::String(L"")) {
     // préchargement des textures
     resource_manager.preload();
 
@@ -19,28 +19,16 @@ Manager::Manager() : title(sf::String(L"")), state(NULL), next_state(NULL), runn
 }
 
 void Manager::start() {
-    running = true;
-
-    while (running) {
+    while (!states.empty()) {
         sf::Event event;
 
-        // si un changement d'état a été demandé, on l'effectue maintenant
-        if (next_state != nullptr) {
-            state = next_state;
-            next_state->begin();
-            next_state = nullptr;
-        }
-
-        // vérification de sécurité
-        if (state == NULL) {
-            throw std::runtime_error("Aucun état à afficher pour le jeu");
-        }
-
         // traitement des évènements reçus
         while (window.pollEvent(event)) {
-            // fermeture de la fenêtre
+            // fermeture de la fenêtre : on dépile tous les états
             if (event.type == sf::Event::Closed) {
-                quit();
+                while (!states.empty()) {
+                    states.pop();
+                }
             }
 
             // redimensionnement de la vue par défaut
@@ -50,27 +38,31 @@ void Manager::start() {
                 ));
             }
 
-            state->processEvent(event);
+            // s'il n'y a plus d'état, on quitte
+            if (states.empty()) {
+                return;
+            }
+
+            states.top()->processEvent(event);
+        }
+        
+        // s'il n'y a plus d'état, on quitte
+        if (states.empty()) {
+            return;
         }
 
         // affichage de la prochaine frame
-        state->frame();
+        states.top()->frame();
         window.display();
     }
 }
 
-void Manager::quit() {
-    running = false;
+void Manager::pushState(std::unique_ptr<State> set_state) {
+    states.push(std::move(set_state));
 }
 
-std::shared_ptr<State> Manager::getState() {
-    return state;
-}
-
-void Manager::setState(std::shared_ptr<State> set_state) {
-    // on ne change pas immédiatement l'état, on attend
-    // la prochaine frame pour éviter toute erreur de segmentation
-    next_state = set_state;
+void Manager::popState() {
+    states.pop();
 }
 
 sf::RenderWindow& Manager::getWindow() {
diff --git a/src/menu.cpp b/src/menu.cpp
index bb87ab8..3a86a4f 100644
--- a/src/menu.cpp
+++ b/src/menu.cpp
@@ -1,20 +1,21 @@
 #include "menu.hpp"
+#include "rules.hpp"
 #include "editor.hpp"
 #include "game.hpp"
 #include <cmath>
 
 const float MAX_WIDTH_PROPORTION = 1.f / 3.f;
 
-Menu::Menu(Manager& manager) : State(manager) {}
-Menu::~Menu() {}
-
-void Menu::begin() {
+Menu::Menu(Manager& manager) : State(manager) {
+    background.setTexture(getResourceManager().getTexture("bg_menu.tga"));
     loadMainMenu();
 
     getResourceManager().playMusic("menu.ogg");
     getWindow().setFramerateLimit(Manager::FPS);
 }
 
+Menu::~Menu() {}
+
 void Menu::processEvent(const sf::Event& event) {
     // gestion des touches
     if (event.type == sf::Event::KeyPressed) {
@@ -175,27 +176,22 @@ void Menu::loadLevelMenu() {
 }
 
 void Menu::loadRules() {
-    choices.clear();
-    getWindow().clear(sf::Color::Black);
-
-    sf::Texture& texture = getResourceManager().getTexture("regles_jeu.png");
-    background.setTexture(texture);
+    auto rules = std::unique_ptr<Rules>(new Rules(getManager()));
+    getManager().pushState(std::move(rules));
 }
 
 void Menu::launchEditor() {
-    std::shared_ptr<Editor> editor = std::shared_ptr<Editor>(new Editor(getManager()));
-
-    // TODO: charger dynamiquement le niveau dans l'éditeur
+    auto editor = std::unique_ptr<Editor>(new Editor(getManager()));
     editor->load(getResourceManager().getLevelPath("editor_result.dat"));
-    getManager().setState(editor);
+    getManager().pushState(std::move(editor));
 }
 
 void Menu::launchGame(std::string path) {
-    std::shared_ptr<Game> game = std::shared_ptr<Game>(new Game(getManager()));
+    auto game = std::unique_ptr<Game>(new Game(getManager()));
     game->load(path);
-    getManager().setState(game);
+    getManager().pushState(std::move(game));
 }
 
 void Menu::quit() {
-    getManager().quit();
+    getManager().popState();
 }