Je n'arrive pas à trouver le problème (2 semaines que j'essaie) que j'ai avec les collisions de la raquette surtout pour la left_raquette.

Voici mes deux fichier les plus importants afin de m'aider:

main.c :

#define __USE_MINGW_ANSI_STDIO 1

#define SDL_MAIN_HANDLED

#include <SDL.h>

#include <stdio.h>

#include <stdlib.h>

#include <stdbool.h>

#include <math.h>

#include "definition.h"

#include "tick.h"

bool testCollision(maBalle_t ball, raquette_t raquette, pixelBord_t * pPixelTouch, int * index, int *nber_of_index) {

    //int pN = 0;

    bool flagIndex = false;

    int value = 0;

    int minAngle = 0;

    int maxAngle = 0;

    *nber_of_index=0;

    for (int n = 0; n < NB_PIXELS_BORD; n++) {

        if ( (raquette.position_x <= ball.position_x + ball.pixel_bord[n].delta_x) &&

             (ball.position_x + ball.pixel_bord[n].delta_x <= raquette.position_x + raquette.w) &&

             (raquette.position_y <= ball.position_y + ball.pixel_bord[n].delta_y) &&

             (ball.position_y + ball.pixel_bord[n].delta_y <= raquette.position_y + raquette.h) )  {

            pPixelTouch->delta_x = ball.pixel_bord[n].delta_x;

            pPixelTouch->delta_y = ball.pixel_bord[n].delta_y;

            *index = n;

            flagIndex = true;

            *nber_of_index = *nber_of_index+1;

            value+=n;

            if (n*DELTA_ANGLE_PIXELS_BORD>180){

                if (360-n*DELTA_ANGLE_PIXELS_BORD>minAngle){

                    minAngle=360-n*DELTA_ANGLE_PIXELS_BORD;

                }

            }

            else{

                if (n*DELTA_ANGLE_PIXELS_BORD>maxAngle){

                    maxAngle=n*DELTA_ANGLE_PIXELS_BORD;

                }

            }

        }

    }

    *index = (maxAngle-minAngle)/2 /DELTA_ANGLE_PIXELS_BORD;

    return flagIndex;

}

int main()

{

//The window we'll be rendering to

SDL_Window* window = NULL;

//The surface contained by the window

SDL_Renderer *renderer;

//To wait on event

SDL_Event event;

//Initialize SDL

if( SDL_Init( SDL_INIT_VIDEO|SDL_INIT_TIMER) < 0 )

{

printf( "SDL could not initialize! SDL_Error: %s\n", SDL_GetError() );

    return -1;

}

//Create window

window = SDL_CreateWindow( "Game Template", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, WINDOW_WIDTH, WINDOW_HEIGHT, SDL_WINDOW_SHOWN );

  if( window == NULL )

{

printf( "Window could not be created! SDL_Error: %s\n", SDL_GetError() );

    return -1;

}

    //Create window (it's possible to create the window and the renderer at the same time by SDL_CreateWindowAndRenderer() )

renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);

if( renderer == NULL )

{

printf( "Renderer could not be created! SDL_Error: %s\n", SDL_GetError() );

    return -1;

}

    //Add timer to have a timing event

    SDL_AddTimer(STEP_TICK_TIME, tickFunction, NULL);

//Load images to create a texture

SDL_Texture *texture[eNberOfTexture];

SDL_Surface *fond;

    fond = SDL_LoadBMP("img\\fond.bmp");

    texture[eFond] = SDL_CreateTextureFromSurface(renderer, fond);

    SDL_FreeSurface(fond);

    SDL_QueryTexture(texture[eFond], NULL,NULL,&rectfond.w,&rectfond.h);

    SDL_RenderCopy(renderer, texture[eFond], NULL, &rectfond);

