Discussion :

[MacMah0n]

Bonsoir à toutes et à tous !

Je viens poster ici car j'ai un petit soucis avec SDL et j'aimerais bien votre aide

En fait, j'ai comme projet en cours de faire une sorte de Shoot'em Up genre Flying Shark. (D'ailleurs décidasse à tout les gens de B1 à Supinfo en galère qui tomberont sur ce thread.)

J'arrive à faire défiler le background vers le bas, puis sur les cotés, pas de soucis. J'arrive aussi à déplacer mon avion dans tous les sens aussi.

Sauf qu'avant de commencer à gérer le tir des missiles, j'aimerais faire un peu d'ordre dans mon main (car oui, tout est dans mon main), et par exemple, mettre la partie qui gère le clavier, dans une fonction a part, et appeler cette fonction dans mon main (histoire d'organiser un peu mon code).

J'ai donc créé la fonction gestionClavier()
Je vais vous mettre mon code :

ini.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
#ifndef FONCTIONS_H  // Si FONCTIONS_H n'est pas défini...
#define FONCTIONS_H  // On défini FONCTIONS_H
 
#include <stdlib.h>
#include <stdio.h>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include <windows.h>
 
void gestionClavier(SDL_Surface *screen, SDL_Surface *background, SDL_Surface *airplane[], SDL_Surface *plane, SDL_Surface *ombre[], SDL_Surface *ombreActuelle, SDL_Rect positionAirplane, SDL_Rect cplane, SDL_Rect decoupe, int continuer);
#endif // FONCTIONS_H

gestionClavier.c

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
#include "ini.h" //prototypes
 
void gestionClavier(SDL_Surface *screen, SDL_Surface *background, SDL_Surface *airplane[], SDL_Surface *plane, SDL_Surface *ombre[], SDL_Surface *ombreActuelle, SDL_Rect positionAirplane, SDL_Rect cplane, SDL_Rect decoupe, int continuer,Uint8 *keystates,SDL_Event event)
{
    plane = airplane[0];
    ombreActuelle = ombre[0];
 
    SDL_PollEvent(&event);
 
    if (keystates[ SDLK_ESCAPE ] || event.type == SDL_QUIT)
    {
        continuer=0;
    }
 
    if (keystates[ SDLK_SPACE ])
    {
        //gestion du tir
    }
 
    if(keystates[SDLK_UP] || keystates[SDLK_w])
 
    {
        positionAirplane.y-=3;
        plane = airplane[1];
        ombreActuelle = ombre[1];
    }
 
    if(keystates[SDLK_RIGHT] || keystates[SDLK_d] && cplane.x + plane->w/2 < screen->w)
    {
        plane = airplane[2];
        ombreActuelle = ombre[2];
        if(cplane.x + plane->w/2 < screen->w)
            positionAirplane.x+=3;
    }
 
    if(keystates[SDLK_LEFT] || keystates[SDLK_a] && positionAirplane.x > 0)
    {
        plane = airplane[4];
        ombreActuelle = ombre[4];
        positionAirplane.x-=3;
    }
 
    if(keystates[SDLK_DOWN] || keystates[SDLK_s])
    {
        if(cplane.y < screen->h - plane->h) 
        {
            positionAirplane.y+=2;
        }
 
        if(keystates[SDLK_LEFT])
        {
            ombreActuelle = ombre[4];
            plane = airplane[5];
        }
 
        else if(keystates[SDLK_RIGHT])
        {
            ombreActuelle = ombre[2];
            plane = airplane[6];
        }
 
        else
        {
            ombreActuelle = ombre[3];
            plane = airplane[3];
        }
    }
 
    if(keystates[SDLK_LEFT] && cplane.x < 350 && decoupe.x > 0)
    {
        decoupe.x-=2;
        positionAirplane.x+=2;
    }
 
 
    if(keystates[SDLK_RIGHT] && cplane.x > 450 && decoupe.x < background->w - decoupe.w) 
    {
        decoupe.x+=2;
        positionAirplane.x-=2;
    }
}

et le main :

main.c

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
#include "ini.h"
 
