[ALGO] algorithme de collision en fromage

[cegdd]

bonjour bonjour !

pour j'ai codé un petit algorithme qui me permet de tester si notre personnage fait face à une image ou non.

le tout avec une marge dynamique

pour les non-initié à la SDL, la structure SDL_Rect contient les coordonnées : x, y, w et h d'une image.

j'ai crois donc qu'il est important de vous le faire partager

bool colisionfromage(SDL_Rect lanceur, SDL_Rect recepteur, SDL_Rect curseur, double marge)
{
    double degre, degre2, diff;
    int difx, dify;

    difx = (lanceur.x + lanceur.w/2) - (curseur.x + curseur.w/2); //calcul de la difference en pixel
    dify = (lanceur.y + lanceur.h/2) - (curseur.y + curseur.h/2); //entre le lanceur et le pointeur de la souris
    degre = atan2(dify, difx);//obtention de l'angle en radian

    difx = (lanceur.x + lanceur.w/2) - (recepteur.x + recepteur.w/2); //calcul de la difference en pixel entre
    dify = (lanceur.y + lanceur.h/2) - (recepteur.y + recepteur.h/2); //le lanceur et l'objectif
    degre2 = atan2(dify, difx);//obtention de l'angle en radian

	degre  *= 57.296;//conversion en degre
	degre2 *= 57.296;

	degre   += 180; //ajustement pour passer d'un systeme (-180/180) à un systeme (0/360)
	degre2  += 180;

	diff = degre-degre2;//calcul de la différence

	if (diff < 0) //si diff est négatif, on le passe en positif
    {
        diff *= -1;
    }

	if (diff <= 0 || diff >= marge/2) //si la différence est plus grande que la marge, nous retournons FAUX
    {
        return FALSE;
    }
    return TRUE;
}

si vous avez des questions / remarques, comme d'habitude, je vous écoute !

edit : je sais que ce code a un défaut, le calcul de la différence ne marche pas si l'un est <360 et l'autre >0. mais je ne sais pas comment gérer ça simplement. des idées ?

[cegdd]

décidement je n'ais pas été très long a l'améliorer en clareté ^^

voici le nouveau code

bool colisionfromage(SDL_Rect lanceur, SDL_Rect recepteur, SDL_Rect curseur, double marge)
{
    register double diff;

	diff = (FindAngle(lanceur, recepteur)+180) - (FindAngle(lanceur, curseur)+180);

	if (diff < 0) //si diff est négatif, on le passe en positif
    {
        diff *= -1;
    }

	if (diff <= 0 || diff >= marge/2) //si la différence est plus grande que la marge, nous retournons FAUX
    {
        return FALSE;
    }
    return TRUE;
}
double FindAngle(SDL_Rect A, SDL_Rect 
{
    register int difx, dify;

    difx = (A.x + A.w/2) - (B.x + B.w/2);
    dify = (A.y + A.h/2) - (B.y + B.h/2);

    return atan2(dify, difx)* 57.296;
}

[mars073]

mmhhh.. fromage ^-^

Très utile, merci du partage.

+1Rep

[cegdd]

cet algorithme, couplé avec celui-ci :

int checkdistance(SDL_Rect A, SDL_Rect B, int lenght)
{

	double difx = A.x+(A.w/2) - B.x+(B.w/2);
	double dify = A.y+(A.h/2) - B.y+(B.h/2);

	if (difx < 0) {difx = difx*-1;}
	if (dify < 0) {dify = dify*-1;}

	double resultat = sqrt((difx*difx)+(dify*dify));

	if (resultat <= lenght) {return -1;}
	else if (resultat > lenght) {return 1;}
	return 0;
}

qui sert a vérifier la distance entre les milieux de deux images.

permet donc de faire des collision de ce style :


[AlexMog]

Ouille, les passages des arguments par copie font bien mal là (n'oublie pas que SDL_* sont des structures, et que tu les passes par copie... Tu ralentit ton programme, et il consomme des ressources qu'il pourrait ne pas consommer. Je te conseille mon cours sur les bonnes pratiques en C )

Sinon, gg l'algo

[Azad]

Merci de ton partage, ça fait toujours plaisir à voir.
Tu as besoin d'aide pour l'optimisation de ton code (je dis ça juste en référence au message d'AlexMog, je me permets pas de juger ton code ) ?

[cegdd]

j'ai refait le code:

bool colisionfromage(SDL_Rect *lanceur, SDL_Rect *recepteur, SDL_Rect *curseur, double marge)
{
    register double diff;

	diff = (FindAngle(lanceur, recepteur)+180) - (FindAngle(lanceur, curseur)+180);

	if (diff < 0) //si diff est négatif, on le passe en positif
    {
        diff *= -1;
    }

	if (diff <= 0 || diff >= marge/2) //si la différence est plus grande que la marge, nous retournons FAUX
    {
        return FALSE;
    }
    return TRUE;
}
double FindAngle(SDL_Rect *A, SDL_Rect *
{
    register int difx, dify;

    difx = (A->x + A->w/2) - (B->x + B->w/2);
    dify = (A->y + A->h/2) - (B->y + B->h/2);

    return atan2(dify, difx)* 57.296;
}

@azad : je peux me débrouiller seul, mais de l'aide est toujours bienvenue

@AlexMog: j'ai essayé de faire mieux, c'est ce que tu voulais ?

d'autres idées ?

[Azad]

Je n'ai pas trop suvi l'ensemble du code, mais ça me semble bizarre que tu aies deux instructions pour le IF qui se suivent, et qui peuvent toutes les deux êtres "enclenchées".
Là, tu fais :

IF diff < 0

IF diff <= 0 ...

Tu devrais peut-être tourner ça dans un else if à mon sens, et prendre le problème à l'envers. Je dis ça sur le coup, j'ai absolument pas réfléchis à la manière d'optimiser et ce n'est qu'une idée qui est peut-être fausse !
AlexMog pourrait approuver ou désapprouver mon idée (s'il arrive à comprendre ce dont je parle), et expliquerait ça peut être mieux que moi.

[AlexMog]

C'est mieux cegdd

@Azad: je ne vois pas de quoi tu parles x)

Par contre, @cegdd: le mot clé "register" est déconseillé depuis gcc 1.2 (on est déjà à la 4.0), car tu empeche le compilateur de pouvoir faire ses propres optimisations mémoire (en sachant qu'il est plus intelligent que nous pour ça )