Chargement des textures pour ball et block

ball.cpp

@@ -1,6 +1,14 @@
 #include "ball.hpp"
 
 void Ball::draw(sf::RenderWindow& window) {
+
+	//chargement de la texture de test
+	if (!texture.loadFromFile("./Images/texture_test.jpeg"))
+	{
+    	//erreur
+	}
+	shape.setTexture(&texture);	
+
     shape.setPosition(position);
     window.draw(shape);
 }

ball.cpp~

@@ -0,0 +1,49 @@
+#include "ball.hpp"
+
+void Ball::draw(sf::RenderWindow& window) {
+    shape.setPosition(position);
+    window.draw(shape);
+}
+
+sf::Vector2f Ball::getForces(State state) {
+    sf::Vector2f forces = PhysicsObject::getForces(state);
+
+    // déplacement de la balle après appui sur les touches de direction
+    if (state.goLeftKey) {
+        forces += sf::Vector2f(-Ball::MOVE, 0);
+    }
+
+    if (state.goRightKey) {
+        forces += sf::Vector2f(Ball::MOVE, 0);
+    }
+
+    // force d'attraction entre les balles et les blocs chargés
+    if (getCharge() != 0) {
+        for (unsigned int j = 0; j < state.objects.size(); j++) {
+            Object *attractive = state.objects[j];
+
+            if (attractive == this || attractive->getCharge() == 0) {
+                continue;
+            }
+
+            // vecteur allant de l'objet attirant vers l'objet considéré
+            sf::Vector2f attraction(position - attractive->getPosition());
+
+            // la norme de ce vecteur est la distance entre les objets
+            float distanceSquared = attraction.x * attraction.x +
+                attraction.y * attraction.y;
+
+            // normalisation du vecteur direction qui porte
+            // la force d'attraction, puis application de la norme
+            attraction /= std::sqrt(distanceSquared);
+            attraction *= Ball::ATTRACTION * (
+                (charge * attractive->getCharge()) /
+                distanceSquared
+            );
+
+            forces += attraction;
+        }
+    }
+
+    return forces;
+}

ball.hpp

@@ -8,6 +8,7 @@
 
 class Ball : public PhysicsObject {
 protected:
+	sf::Texture texture;
     sf::CircleShape shape;
 
     /**

ball.hpp~

@@ -0,0 +1,40 @@
+#ifndef __PTF_BALL_HPP__
+#define __PTF_BALL_HPP__
+
+#include <SFML/Graphics.hpp>
+#include <iostream>
+#include "state.hpp"
+#include "physics_object.hpp"
+
+class Ball : public PhysicsObject {
+protected:
+    sf::CircleShape shape;
+
+    /**
+     * Calcule les forces appliquées à l'objet
+     */
+    virtual sf::Vector2f getForces(State state);
+
+    static constexpr float ATTRACTION = 25000;
+    static constexpr float MOVE = 100;
+
+public:
+    Ball(float x, float y) : PhysicsObject(x, y), shape(10 * mass) {
+        shape.setOrigin(sf::Vector2f(10 * mass, 10 * mass));
+        shape.setFillColor(sf::Color(255, 245, 131));
+    }
+
+    /**
+     * Dessine la balle dans la fenêtre donnée
+     */
+    void draw(sf::RenderWindow& window);
+
+    /**
+     * Détermine la couche d'affichage de l'objet
+     */
+    unsigned int getLayer() {
+        return 1;
+    }
+};
+
+#endif

block.cpp

@@ -1,16 +1,26 @@
 #include "block.hpp"
 
 void Block::draw(sf::RenderWindow& window) {
+	
+	//chargement de la texture de test
+	if (!texture.loadFromFile("./Images/texture_test.jpeg"))
+	{
+    	//erreur
+	}
+	shape.setTexture(&texture);	
+
     if (charge > 0) {
         shape.setFillColor(sf::Color(0, 0, 255));
     } else if (charge < 0) {
         shape.setFillColor(sf::Color(255, 0, 0));
     } else {
-        shape.setFillColor(sf::Color(0, 0, 0));
+        shape.setFillColor(sf::Color(75, 75, 75));
     }
 
     shape.setPosition(position);
     window.draw(shape);
+
+	
 }
 
 void Block::update(State state) {

block.cpp~

@@ -0,0 +1,29 @@
+#include "block.hpp"
+
+void Block::draw(sf::RenderWindow& window) {
+	
+	//chargement de la texture de test
+	if (!texture.loadFromFile("./Images/texture_test.jpeg"))
+	{
+    	//erreur
+	}
+	shape.setTexture(&texture);	
+	shape.setTextureRect(sf::IntRect(5, 5, 10, 10));
+
+    if (charge > 0) {
+        shape.setFillColor(sf::Color(0, 0, 255));
+    } else if (charge < 0) {
+        shape.setFillColor(sf::Color(255, 0, 0));
+    } else {
+        shape.setFillColor(sf::Color(75, 75, 75));
+    }
+
+    shape.setPosition(position);
+    window.draw(shape);
+
+	
+}
+
+void Block::update(State state) {
+    // rien à mettre à jour
+}

block.hpp

@@ -8,6 +8,7 @@
 
 class Block : public Object {
 protected:
+	sf::Texture texture;
     sf::RectangleShape shape;
 
 public:

block.hpp~

@@ -0,0 +1,42 @@
+#ifndef __PTF_BLOCK_HPP__
+#define __PTF_BLOCK_HPP__
+
+#include <SFML/Graphics.hpp>
+#include <iostream>
+#include "object.hpp"
+#include "state.hpp"
+
+class Block : public Object {
+protected:
+	sf::Texture texture;
+	sf::Sprite sprite;
+    sf::RectangleShape shape;
+
+public:
+    static constexpr float GRID = 32;
+
+    Block(float x, float y) : Object(x, y), shape(sf::Vector2f(Block::GRID, Block::GRID)) {
+        shape.setOrigin(sf::Vector2f(Block::GRID / 2, Block::GRID / 2));
+        shape.setFillColor(sf::Color(0, 0, 0));
+    }
+
+    /**
+     * Dessin du bloc dans la fenêtre donnée
+     */
+    void draw(sf::RenderWindow& window);
+
+    /**
+     * Met à jour l'objet juste avant le dessin d'une frame
+     * Reçoit l'état actuel du moteur
+     */
+    void update(State state);
+
+    /**
+     * Détermine la couche d'affichage de l'objet
+     */
+    unsigned int getLayer() {
+        return 0;
+    }
+};
+
+#endif