int main(int argc, char *argv[])
{	
    /*VARIABLES*/
    int i = 0;
    int continuer = 1;
 
    SDL_Event event;
    SDL_Surface *airplane[7] = {NULL}, *ombre[5] = {NULL};
    SDL_Surface *screen = NULL, *background = NULL, *plane = NULL, *ombreActuelle = NULL;
    SDL_Rect positionBackground, positionAirplane, decoupe, cplane, positionOmbre;
    Uint8 *keystates = SDL_GetKeyState( NULL );
 
    positionBackground.x = 0;
    positionBackground.y = 0;
    cplane.x = 0;
    cplane.y = 0;
 
 
    /*PROGRAMME*/
 
    //Résolution 800x600 32bit double buffer permettant un rafraichissement fluide
    SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER);
    screen = SDL_SetVideoMode(800, 600, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
    //On donne un nom à notre fenêtre
    SDL_WM_SetCaption("Air Wars - Projet C", NULL);
 
    //On définit notre image de fond
    background = IMG_Load("img/map3.jpg");
    //On définit les images de l'avion
    airplane[0] = IMG_Load("img/aviondefault.png"); //Par defaut
    airplane[1] = IMG_Load("img/avionup.png"); //Quand on avance
    airplane[2] = IMG_Load("img/avionright.png"); //Quand on tourne à droite
    airplane[3] = IMG_Load("img/aviondown.png"); //Quand on recule
    airplane[4] = IMG_Load("img/avionleft.png"); //Quand on tourne à gauche
    airplane[5] = IMG_Load("img/aviondownleft.png"); //Quand on recule à gauche
    airplane[6] = IMG_Load("img/aviondownright.png"); //Quand on recule à droite
    plane = airplane[0];
    ombre[0] = IMG_Load("img/aviondefaultombre.png"); //Par defaut
    ombre[1] = IMG_Load("img/avionupombre.png"); //Quand on avance
    ombre[2] = IMG_Load("img/avionrightombre.png"); //Quand on tourne à droite
    ombre[3] = IMG_Load("img/aviondownombre.png"); //Quand on recule
    ombre[4] = IMG_Load("img/avionleftombre.png"); //Quand on tourne à gauche
 
    decoupe.x=background->w-screen->w-100; //le x de ta découpe, donc 0 puisque tu pars à gauche de ton image de fond.
    decoupe.y=background->h-screen->h; //y= la hauteur du fond moins la hauteur de ton ecran
    decoupe.h=screen->h; //la hauteur de découpe est égale à la hauteur de ton ecran
    decoupe.w=screen->w;// la largeur de la découpe 
    //Initialistion des coordonnées de l'avion
    positionAirplane.x = screen->w/2 - plane->w/2;
    positionAirplane.y = screen->h - plane->h;
 
 
    while (continuer)
    {
 
        //appelle de la fonction 
        gestionClavier(screen,background,airplane,plane,ombre,ombreActuelle,positionAirplane,cplane,decoupe,continuer,keystates,event);
 
 
 
 
        cplane.x = positionAirplane.x + plane->w/2;
        cplane.y = positionAirplane.y - plane->h/2;
 
 
        decoupe.y-=2;
 
        if(decoupe.y <= -background->h)
            decoupe.y=background->h;
 
 
        if(cplane.y < screen->h - plane->h) 
        {
            positionAirplane.y++;
        }
 
        positionOmbre.x = positionAirplane.x - 60;
        positionOmbre.y = positionAirplane.y + 75;
 
 
        SDL_BlitSurface(background, &decoupe, screen, &positionBackground);
        SDL_BlitSurface(plane, NULL, screen, &positionAirplane);
        SDL_BlitSurface(ombreActuelle, NULL, screen, &positionOmbre);
        SDL_Flip(screen);	
 
    }	
 
    //On libère les surfaces
    SDL_FreeSurface(background);
 
    for (i = 0 ; i < 7 ; i++)
    {
        SDL_FreeSurface(airplane[i]);
    }
 
    for (i = 0 ; i < 5 ; i++)
    {
        SDL_FreeSurface(ombre[i]);
    }
    //On ferme la fenètre
    SDL_Quit();
    return EXIT_SUCCESS;
}

Bon bien sûr l’appel ne fonctionne pas, il n'y a pas d'erreur mais quand le programme, on ne peut rien gérer au clavier du tout comme si la fonction n'existait pas, alors qu'elle est bien là et elle marche !

Je pense que c'est dû au SDL_Rect, qu'on ne peux pas convertir en pointeur et donc, lorsque qu'on incrémente la positionAirplane, ça ne met pas à jour la véritable variable, mais plutôt une copie.

Si vous avez des idées de comment faire ça serait génial...
Car j'ai essayé beaucoup de chose sans succès, je commence à croire que c'est pas possible.

Merci beaucoup !