Correction de glitches visuels

include/constants.hpp

@@ -35,8 +35,8 @@ namespace Constants {
      * Correction positionnelle : pourcentage de correction
      * et seuil de correction
      */
-    static const float CORRECTION_PERCENTAGE = .2f;
+    static const float CORRECTION_PERCENTAGE = .5f;
-    static const float CORRECTION_THRESHOLD = .05f;
+    static const float CORRECTION_SLOP = .02f;
 
     /**
      * Taille de la grille des blocs en pixels

src/game.cpp

@@ -1,4 +1,6 @@
+#include <cmath>
 #include "game.hpp"
+#include "player.hpp"
 #include "constants.hpp"
 
 Game::Game(Manager& manager) : Level(manager),
@@ -27,6 +29,33 @@ void Game::frame() {
         // on met à jour la physique d'un cran temporel
         update();
 
+        // on place la caméra à la position médiane des joueurs
+        // s'ils sont trop éloignés
+        std::vector<ObjectPtr>& objects = getObjects();
+        sf::Vector2f position_first_player;
+        sf::Vector2f position_second_player;
+
+        for (unsigned int i = 0; i < objects.size(); i++) {
+            if (Player* player = dynamic_cast<Player*>(objects[i].get())) {
+                if (player->getPlayerNumber() == 0) {
+                    position_first_player = player->getPosition();
+                }
+
+                if (player->getPlayerNumber() == 1) {
+                    position_second_player = player->getPosition();
+                }
+            }
+        }
+
+        sf::Vector2f diff = position_second_player - position_first_player;
+        sf::View camera = getCamera();
+
+        if (std::pow(diff.x, 2) + std::pow(diff.y, 2) > std::pow(camera.getSize().x / 3, 2)) {
+            sf::Vector2f middle = (position_second_player + position_first_player) / 2.f;
+            camera.setCenter(floor(middle.x), floor(middle.y));
+            setCamera(camera);
+        }
+
         // si on a encore suffisamment de temps, on dessine
         if (current_time < next_frame_time) {
             draw();
@@ -76,7 +105,7 @@ void Game::update() {
         }
     }
 
-    // intégration des forces dans la vitesse (première moitié)
+    // intégration des forces dans la vitesse (seconde moitié)
     for (unsigned int i = 0; i < getObjects().size(); i++) {
         getObjects()[i]->updateVelocity(manager, getObjects(), Constants::PHYSICS_TIME.asSeconds() / 2);
     }
@@ -99,11 +128,6 @@ void Game::update() {
             collided.objB, collided.normal, collided.depth
         );
     }
-
-    // intégration des forces dans la vitesse (seconde moitié)
-    for (unsigned int i = 0; i < getObjects().size(); i++) {
-        getObjects()[i]->updateVelocity(manager, getObjects(), Constants::PHYSICS_TIME.asSeconds() / 2);
-    }
 }
 
 void Game::setTestMode(std::shared_ptr<View> set_return_view) {

src/object.cpp

@@ -1,3 +1,5 @@
+#include <cmath>
+#include <iostream>
 #include "object.hpp"
 #include "constants.hpp"
 #include "collision.hpp"
@@ -169,13 +171,16 @@ void Object::solveCollision(Object& obj, const sf::Vector2f& normal) {
 
     // si les directions sont divergentes, pas besoin
     // de résoudre la collision
-    if (dot_normal >= 0) {
+    if (dot_normal > 0) {
         return;
     }
 
-    // calcule et applique l'impulsion de résolution de la collision
+    // on utilise le plus petit coefficient de friction entre les
+    // deux objets comme le coefficient de la collision
     float restitution = std::min(getRestitution(), obj.getRestitution());
-    float collision_impulse = (-(1 + restitution) * dot_normal) /
+
+    // calcule et applique l'impulsion de résolution de la collision
+    float collision_impulse = -(1.f + restitution) * std::min(dot_normal + .8f, 0.f) /
         (getMassInvert() + obj.getMassInvert());
 
     setVelocity(getVelocity() - getMassInvert() * collision_impulse * normal);
@@ -217,13 +222,8 @@ void Object::solveCollision(Object& obj, const sf::Vector2f& normal) {
 }
 
 void Object::positionalCorrection(Object& obj, const sf::Vector2f& normal, float depth) {
-    // ne pas corriger les petites erreurs de position
+    float position_correction = std::max(depth - Constants::CORRECTION_SLOP, 0.0f) /
-    // pour éviter l'instabilité du moteur
+        (getMassInvert() + obj.getMassInvert()) *
-    if (depth <= Constants::CORRECTION_THRESHOLD) {
-        return;
-    }
-
-    float position_correction = depth / (getMassInvert() + obj.getMassInvert()) *
         Constants::CORRECTION_PERCENTAGE;
 
     setPosition(getPosition() - getMassInvert() * position_correction * normal);