From dde1280573250ee69a68b6d7a53974626cf2cfeb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matt=C3=A9o=20Delabre?= Date: Mon, 28 Mar 2016 17:23:47 +0200 Subject: [PATCH] =?UTF-8?q?Centralisation=20de=20l'=C3=A9tat=20dans=20un?= =?UTF-8?q?=20gestionnaire=20principal?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Démarrage de l'abstraction nécessaire à l'utilisation de plusieurs vues --- include/block.hpp | 9 ++-- include/engine_state.hpp | 26 ---------- include/game.hpp | 21 ++++---- include/manager.hpp | 54 ++++++++++++++++++++ include/object.hpp | 49 +++++++++--------- include/player.hpp | 15 +++--- include/view.hpp | 23 +++++++++ src/block.cpp | 14 ++--- src/game.cpp | 108 ++++++++++++--------------------------- src/main.cpp | 56 ++++++++++---------- src/manager.cpp | 57 +++++++++++++++++++++ src/object.cpp | 52 ++++++++++--------- src/player.cpp | 32 ++++++------ 13 files changed, 295 insertions(+), 221 deletions(-) delete mode 100644 include/engine_state.hpp create mode 100644 include/manager.hpp create mode 100644 include/view.hpp create mode 100644 src/manager.cpp diff --git a/include/block.hpp b/include/block.hpp index d742317..78d5b7b 100644 --- a/include/block.hpp +++ b/include/block.hpp @@ -3,11 +3,10 @@ #include #include "object.hpp" -#include "engine_state.hpp" class Block : public Object { private: - sf::Sprite sprite; + mutable sf::Sprite sprite; public: Block(float x, float y); @@ -15,18 +14,18 @@ public: /** * Dessin du bloc dans la fenêtre donnée */ - virtual void draw(sf::RenderWindow& window, ResourceManager& resources); + virtual void draw(Manager& manager); /** * Récupère la boîte englobante de l'objet */ - std::unique_ptr getAABB(); + virtual std::unique_ptr getAABB() const; /** * Récupère l'identifiant de type de cet objet */ static constexpr unsigned int TYPE_ID = 1; - unsigned int getTypeId(); + virtual unsigned int getTypeId() const; }; #endif diff --git a/include/engine_state.hpp b/include/engine_state.hpp deleted file mode 100644 index fc28498..0000000 --- a/include/engine_state.hpp +++ /dev/null @@ -1,26 +0,0 @@ -#ifndef __PTF_ENGINE_STATE_HPP__ -#define __PTF_ENGINE_STATE_HPP__ - -#include -#include - -// pré-déclaration de Object pour éviter les erreurs -// de compilation Object est définie dans object.hpp -class Object; - -/** - * Structure qui retient l'état actuel du moteur - * Cette structure est passée aux objets pour qu'ils se - * mettent à jour en fonction de cet état - */ -struct EngineState { - std::vector objects; - std::array keys; - - EngineState() { - // aucune touche n'est enfoncée au démarrage - keys.fill(false); - } -}; - -#endif diff --git a/include/game.hpp b/include/game.hpp index d953145..5d0b87e 100644 --- a/include/game.hpp +++ b/include/game.hpp @@ -1,44 +1,43 @@ #ifndef __PTF_GAME_HPP__ #define __PTF_GAME_HPP__ -#include #include +#include "view.hpp" #include "object.hpp" -#include "engine_state.hpp" +#include "manager.hpp" #include "resource_manager.hpp" /** * La classe Game gère l'affichage et les objets * d'une partie de jeu */ -class Game { +class Game : public View { private: - sf::Clock clock; - sf::RenderWindow window; sf::View view; sf::Music music; - EngineState state; - ResourceManager resources; + float accumulator; + std::vector objects; /** * Met à jour les objets du jeu pour * qu'ils s'adaptent au nouvel état */ - void update(); + void update(const Manager& manager); /** * Dessine la scène du jeu couche par couche */ - void draw(); + void draw(Manager& manager); public: Game(); /** - * Démarre la boucle principale du jeu + * Demande le passage à la frame suivante sur + * cette vue */ - void start(); + void frame(Manager& manager); /** * Ajoute un nouvel objet à la liste des objets du jeu diff --git a/include/manager.hpp b/include/manager.hpp new file mode 100644 index 0000000..4bb92b8 --- /dev/null +++ b/include/manager.hpp @@ -0,0 +1,54 @@ +#ifndef __PTF_MANAGER_HPP__ +#define __PTF_MANAGER_HPP__ + +#include "resource_manager.hpp" +#include "view.hpp" + +/** + * Gestionnaire principal de toutes les vues et + * ressources du jeu + */ +class Manager { +private: + sf::RenderWindow window; + sf::Clock clock; + + float elapsed_time; + ResourceManager resource_manager; + std::array keys; + +public: + // FIXME: devrait être privé + View* view; + + Manager(); + + /** + * Démarre la boucle principale du jeu + */ + void start(); + + /** + * Renvoie la fenêtre actuellement utilisée pour le dessin + */ + sf::RenderWindow& getWindow(); + + /** + * Renvoie le temps écoulé entre la frame précédente + * et la frame actuelle + */ + float getElapsedTime() const; + + /** + * Renvoie le gestionnaire de ressources + */ + ResourceManager& getResourceManager(); + + /** + * Renvoie un booléen attestant de l'appui sur la + * touche donnée ou non + */ + bool isKeyPressed(sf::Keyboard::Key key) const; +}; + +#endif diff --git a/include/object.hpp b/include/object.hpp index edc87e9..a462b17 100644 --- a/include/object.hpp +++ b/include/object.hpp @@ -3,13 +3,10 @@ #include #include -#include "engine_state.hpp" #include "collision_data.hpp" +#include "manager.hpp" #include "resource_manager.hpp" -class Block; -class Player; - class Object { private: sf::Vector2f acceleration; @@ -20,7 +17,7 @@ private: sf::VertexArray velocity_line; float mass; - float inv_mass; + mutable float inv_mass; float charge; float restitution; float static_friction; @@ -31,7 +28,7 @@ protected: /** * Calcule les forces appliquées à l'objet */ - virtual sf::Vector2f getForces(EngineState& state); + virtual sf::Vector2f getForces(const Manager& manager, const std::vector& objects) const; public: Object(float x, float y); @@ -39,32 +36,32 @@ public: /** * Dessine l'objet dans la fenêtre donnée */ - virtual void draw(sf::RenderWindow& window, ResourceManager& resources); + virtual void draw(Manager& manager); /** * Met à jour la vitesse de l'objet selon les * forces qui lui sont appliquées */ - void updateVelocity(EngineState& state, float delta); + void updateVelocity(const Manager& manager, const std::vector& objects, float delta); /** * Met à jour la position de l'objet selon sa * vitesse actuelle */ - void updatePosition(EngineState& state, float delta); + void updatePosition(float delta); /** * Détecte s'il y a collision entre cet objet * et l'objet passé en paramètre */ - bool detectCollision(Object& obj, CollisionData& data); + bool detectCollision(const Object& obj, CollisionData& data) const; /** * Résolution de la collision entre cet objet * et l'objet passé en paramètre selon la normale * donnée */ - void solveCollision(Object& obj, sf::Vector2f normal); + void solveCollision(Object& obj, const sf::Vector2f& normal); /** * Application de la correction positionnelle sur @@ -74,27 +71,27 @@ public: * les objets peuvent accumuler une erreur de positionnement * qui les fait "plonger" les uns dans les autres */ - void positionalCorrection(Object& obj, sf::Vector2f normal, float depth); + void positionalCorrection(Object& obj, const sf::Vector2f& normal, float depth); /** * Récupère la boîte englobante de l'objet */ - virtual std::unique_ptr getAABB() = 0; + virtual std::unique_ptr getAABB() const = 0; /** * Récupère l'identifiant de type de cet objet */ - virtual unsigned int getTypeId() = 0; + virtual unsigned int getTypeId() const = 0; /** * Récupère l'accélération de l'objet */ - sf::Vector2f getAcceleration(); + sf::Vector2f getAcceleration() const; /** * Récupère la vitesse de l'objet */ - sf::Vector2f getVelocity(); + sf::Vector2f getVelocity() const; /** * Modifie la vitesse de l'objet @@ -105,7 +102,7 @@ public: /** * Récupère la position de l'objet */ - sf::Vector2f getPosition(); + sf::Vector2f getPosition() const; /** * Modifie la position de l'objet @@ -116,12 +113,12 @@ public: /** * Récupère la masse de l'objet */ - float getMass(); + float getMass() const; /** * Récupère l'inverse de la masse de l'objet (en cache) */ - float getMassInvert(); + float getMassInvert() const; /** * Modifie la masse de l'objet @@ -131,7 +128,7 @@ public: /** * Récupère la charge de l'objet */ - float getCharge(); + float getCharge() const; /** * Modifie la charge de l'objet @@ -141,7 +138,7 @@ public: /** * Récupère le coefficient de restitution de l'objet */ - float getRestitution(); + float getRestitution() const; /** * Modifie le coefficient de restitution de l'objet @@ -151,7 +148,7 @@ public: /** * Récupère le coefficient de frottement dynamique de l'objet */ - float getStaticFriction(); + float getStaticFriction() const; /** * Modifie le coefficient de frottement dynamique de l'objet @@ -161,7 +158,7 @@ public: /** * Récupère le coefficient de frottement dynamique de l'objet */ - float getDynamicFriction(); + float getDynamicFriction() const; /** * Modifie le coefficient de frottement dynamique de l'objet @@ -171,12 +168,12 @@ public: /** * Récupère la couche d'affichage de l'objet */ - unsigned int getLayer(); + int getLayer() const; /** * Modifie la couche d'affichage de l'objet */ - void setLayer(unsigned int set_layer); + void setLayer(int set_layer); }; /** @@ -185,7 +182,7 @@ public: * qui doit être dessinée avant celle du second */ struct ObjectCompare { - bool operator()(Object* const &t1, Object* const &t2); + bool operator()(Object* const &t1, Object* const &t2) const; }; #endif diff --git a/include/player.hpp b/include/player.hpp index a002482..37298be 100644 --- a/include/player.hpp +++ b/include/player.hpp @@ -3,18 +3,17 @@ #include #include "object.hpp" -#include "engine_state.hpp" class Player : public Object { private: - sf::Sprite sprite; + mutable sf::Sprite sprite; unsigned int player_number; protected: /** * Calcule les forces appliquées à l'objet */ - virtual sf::Vector2f getForces(EngineState& state); + virtual sf::Vector2f getForces(const Manager& manager, const std::vector& objects) const; public: Player(float x, float y); @@ -22,28 +21,28 @@ public: /** * Dessine la balle dans la fenêtre donnée */ - virtual void draw(sf::RenderWindow& window, ResourceManager& resources); + virtual void draw(Manager& manager); /** * Récupère la boîte englobante de l'objet */ - std::unique_ptr getAABB(); + virtual std::unique_ptr getAABB() const; /** * Récupère l'identifiant de type de cet objet */ static constexpr unsigned int TYPE_ID = 0; - unsigned int getTypeId(); + virtual unsigned int getTypeId() const; /** * Renvoie le rayon de la balle */ - float getRadius(); + float getRadius() const; /** * Renvoie le numéro du joueur */ - unsigned int getPlayerNumber(); + unsigned int getPlayerNumber() const; /** * Modifie le numéro du joueur diff --git a/include/view.hpp b/include/view.hpp new file mode 100644 index 0000000..fd3b384 --- /dev/null +++ b/include/view.hpp @@ -0,0 +1,23 @@ +#ifndef __PTF_VIEW_HPP__ +#define __PTF_VIEW_HPP__ + +#include + +class Manager; +class Object; + +/** + * Classe abstraite pour les vues + */ +class View { +public: + /** + * Demande le passage à la frame suivante sur + * cette vue + */ + virtual void frame(Manager& manager) = 0; + + virtual void addObject(Object& object) = 0; +}; + +#endif diff --git a/src/block.cpp b/src/block.cpp index ac5a8b5..8387b14 100644 --- a/src/block.cpp +++ b/src/block.cpp @@ -12,11 +12,13 @@ Block::Block(float x, float y) : Object(x, y) { sprite.setOrigin(sf::Vector2f(Constants::GRID / 2, Constants::GRID / 2)); } -void Block::draw(sf::RenderWindow& window, ResourceManager& resources) { - Object::draw(window, resources); +void Block::draw(Manager& manager) { + Object::draw(manager); // utilisation de la texture - sprite.setTexture(resources.getTexture("block.png")); + sprite.setTexture( + manager.getResourceManager().getTexture("block.png") + ); // coloration du bloc en fonction de sa charge if (getCharge() > 0) { @@ -28,10 +30,10 @@ void Block::draw(sf::RenderWindow& window, ResourceManager& resources) { } sprite.setPosition(getPosition()); - window.draw(sprite); + manager.getWindow().draw(sprite); } -std::unique_ptr Block::getAABB() { +std::unique_ptr Block::getAABB() const { return std::unique_ptr(new sf::FloatRect( getPosition().x - Constants::GRID / 2, getPosition().y - Constants::GRID / 2, @@ -39,6 +41,6 @@ std::unique_ptr Block::getAABB() { )); } -unsigned int Block::getTypeId() { +unsigned int Block::getTypeId() const { return Block::TYPE_ID; } diff --git a/src/game.cpp b/src/game.cpp index 091bdcd..e451b01 100644 --- a/src/game.cpp +++ b/src/game.cpp @@ -3,82 +3,42 @@ #include #include -Game::Game() : window( - sf::VideoMode(704, 480), "Projet CMI", sf::Style::Default, - sf::ContextSettings(0, 0, 2) -), view(sf::FloatRect(0, 0, 704, 480)) { - window.setVerticalSyncEnabled(true); - - // mise en place de la caméra - view.setSize(704, 480); - window.setView(view); -} - -void Game::start() { - float accumulator = 0; - if (!music.openFromFile("./res/music_lvl1.wav")) - { +Game::Game() : accumulator(0.f) { + if (!music.openFromFile("./res/music_lvl1.wav")) { // erreur } + music.play(); music.setVolume(15); music.setLoop(true); - - // boucle d'événements sur la fenêtre - while (window.isOpen()) { - sf::Event event; - - // traitement des évènements reçus - while (window.pollEvent(event)) { - // fermeture de la fenêtre - if (event.type == sf::Event::Closed) { - window.close(); - } - - // suivi de l'enfoncement et du relâchement des touches - if (event.type == sf::Event::KeyPressed) { - state.keys[event.key.code] = true; - } - - if (event.type == sf::Event::KeyReleased) { - state.keys[event.key.code] = false; - } - - // lorsque la fenêtre est redimensionnée par l'utilisateur, - // mise à jour de la caméra en fonction de la taille de la fenêtre - if (event.type == sf::Event::Resized) { - sf::FloatRect visibleArea(0, 0, event.size.width, event.size.height); - window.setView(sf::View(visibleArea)); - } - } - - float frame = clock.restart().asSeconds(); - accumulator += frame; - - // tant qu'il reste du temps à passer, - // effectuer la simulation physique étape par étape - while (accumulator >= Constants::PHYSICS_TIME) { - accumulator -= Constants::PHYSICS_TIME; - update(); - } - - draw(); - } } void Game::addObject(Object& object) { - state.objects.push_back(&object); + objects.push_back(&object); } -void Game::update() { +void Game::frame(Manager& manager) { + accumulator += manager.getElapsedTime(); + + // tant qu'il reste du temps à passer, + // effectuer la simulation physique étape par étape + while (accumulator >= Constants::PHYSICS_TIME) { + accumulator -= Constants::PHYSICS_TIME; + update(manager); + } + + draw(manager); +} + +void Game::update(const Manager& manager) { std::vector colliding; // détection des objets en collision - for (unsigned int i = 0; i < state.objects.size(); i++) { - Object* objA = state.objects[i]; + for (unsigned int i = 0; i < objects.size(); i++) { + Object* objA = objects[i]; - for (unsigned int j = i + 1; j < state.objects.size(); j++) { - Object* objB = state.objects[j]; + for (unsigned int j = i + 1; j < objects.size(); j++) { + Object* objB = objects[j]; CollisionData data(*objA, *objB); if (objA->detectCollision(*objB, data)) { @@ -88,8 +48,8 @@ void Game::update() { } // intégration des forces dans la vitesse (première moitié) - for (unsigned int i = 0; i < state.objects.size(); i++) { - state.objects[i]->updateVelocity(state, Constants::PHYSICS_TIME / 2); + for (unsigned int i = 0; i < objects.size(); i++) { + objects[i]->updateVelocity(manager, objects, Constants::PHYSICS_TIME / 2); } // résolution des collisions détectées @@ -99,8 +59,8 @@ void Game::update() { } // intégration de la vitesse dans la position - for (unsigned int i = 0; i < state.objects.size(); i++) { - state.objects[i]->updatePosition(state, Constants::PHYSICS_TIME); + for (unsigned int i = 0; i < objects.size(); i++) { + objects[i]->updatePosition(Constants::PHYSICS_TIME); } // application de la correction positionnelle @@ -112,27 +72,27 @@ void Game::update() { } // intégration des forces dans la vitesse (seconde moitié) - for (unsigned int i = 0; i < state.objects.size(); i++) { - state.objects[i]->updateVelocity(state, Constants::PHYSICS_TIME / 2); + for (unsigned int i = 0; i < objects.size(); i++) { + objects[i]->updateVelocity(manager, objects, Constants::PHYSICS_TIME / 2); } } -void Game::draw() { +void Game::draw(Manager& manager) { // efface la scène précédente et dessine la couche de fond - window.clear(sf::Color(66, 165, 245)); + manager.getWindow().clear(sf::Color(66, 165, 245)); // chargement de la file d'affichage des objets std::priority_queue, ObjectCompare> display_queue; - for (unsigned int i = 0; i < state.objects.size(); i++) { - display_queue.push(state.objects[i]); + for (unsigned int i = 0; i < objects.size(); i++) { + display_queue.push(objects[i]); } // dessin des objets de la file d'affichage couche par couche while (!display_queue.empty()) { - display_queue.top()->draw(window, resources); + display_queue.top()->draw(manager); display_queue.pop(); } - window.display(); + manager.getWindow().display(); } diff --git a/src/main.cpp b/src/main.cpp index 7e94ef9..02d0bc8 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -1,12 +1,13 @@ #include "player.hpp" #include "block.hpp" +#include "manager.hpp" #include "game.hpp" #include "constants.hpp" #include #include int main() { - Game game; + Manager manager; Player player1(3.5f * Constants::GRID, 10 * Constants::GRID); player1.setPlayerNumber(1); @@ -40,33 +41,36 @@ int main() { block22.setCharge(1.f); block22.setMass(2); - game.addObject(player1); - game.addObject(player2); - game.addObject(block01); - game.addObject(block02); - game.addObject(block03); - game.addObject(block04); - game.addObject(block05); - game.addObject(block06); - game.addObject(block07); - game.addObject(block08); - game.addObject(block09); - game.addObject(block10); - game.addObject(block11); - game.addObject(block12); - game.addObject(block13); - game.addObject(block14); - game.addObject(block15); - game.addObject(block16); - game.addObject(block17); - game.addObject(block18); - game.addObject(block19); - game.addObject(block20); - game.addObject(block21); - game.addObject(block22); + Game game_view; + manager.view = &game_view; + + manager.view->addObject(player1); + manager.view->addObject(player2); + manager.view->addObject(block01); + manager.view->addObject(block02); + manager.view->addObject(block03); + manager.view->addObject(block04); + manager.view->addObject(block05); + manager.view->addObject(block06); + manager.view->addObject(block07); + manager.view->addObject(block08); + manager.view->addObject(block09); + manager.view->addObject(block10); + manager.view->addObject(block11); + manager.view->addObject(block12); + manager.view->addObject(block13); + manager.view->addObject(block14); + manager.view->addObject(block15); + manager.view->addObject(block16); + manager.view->addObject(block17); + manager.view->addObject(block18); + manager.view->addObject(block19); + manager.view->addObject(block20); + manager.view->addObject(block21); + manager.view->addObject(block22); try { - game.start(); + manager.start(); } catch (const std::exception& exception) { std::cerr << std::endl; 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 new file mode 100644 index 0000000..7836b76 --- /dev/null +++ b/src/manager.cpp @@ -0,0 +1,57 @@ +#include "manager.hpp" + +Manager::Manager() : window( + sf::VideoMode(704, 480), "Projet CMI", sf::Style::Default, + sf::ContextSettings(0, 0, 2) +), elapsed_time(0.f), view(NULL) { + keys.fill(false); +} + +void Manager::start() { + while (window.isOpen()) { + sf::Event event; + + // traitement des évènements reçus + while (window.pollEvent(event)) { + // fermeture de la fenêtre + if (event.type == sf::Event::Closed) { + window.close(); + return; + } + + // suivi de l'enfoncement et du relâchement des touches + if (event.type == sf::Event::KeyPressed) { + keys[event.key.code] = true; + } + + if (event.type == sf::Event::KeyReleased) { + keys[event.key.code] = false; + } + } + + // demande à la vue de se mettre à jour sur + // la prochaine frame + if (view == NULL) { + throw std::runtime_error("Aucune vue à afficher pour le jeu"); + } + + elapsed_time = clock.restart().asSeconds(); + view->frame(*this); + } +} + +sf::RenderWindow& Manager::getWindow() { + return window; +} + +float Manager::getElapsedTime() const { + return elapsed_time; +} + +ResourceManager& Manager::getResourceManager() { + return resource_manager; +} + +bool Manager::isKeyPressed(sf::Keyboard::Key key) const { + return keys[key]; +} diff --git a/src/object.cpp b/src/object.cpp index 8ec3e7b..9178c8c 100644 --- a/src/object.cpp +++ b/src/object.cpp @@ -15,7 +15,9 @@ Object::Object(float x, float y) : dynamic_friction(0.2f), layer(Constants::DEFAULT_LAYER) {} -sf::Vector2f Object::getForces(EngineState& state) { +sf::Vector2f Object::getForces( + const Manager& manager, const std::vector& objects +) const { sf::Vector2f forces(0, 0); // force de gravité @@ -23,8 +25,8 @@ sf::Vector2f Object::getForces(EngineState& state) { // force d'attraction entre objets chargés if (getCharge() != 0) { - for (unsigned int j = 0; j < state.objects.size(); j++) { - Object *attractive = state.objects[j]; + for (unsigned int j = 0; j < objects.size(); j++) { + Object *attractive = objects[j]; if (attractive == this || attractive->getCharge() == 0) { continue; @@ -57,7 +59,7 @@ sf::Vector2f Object::getForces(EngineState& state) { return forces; } -void Object::draw(sf::RenderWindow& window, ResourceManager& resources) { +void Object::draw(Manager& manager) { if (Constants::DEBUG_MODE) { velocity_line[0].position = position; velocity_line[0].color = sf::Color::Green; @@ -69,21 +71,23 @@ void Object::draw(sf::RenderWindow& window, ResourceManager& resources) { acceleration_line[1].position = position + acceleration * 1.f; acceleration_line[1].color = sf::Color::Red; - window.draw(velocity_line); - window.draw(acceleration_line); + manager.getWindow().draw(velocity_line); + manager.getWindow().draw(acceleration_line); } } -void Object::updateVelocity(EngineState& state, float delta) { - acceleration = getForces(state) * getMassInvert(); +void Object::updateVelocity( + const Manager& manager, const std::vector& objects, float delta +) { + acceleration = getForces(manager, objects) * getMassInvert(); velocity += acceleration * delta; } -void Object::updatePosition(EngineState& state, float delta) { +void Object::updatePosition(float delta) { position += velocity * delta; } -bool Object::detectCollision(Object& obj, CollisionData& data) { +bool Object::detectCollision(const Object& obj, CollisionData& data) const { // si les objets ne sont pas sur la même couche, // ils ne peuvent pas entrer en collision if (getLayer() != obj.getLayer()) { @@ -103,7 +107,7 @@ bool Object::detectCollision(Object& obj, CollisionData& data) { ](data); } -void Object::solveCollision(Object& obj, sf::Vector2f normal) { +void Object::solveCollision(Object& 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) { @@ -164,7 +168,7 @@ void Object::solveCollision(Object& obj, sf::Vector2f normal) { obj.setVelocity(obj.getVelocity() + obj.getMassInvert() * friction_impulse * tangent); } -void Object::positionalCorrection(Object& obj, sf::Vector2f normal, float depth) { +void Object::positionalCorrection(Object& obj, const sf::Vector2f& normal, float depth) { // ne pas corriger les petites erreurs de position // pour éviter l'instabilité du moteur if (depth <= Constants::CORRECTION_THRESHOLD) { @@ -178,11 +182,11 @@ void Object::positionalCorrection(Object& obj, sf::Vector2f normal, float depth) obj.setPosition(obj.getPosition() + obj.getMassInvert() * position_correction * normal); } -sf::Vector2f Object::getAcceleration() { +sf::Vector2f Object::getAcceleration() const { return acceleration; } -sf::Vector2f Object::getVelocity() { +sf::Vector2f Object::getVelocity() const { return velocity; } @@ -190,7 +194,7 @@ void Object::setVelocity(sf::Vector2f set_velocity) { velocity = set_velocity; } -sf::Vector2f Object::getPosition() { +sf::Vector2f Object::getPosition() const { return position; } @@ -198,11 +202,11 @@ void Object::setPosition(sf::Vector2f set_position) { position = set_position; } -float Object::getMass() { +float Object::getMass() const { return mass; } -float Object::getMassInvert() { +float Object::getMassInvert() const { if (inv_mass >= 0) { return inv_mass; } @@ -221,7 +225,7 @@ void Object::setMass(float set_mass) { inv_mass = -1.f; } -float Object::getCharge() { +float Object::getCharge() const { return charge; } @@ -229,7 +233,7 @@ void Object::setCharge(float set_charge) { charge = set_charge; } -float Object::getRestitution() { +float Object::getRestitution() const { return restitution; } @@ -237,7 +241,7 @@ void Object::setRestitution(float set_restitution) { restitution = set_restitution; } -float Object::getStaticFriction() { +float Object::getStaticFriction() const { return static_friction; } @@ -245,7 +249,7 @@ void Object::setStaticFriction(float set_static_friction) { static_friction = set_static_friction; } -float Object::getDynamicFriction() { +float Object::getDynamicFriction() const { return dynamic_friction; } @@ -253,14 +257,14 @@ void Object::setDynamicFriction(float set_dynamic_friction) { dynamic_friction = set_dynamic_friction; } -unsigned int Object::getLayer() { +int Object::getLayer() const { return layer; } -void Object::setLayer(unsigned int set_layer) { +void Object::setLayer(int set_layer) { layer = set_layer; } -bool ObjectCompare::operator()(Object* const &t1, Object* const &t2) { +bool ObjectCompare::operator()(Object* const &t1, Object* const &t2) const { return t1->getLayer() > t2->getLayer(); } diff --git a/src/player.cpp b/src/player.cpp index 92352b9..f40e75f 100644 --- a/src/player.cpp +++ b/src/player.cpp @@ -9,26 +9,26 @@ Player::Player(float x, float y) : Object(x, y) { sprite.setOrigin(sf::Vector2f(getRadius(), getRadius())); } -sf::Vector2f Player::getForces(EngineState& state) { - sf::Vector2f forces = Object::getForces(state); +sf::Vector2f Player::getForces(const Manager& manager, const std::vector& objects) const { + sf::Vector2f forces = Object::getForces(manager, objects); // déplacement de la balle après appui sur les touches de direction if (getPlayerNumber() == 1) { - if (state.keys[sf::Keyboard::Left]) { + if (manager.isKeyPressed(sf::Keyboard::Left)) { forces += sf::Vector2f(-Constants::MOVE, 0); } - if (state.keys[sf::Keyboard::Right]) { + if (manager.isKeyPressed(sf::Keyboard::Right)) { forces += sf::Vector2f(Constants::MOVE, 0); } } if (getPlayerNumber() == 2) { - if (state.keys[sf::Keyboard::Q]) { + if (manager.isKeyPressed(sf::Keyboard::Q)) { forces += sf::Vector2f(-Constants::MOVE, 0); } - if (state.keys[sf::Keyboard::D]) { + if (manager.isKeyPressed(sf::Keyboard::D)) { forces += sf::Vector2f(Constants::MOVE, 0); } } @@ -36,19 +36,21 @@ sf::Vector2f Player::getForces(EngineState& state) { return forces; } -void Player::draw(sf::RenderWindow& window, ResourceManager& resources) { - Object::draw(window, resources); +void Player::draw(Manager& manager) { + Object::draw(manager); // utilisation de la texture - sprite.setTexture(resources.getTexture("ball.png")); + sprite.setTexture( + manager.getResourceManager().getTexture("ball.png") + ); // déplacement du sprite à la position de la balle - sprite.rotate(getVelocity().x * .1f); + sprite.rotate(getVelocity().x * Constants::PHYSICS_TIME * .5f); sprite.setPosition(getPosition()); - window.draw(sprite); + manager.getWindow().draw(sprite); } -std::unique_ptr Player::getAABB() { +std::unique_ptr Player::getAABB() const { return std::unique_ptr(new sf::FloatRect( getPosition().x - getRadius(), getPosition().y - getRadius(), @@ -56,15 +58,15 @@ std::unique_ptr Player::getAABB() { )); } -unsigned int Player::getTypeId() { +unsigned int Player::getTypeId() const { return Player::TYPE_ID; } -float Player::getRadius() { +float Player::getRadius() const { return 10 * getMass(); } -unsigned int Player::getPlayerNumber() { +unsigned int Player::getPlayerNumber() const { return player_number; }