SDL_Surface *zero;

    zero = SDL_LoadBMP("img\\zero.bmp");

    texture[eZero] = SDL_CreateTextureFromSurface(renderer, zero);

    SDL_FreeSurface(zero);

    SDL_Surface *un;

    un = SDL_LoadBMP("img\\un.bmp");

    texture[eUn] = SDL_CreateTextureFromSurface(renderer, un);

    SDL_FreeSurface(un);

    SDL_Surface *deux;

    deux = SDL_LoadBMP("img\\deux.bmp");

    texture[eDeux] = SDL_CreateTextureFromSurface(renderer, deux);

    SDL_FreeSurface(deux);

    SDL_Surface *trois;

    trois = SDL_LoadBMP("img\\trois.bmp");

    texture[eTrois] = SDL_CreateTextureFromSurface(renderer, trois);

    SDL_FreeSurface(trois);

    SDL_Surface *quatre;

    quatre = SDL_LoadBMP("img\\quatre.bmp");

    texture[eQuatre] = SDL_CreateTextureFromSurface(renderer, quatre);

    SDL_FreeSurface(quatre);

    SDL_Surface *cinq;

    cinq = SDL_LoadBMP("img\\cinq.bmp");

    texture[eCinq] = SDL_CreateTextureFromSurface(renderer, cinq);

    SDL_FreeSurface(cinq);

    SDL_Surface *six;

    six = SDL_LoadBMP("img\\six.bmp");

    texture[eSix] = SDL_CreateTextureFromSurface(renderer, six);

    SDL_FreeSurface(six);

    SDL_Surface *sept;

    sept = SDL_LoadBMP("img\\sept.bmp");

    texture[eSept] = SDL_CreateTextureFromSurface(renderer, sept);

    SDL_FreeSurface(sept);

    raquette_t right_raquette;

    right_raquette.position_x = WINDOW_WIDTH-INTIAL_POSX_RACKET-RAQUETTE1_WIDTH;

    right_raquette.position_y = WINDOW_HEIGHT/2-RAQUETTE1_HEIGHT/2;

    right_raquette.w = RAQUETTE1_WIDTH;

    right_raquette.h = RAQUETTE1_HEIGHT;

    SDL_Surface *raquette1;

    raquette1 = SDL_LoadBMP("img\\raquette1.bmp");

    texture[eRaquette1] = SDL_CreateTextureFromSurface(renderer, raquette1);

    SDL_FreeSurface(raquette1);

    rectraquette1.x = right_raquette.position_x;

    rectraquette1.y = right_raquette.position_y;

    rectraquette1.w = right_raquette.w;

    rectraquette1.h = right_raquette.h;

    SDL_QueryTexture(texture[eRaquette1], NULL,NULL,&rectraquette1.w,&rectraquette1.h);

    SDL_RenderCopy(renderer, texture[eRaquette1], NULL, &rectraquette1);

    SDL_RenderPresent(renderer);

    raquette_t left_raquette;

    left_raquette.position_x = INTIAL_POSX_RACKET;

    left_raquette.position_y = WINDOW_HEIGHT/2-RAQUETTE2_HEIGHT/2;

    left_raquette.w = RAQUETTE2_WIDTH;

    left_raquette.h = RAQUETTE2_HEIGHT;

    SDL_Surface *raquette2;

    raquette2 = SDL_LoadBMP("img\\raquette2.bmp");

    texture[eRaquette2] = SDL_CreateTextureFromSurface(renderer, raquette2);

    SDL_FreeSurface(raquette2);

    rectraquette2.x = left_raquette.position_x;

    rectraquette2.y = left_raquette.position_y;

    rectraquette2.w = left_raquette.w;

    rectraquette2.h = left_raquette.h;

    SDL_QueryTexture(texture[eRaquette2], NULL,NULL,&rectraquette2.w,&rectraquette2.h);

    SDL_RenderCopy(renderer, texture[eRaquette2], NULL, &rectraquette2);

    SDL_RenderPresent(renderer);

    // Déclarez et initialisez les scores pour les deux joueurs

    int scoreJoueur1 = 0;

    int scoreJoueur2 = 0;

    //création d'un rectangle --> je vais coller mes images du score à ces positions

    SDL_Rect rectscore1 = AFFICHAGE_SCORE1;

    SDL_Rect rectscore2 = AFFICHAGE_SCORE2;

    int redemarrage_tps_balle = 0;

    int nber_of_index;

    maBalle_t ball;

    ball.position_x = WINDOW_WIDTH / 2;

    ball.position_y = WINDOW_HEIGHT / 2;

    ball.vitesse= VITESSE_BALLE;

    ball.rayon = RAYON_BALLE;

    ball.angle = ANGLE;

    //ball.position_x += ball.vitesse * cos(ball.angle * PI / 180); // Convertir l'angle en radians

    //ball.position_y += ball.vitesse * sin(ball.angle * PI / 180);

    //Initialisation des pixels du bord de la balle

    for (int i=0;i<32;i++){

        ball.pixel_bord[i].delta_x = ball.rayon*cos((float)i*2*PI/32);

        ball.pixel_bord[i].delta_y = ball.rayon*sin((float)i*2*PI/32);

    }

    SDL_Surface *balle;

    balle = SDL_LoadBMP("img\\balle.bmp");

    texture[eBalle] = SDL_CreateTextureFromSurface(renderer, balle);

    SDL_FreeSurface(balle);

    SDL_Rect rectballe={ball.position_x-ball.rayon,ball.position_y-ball.rayon,2*ball.rayon,2*ball.rayon};

    SDL_QueryTexture(texture[eBalle], NULL,NULL,&rectballe.w,&rectballe.h);

    SDL_RenderCopy(renderer, texture[eBalle], NULL, &rectballe);

    //Pixel de collision

    pixelBord_t pixelTouch;

    int pixelIndex;

    //int angles[32] = {150, 145, 140, 135, 130, 125, 120, 115, 110, 105, 100, 95, 90, 85, 80, 75, 70, 65, 60, 55, 50, 45, 40, 35, 30, 25, 20, 15, 10, 5, 0};

    //int nber_of_index;

     while( (SDL_PollEvent(&event)>=0) && (event.key.keysym.scancode!=SDL_SCANCODE_ESCAPE) ){

            // Example of test on mouse event

            if (event.type == SDL_MOUSEBUTTONDOWN){

                printf("Mouse button down event\n");

            //User code for mouse button down event ...

            }

            // Example of test on mouse event

            if (event.type == SDL_MOUSEBUTTONDOWN){

                printf("Mouse button down event\n");

                //User code for mouse button down event ...

            }

            if (event.type == SDL_USEREVENT&& SDL_GetTicks() >= redemarrage_tps_balle ){

                // Mettre à jour la position de la balle

                ball.position_x += ball.vitesse * cos(ball.angle * PI / 180);

                ball.position_y += ball.vitesse * sin(ball.angle * PI / 180);

                // Collision avec les bords haut et bas

                if (ball.position_y <= 0 || ball.position_y + BALLE_WIDTH_HEIGHT >= WINDOW_HEIGHT){

                    ball.angle = -ball.angle;

                }

                 // Collisions avec la raquette gauche

                if (testCollision(ball, left_raquette, &pixelTouch, &pixelIndex, &nber_of_index)) {

                    printf("Collision with racket 1 at pixel %d.\n There is %d pixel touched.\n", pixelIndex,nber_of_index);

                    // Gérer l'angle en fonction du pixel touché

                    ball.angle = 2*(pixelIndex*DELTA_ANGLE_PIXELS_BORD+90)-ball.angle;

                }

                // Collisions avec la raquette droite

                if (testCollision(ball, right_raquette, &pixelTouch, &pixelIndex, &nber_of_index)) {

                    printf("Collision with racket 2 at pixel %d.\n There is %d pixel touched.\n", pixelIndex,nber_of_index);

                    // Gérer l'angle en fonction du pixel touché

                    ball.angle = 2*(pixelIndex*DELTA_ANGLE_PIXELS_BORD+90)-ball.angle;

                }

                // dépassement de la balle avec les bords gauche et droit de la fenêtre

                if (ball.position_x <= 0 || ball.position_x + BALLE_WIDTH_HEIGHT >= WINDOW_WIDTH) {

                    // Augmenter le score du joueur approprié

                    if (ball.position_x <= 0) {

                        scoreJoueur2++;

                    } else  {

                        scoreJoueur1++;

                    }

                    // Vérifier si l'un des joueurs a atteint 7 points et quitter la boucle principale si c'est le cas

                    if (scoreJoueur1 == 7 || scoreJoueur2 == 7) {

                    break;

                    }

                    // Remettre la balle au centre de la fenêtre

                    ball.position_x = (WINDOW_WIDTH / 2) - (BALLE_WIDTH_HEIGHT / 2);

                    ball.position_y = (WINDOW_HEIGHT / 2) - (BALLE_WIDTH_HEIGHT / 2);

                    SDL_Delay(1); //1ms

                    // Inverser la direction horizontale de la balle

                    ball.angle = -ball.angle;

                    redemarrage_tps_balle = SDL_GetTicks() + 500; //500ms

                    // Augmenter la vitesse de la balle

/*

                    if (ball.vitesse < 0) {

                        ball.vitesse = ball.vitesse - 2;

                    } else {

                        ball.vitesse = ball.vitesse + 2;

                    }

                    if (ball.vitesse < 0) {

                        ball.vitesse = ball.vitesse - 2;

                    } else {

                        ball.vitesse = ball.vitesse + 2;

                    }

*/

                }

        /* Exemple avec  le test sur l'état du clavier dans le tick system*/

            Uint8 *clavier;

            clavier = (Uint8 *)SDL_GetKeyboardState(NULL);

            if (clavier[SDL_SCANCODE_L]) {

                //printf("L pressed\n");

                right_raquette.position_y += VITESSE_RAQUETTE;

                if (right_raquette.position_y + right_raquette.h > WINDOW_HEIGHT) {

                    right_raquette.position_y = WINDOW_HEIGHT - right_raquette.h;

                }

            }

            if (clavier[SDL_SCANCODE_P]) {

                //printf("P pressed\n");

                right_raquette.position_y -= VITESSE_RAQUETTE;

                if (right_raquette.position_y < 0) {

                    right_raquette.position_y = 0;

                }

            }

            if (clavier[SDL_SCANCODE_W]) {

                //printf("W pressed\n");

                left_raquette.position_y -= VITESSE_RAQUETTE;

                if (left_raquette.position_y < 0) {

                    left_raquette.position_y = 0;

                }

            }

            if (clavier[SDL_SCANCODE_S]) {

                //printf("S pressed\n");

                left_raquette.position_y += VITESSE_RAQUETTE;

                if (left_raquette.position_y + left_raquette.h > WINDOW_HEIGHT) {

                    left_raquette.position_y = WINDOW_HEIGHT - left_raquette.h;

                }

            }

            if (event.type == SDL_USEREVENT ) {

                if ((event.type == SDL_KEYDOWN)) {

                    switch (event.key.keysym.scancode) {

                        case SDL_SCANCODE_SPACE:

                            printf("SPACE down event\n");

                            break;

                        default:

                            break;

                    }

                }

            }

            rectballe.x=ball.position_x-ball.rayon;

            rectballe.y=ball.position_y-ball.rayon;

            rectraquette2.x = right_raquette.position_x;

            rectraquette2.y = right_raquette.position_y;

            rectraquette1.x = left_raquette.position_x;

            rectraquette1.y = left_raquette.position_y;

            // Rendu des éléments

            SDL_RenderClear(renderer);

            SDL_RenderCopy(renderer, texture[eFond], NULL, &rectfond);

            SDL_RenderCopy(renderer, texture[eBalle], NULL, &rectballe);

            SDL_RenderCopy(renderer, texture[eRaquette2], NULL, &rectraquette2);

            SDL_RenderCopy(renderer, texture[eRaquette1], NULL, &rectraquette1);

            SDL_RenderPresent(renderer);

            // Afficher les scores des joueurs

            if (scoreJoueur1 >= 0 && scoreJoueur1 <= 7) {

                SDL_RenderCopy(renderer, texture[eZero + scoreJoueur1], NULL, &rectscore1);

            }

            if (scoreJoueur2 >= 0 && scoreJoueur2 <= 7) {

                SDL_RenderCopy(renderer, texture[eZero + scoreJoueur2], NULL, &rectscore2);

            }

            SDL_RenderPresent(renderer);

        }

        }

        //Destroy SDL objects

        for (int n=0;n<eNberOfTexture;n++)

        {

            SDL_DestroyTexture( texture[n] );

        }

        SDL_DestroyRenderer( renderer );

        SDL_DestroyWindow( window );

        SDL_Quit();

        if (scoreJoueur1 == 7 ) {

             printf("bravo joueur1 tu as gagne\n");

        } else {

                 printf("bravo joueur2 tu as gagne\n");

                }

        printf("Quit!\n");

