int _tmain(int argc, _TCHAR* argv[])
{
//On lance la recherche de chemin
sf::RenderWindow window(sf::VideoMode(1024 , 768), "Pathfinding A*");
//Espace de jeu
World world;
//On instancie le pathFinder
PathFinding pathfinder(world);
//On lance la recherche de chemin
pathfinder.findPath(Vecteur(30,40), Vecteur(250,150));
//On créé une liste Vecteur et on récupère le chemin du pathfinder
std::vector<Vecteur> path(pathfinder.getPath());
//On affiche les coordonées des points du chemin
std::vector<Vecteur>::reverse_iterator it = path.rbegin();
/*for(; it != path.rend(); it++)
std::cout << (*it)->x << " " << (*it)->y << std::endl;*/
//On créé les obstacles
sf::RectangleShape rect1(sf::Vector2f(50, 300));
rect1.setFillColor(sf::Color::Black);
rect1.setPosition(200, 0);
sf::RectangleShape rect2(sf::Vector2f(50, 200));
rect2.setFillColor(sf::Color::Black);
rect2.setPosition(350, 200);
sf::Clock clock;
//Boucle d'affichage
while (window.isOpen())
{
if(clock.getElapsedTime().asSeconds() > 0.5)
{
clock.restart();
int y = rand() % 140 + 10 ;
int x = rand() % 240 + 10 ;
pathfinder.findPath(Vecteur(30,40), Vecteur(x,y));
}
//Enlever l'affichage la frame précédent
window.clear(sf::Color::White);
sf::Event event;
//Gesion de l'évènement "fermer la fenêtre"
while (window.pollEvent(event))
if (event.type == sf::Event::Closed)
window.close();
//On dessine nos cercles
pathfinder.draw(window);
//On dessine les obstacles
//window.draw(rect1);
//window.draw(rect2);
//Afficher nos objets
window.display();
}
return 0;
}
int Segment::testActivation(ListePoints *liste) {
float distP1P2, distP1, distP2, p_scal, distQuad;
Point P1, P2, PPc, PPp;
Vecteur PC, PS;
if (_lpts.longueur() <= 3 || liste->longueur() <= 2) {
return 0;
}
// position courante
Point *test = liste->getFirstPoint();
PPc = test;
PPp = liste->getPointAt(1);
P1 = _lpts.getFirstPoint();
// premier point
P2 = _lpts.getPointAt(1);
distP1 = P1.dist(&PPc);
distP2 = P2.dist(&PPc);
distP1P2 = P1.dist(&P2);
distQuad = P1.dist(&PPc);
if (distQuad > DIST_ACT) return 0;
PC = Vecteur(PPp, PPc);
PS = Vecteur(P1, P2);
p_scal = PC._x * PS._x + PC._y * PS._y;
if (sqrt(PC._x * PC._x + PC._y * PC._y) * sqrt(PS._x * PS._x + PS._y * PS._y) > 0.001) {
p_scal /= sqrt(PC._x * PC._x + PC._y * PC._y);
p_scal /= sqrt(PS._x * PS._x + PS._y * PS._y);
Serial.print(F("Produit scalaire: "));
Serial.println(p_scal);
} else {
p_scal = -10.;
}
if (distP2 * distP2 < distP1 * distP1 + distP1P2 * distP1P2 && p_scal > PSCAL_LIM) {
return 1;
Serial.println(F("Test positif"));
} else {
return 0;
//Serial.println(F("Segment toujours inactif"));
}
}
Vecteur Vecteur::unitaire() const
{
if (m_x == 0 && m_y == 0)
return Vecteur();
else
return (1.0/norme())*(*this);
}
void BlinkyBlocksBlock::setPosition(const int x, const int y, const int z) {
lock();
if (state >= ALIVE) {
position = Vecteur(x,y,z);
}
unlock();
getWorld()->updateGlData(this);
}
Particule::Particule(int x, int y, double xd, double yd, Matiere* matiere)
: Element(Vecteur(xd,yd)), m_x(x), m_y(y),
m_resf(), m_matiere(matiere)
{
m_pos2 = m_pos;
m_v2 = m_v;
m_liaisons = new Particule*[def::nbLiaisons];
for(int i = 0 ; i < def::nbLiaisons ; i++)
m_liaisons[i] = NULL;
}
float SC_GetAngleVector(TGfxVec2 & Position, TGfxVec2 Direction)
{
TGfxVec2 Vecteur(Direction - Position);
float hypothenuse = Vecteur.Length();
float fAngle = GfxMathRadToDeg(acos(Vecteur.x / hypothenuse));
if (Vecteur.y > 0) return -fAngle;
return fAngle;
}
// EULER EXPLICITE
void Particule::calculerDeplacement(double dt)
{
if (m_matiere != NULL)
{
Vecteur a = 1.0/getMasse() * m_resf;
m_pos2 += dt*(m_v + 0.5*dt*a);
m_v2 += dt*a;
m_resf = Vecteur();
}
}
bool Vecteur::intersection(Point const& a, Point const& b, Point const& c, Point const& d)
{
Vecteur ab(a,b);
Vecteur cd(c,d);
if (ab.estNul())
{
if (cd.estNul())
return false;
else
return ( cd.mixte(Vecteur(c,a)) == 0 && cd*Vecteur(c,a) >= 0 && cd*Vecteur(d,a) <= 0 );
}
else if (cd.estNul())
return ( ab.mixte(Vecteur(a,c)) == 0 && ab*Vecteur(a,c) >= 0 && ab*Vecteur(b,c) <= 0 );
else
return ( ab.mixte(Vecteur(a,c))*ab.mixte(Vecteur(a,d)) <= 0 && cd.mixte(Vecteur(c,a))*cd.mixte(Vecteur(c,b)) <= 0 );
}
EDirection SC_GetDirectionVector(TGfxVec2 & Position, TGfxVec2 Direction)
{
TGfxVec2 Vecteur(Direction - Position);
float hypothenuse = Vecteur.Length();
float fAngle = GfxMathRadToDeg(acos(Vecteur.x / hypothenuse));
if (Vecteur.y > 0) fAngle *= -1;
if (fAngle > -45.0f && fAngle < 45.0f)
return EDirection_Right;
else if (fAngle > 45.0f && fAngle < 135.0f)
return EDirection_Up;
else if (fAngle < -45.0f && fAngle > -135.0f)
return EDirection_Down;
else if (fAngle < -135.0f && fAngle > 45.0f)
return EDirection_Left;
else
return EDirection_Left;
}
Point::Point( double x, double y):
_coord(Vecteur(x,y))
{}
Vecteur Vecteur::normal() const
{
return Vecteur(-m_y, m_x);
}
Point* Point::homothetie(const Point &p, const double &scale) const{
return p.translation(scale* Vecteur(p,*this));
}
// Suppose que la matrice est 2x2
Vecteur operator*(const double* mat, const Vecteur& v)
{
return Vecteur(mat[0]*v.m_x + mat[2]*v.m_y,
mat[1]*v.m_x + mat[3]*v.m_y);
}
Vecteur operator*(int n, const Vecteur& v)
{
return Vecteur(v.getX() * n, v.getY() * n);
}
Vecteur operator-(const Vecteur& v)
{
return Vecteur(-v.getX(), -v.getY());
}
Vecteur operator-(const Point& a, const Point& b)
{
return Vecteur(a.getX() - b.getX(), a.getY() - b.getY());
}
Vecteur operator+(const Point& a, const Vecteur& v)
{
return Vecteur(a.getX() + v.getX(), a.getY() + v.getY());
}
void Particule::collision(Element& e, int x, int y, int taille,
bool haut, bool gauche, bool bas, bool droite)
{
// A ce stade, p et cette particule sont dans la même "boîte"
// d'après les coordonnées en double, les coordonnées entières ne sont pas les mêmes
double xCol=0.0, yCol=0.0; // Coordonnées double de la collision (au bord de la "boîte" de p)
double vx = m_v.getX();
double vy = m_v.getY();
bool ch = false, cg = false, cb = false, cd = false; // Direction par laquelle arrive la particule
// Réglage de la position : au bord de la "boîte"
double newX = m_pos.getX();
double newY = m_pos.getY();
if (x+taille-1 < m_x)
{
newX = (double)m_x + OFFSET_COLLISION;
// Logiquement, vx != 0.0
xCol = (double)(x+taille);
yCol = m_pos.getY() + vy/vx*(xCol-m_pos.getX());
cd = true;
}
else if (x > m_x)
{
newX = (double)(m_x+1) - OFFSET_COLLISION;
// Logiquement, vx != 0.0
xCol = (double)x;
yCol = m_pos.getY() + vy/vx*(xCol-m_pos.getX());
cg = true;
}
if (y+taille-1 < m_y)
{
newY = (double)m_y + OFFSET_COLLISION;
if (!(cg||cd) || yCol > (double)(y+taille))
{
// Logiquement, vy != 0.0
yCol = (double)(y+taille);
xCol = m_pos.getX() + vx/vy*(yCol-m_pos.getY());
}
cb = true;
}
else if (y > m_y)
{
newY = (double)(m_y+1) - OFFSET_COLLISION;
if (!(cg||cd) || yCol < (double)y)
{
// Logiquement, vy != 0.0
yCol = (double)y;
xCol = m_pos.getX() + vx/vy*(yCol-m_pos.getY());
}
ch = true;
}
setPos(Vecteur(newX,newY));
// Modèle sphérique
Vecteur n(
e.getPos(), // Centre de p
Point(xCol,yCol) ); // Point de collision
// Gestion des liaisons, rebond sur une surface plane
if (haut && m_y-y < taille/2 || bas && m_y-y >= taille/2)
n = Vecteur(cd ? 1.0 : -1.0, 0.0);
else if (gauche && m_x-x < taille/2 || droite && m_x-x >= taille/2)
n = Vecteur(0.0, cb ? 1.0 : -1.0);
Vecteur vr = m_v - e.getV(); // Vitesse relative
double m1 = getMasse();
double m2 = e.getMasse();
Vecteur dvm = -2.0 / (m1+m2) / n.normeCarre()*(vr*n)*n; // Variation de vitesse, à la masse de la particule opposée près
// Application de la force de collision
appliquerDV(m2*dvm);
e.appliquerDV(-m1*dvm);
}
void Particule::collision(Particule& p)
{
// A ce stade, p et cette particule sont dans la même "boîte"
// d'après les coordonnées en double, les coordonnées entières ne sont pas les mêmes
double xCol=0.0, yCol=0.0; // Coordonnées double de la collision (au bord de la "boîte" de p)
double vx = m_v.getX();
double vy = m_v.getY();
bool deplacementX = false; // Détecte si cette particule s'est déplacé selon m_x (int)
// Réglage de la position : au bord de la "boîte"
double newX = m_pos.getX();
double newY = m_pos.getY();
if (p.m_x < m_x)
{
newX = (double)m_x + OFFSET_COLLISION;
// Logiquement, vx != 0.0
xCol = (double)(p.m_x+1);
yCol = m_pos.getY() + vy/vx*(xCol-m_pos.getX());
deplacementX = true;
}
else if (p.m_x > m_x)
{
newX = (double)(m_x+1) - OFFSET_COLLISION;
// Logiquement, vx != 0.0
xCol = (double)p.m_x;
yCol = m_pos.getY() + vy/vx*(xCol-m_pos.getX());
deplacementX = true;
}
if (p.m_y < m_y)
{
newY = (double)m_y + OFFSET_COLLISION;
if (!deplacementX || yCol > (double)(p.m_y+1))
{
// Logiquement, vy != 0.0
yCol = (double)(p.m_y+1);
xCol = m_pos.getX() + vx/vy*(yCol-m_pos.getY());
}
}
else if (p.m_y > m_y)
{
newY = (double)(m_y+1) - OFFSET_COLLISION;
if (!deplacementX || yCol < (double)p.m_y)
{
// Logiquement, vy != 0.0
yCol = (double)p.m_y;
xCol = m_pos.getX() + vx/vy*(yCol-m_pos.getY());
}
}
setPos(Vecteur(newX,newY));
// Calcul de la force de collision (peut être optimisé ?)
Vecteur n(
p.getPos(), // Centre de p
Point(xCol,yCol) ); // Point de collision
Vecteur vr = m_v - p.getV(); // Vitesse relative
double m1 = getMasse();
double m2 = p.getMasse();
Vecteur dvm = -2.0 / (m1+m2) / n.normeCarre()*(vr*n)*n; // Variation de vitesse, à la masse de la particule opposée près
// Application de la force de collision
appliquerDV(m2*dvm);
p.appliquerDV(-m1*dvm);
}
double Point::getDist(const Point &p)const{
return Vecteur(*this,p).norme();
}
/**
* @brief Point::rotation
* @param p le point à partir duquel il faut effectuer la rotation
* @param a l'angle de la rotation
* @return le point résultat
* Permet de calculer le point issus de la rotation du point courrant par rapport à p et a
*/
Point* Point::rotation(const Point &p, const Angle &a) const{
Vecteur rot(MatriceCarree2::getMatriceRotation(a) * Vecteur(p,*this));
return new Point( p._coord + rot );
}
Vecteur SetColorVMCommand::getColor() {
return Vecteur((float)data[4]/255.0, (float)data[5]/255.0, (float)data[6]/255.0, (float)data[7]/255.0);
}
void Catoms2DBlock::setColor(const Color &c) {
color = c;
getWorld()->updateGlData(this,Vecteur(ptrGlBlock->position[0],ptrGlBlock->position[1],ptrGlBlock->position[2]),ptrGlBlock->angle);
}