return 0;

}

Utilises le bouton code </> du forum pour poster ton code ! (tu peux modifier ton post, lien modifier en haut à droite du post).

Hello,

Tu pourrais faire sauter un paquet de lignes, toutes celles qui vont de SDL_Surface *zero; à SDL_FreeSurface(eSept); car elles font la même chose:

char *bmp_name[]={"zero","un","deux","trois","quatre","cinq","six","sept"};

for(int i=eZero; i<=eSept; i++) {
	char filename[32];
	sprintf(filename,"img\\%s.bmp",bmp_name[i]);
	SDL_Surface *srfc=SDL_LoadBMP(filename);
	if(!srfc) {
		// traiter l'erreur et ....
	}
	texture[i]=SDL_CreateTextureFromSurface(renderer,srfc);
	SDL_FreeSurface(srfc);
}

Et encore plus simple en renommant tes fichiers bmp (zero.bmp → 0.bmp, un.bmp → 1.bmp, etc)

for(int i=eZero; i<=eSept; i++) {
	char filename[16];
	sprintf(filename,"img\\%d.bmp",i);
	SDL_Surface *srfc=SDL_LoadBMP(filename);
	if(!srfc) {
		// traiter l'erreur et ....
	}
	texture[i]=SDL_CreateTextureFromSurface(renderer,srfc);
	SDL_FreeSurface(srfc);
}

Et tout ça ne devrait pas se trouver dans le main(), mais dans une fonction.

Edit: et ton main() est beaucoup (beaucoup) trop long.

-
Edité par edgarjacobs 31 mai 2023 à 18:28:52

D'accord merci pour vos conseilles 

> le problème que j'ai avec les raquettes

Serait-il possible de décrire ce problème, plutôt que d'essayer de nous faire jouer aux devinettes sur la base d'un code incomplet ?

-
Edité par michelbillaud 5 juin 2023 à 8:04:18

j'ai réussi à régler le problème merci de votre aide. Faites moi savoir si vous voulez le code au complet