Discussion :

[SiOuZ]

Bonjour voila je me suis fortement inspiré du tuto de loka , mais ma camera ne suit pas mon sprite , voici mon code :

Mon main.cpp

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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
 #include <iostream>
#include <string>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include <SDL/SDL_ttf.h>
#include "Point.h"
#include "map.h"
#include "constante.h"
 
 
 
//Les dimensions du point (l'image qu'on va deplacer)
const int POINT_WIDTH = 40;
const int POINT_HEIGHT = 80;
 
 
 
int main(int argc, char *argv[])
{
    int continuer =1;
    int map[NB_BLOCS_LARGEUR][NB_BLOCS_HAUTEUR];
    int x,y,i,j;
    Point monPoint;
 
    SDL_Event event2;
    SDL_Surface *sprite = NULL;
    SDL_Surface *screen,*texture1,*texture2,*texture3 = NULL;
    SDL_Rect position;
 
 
 
 
    SDL_Init(SDL_INIT_EVERYTHING);
    screen = SDL_SetVideoMode( SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP, SDL_HWSURFACE|SDL_DOUBLEBUF );
    SDL_WM_SetCaption( "Bouge le point", NULL );
 
    sprite = SDL_LoadBMP( "SiOu_Left_1.bmp" );
    sprite = SDL_DisplayFormat(sprite);
    SDL_SetColorKey( sprite, SDL_RLEACCEL | SDL_SRCCOLORKEY, SDL_MapRGB( sprite->format, 255, 255, 255 ) );
 
    //chargement des textures
    //texture1 = SDL_LoadBMP("tn225.bmp");
    texture1 = load_image("tn225.bmp");
    //texture2 = SDL_LoadBMP("tn226.bmp");
    texture2 = load_image("tn226.bmp");
    //texture3 = SDL_LoadBMP("tn227.bmp");
    texture3 = load_image("tn227.bmp");
 
 
 
 
    while (continuer)
    {
        while( SDL_PollEvent( &event2 ) )
        {
            //On remplit l'ecran de blanc
            //SDL_FillRect( screen, &screen->clip_rect, SDL_MapRGB( screen->format, 0, 0, 0) );
 
            monPoint.handle_input(event2,sprite, screen);
 
 
            if( event2.type == SDL_QUIT )
            {
                //On quitte the programme
                continuer = 0;
            }
 
        }
 
 
 
       if (!chargerMap(map))
        {
                exit(EXIT_FAILURE);
        }
 
        //Met la camera
        monPoint.set_camera();
 
 
        //Le point qu'on va utilise
                x = 0;
                y = 0;
 
        for (i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
        {
 
 
 
                for (j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
                {
                    position.x = i * TAILLE_BLOC;
                    position.y = j * TAILLE_BLOC;
 
                    switch(map[i][j])
                    {
                        case 0:
                            SDL_BlitSurface(texture1, NULL, screen, &position);
                            break;
                        case 1:
                            SDL_BlitSurface(texture2, NULL, screen, &position);
                            break;
                        case 2:
                            SDL_BlitSurface(texture3, NULL, screen, &position);
                            break;
                    }
 
 
                }
        }
 
 
        //SDL_FillRect(screen, 0, SDL_MapRGB(screen->format, 0, 0, 0));
        monPoint.move(sprite,screen);
        monPoint.show(sprite,screen);
 
        if( SDL_Flip( screen ) == -1 )
        {
            return 1;
        }
 
    }
    //Libèration des surfaces
    SDL_FreeSurface( sprite );
    //On quitte SDL
    SDL_Quit();
 
return EXIT_SUCCESS;
}

et mon fichier Point.cpp ou est créer ma fonction camera :

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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
#include <iostream>
#include <string>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include <SDL/SDL_ttf.h>
#include "Point.h"
#include "constante.h"
 
 
//Les dimensions du point (l'image qu'on va deplacer)
const int POINT_WIDTH = 20;
const int POINT_HEIGHT = 120;
 
SDL_Rect camera = { 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT };
 
 
void apply_surface( int x, int y, SDL_Surface* source, SDL_Surface* destination, SDL_Rect* clip = NULL )
{
    SDL_Rect offset;
 
    //Recuperation des coordonnées
    offset.x = x;
    offset.y = y;
 
    //On blitte la surface
    SDL_BlitSurface( source, clip, destination, &offset );
}
 
 
 
Point::Point()
{
    //Initialisation des coordonnees
    x = 0;
    y = 0;
 
    //Initialisation de la vitesse
    xVel = 0;
    yVel = 0;
}
 
 
 
void Point::handle_input(SDL_Event event, SDL_Surface* affichePoint,SDL_Surface* screen)
{
 
 
    if( event.type == SDL_KEYDOWN )
    {
        //ajustement de la vitesse
        switch( event.key.keysym.sym )
        {
            case SDLK_UP: yVel -= POINT_HEIGHT / 2; break;
            case SDLK_DOWN: yVel += POINT_HEIGHT / 2; break;
            case SDLK_LEFT: xVel -= POINT_WIDTH / 2; break;
            case SDLK_RIGHT: xVel += POINT_WIDTH / 2; break;
            default: break;
        }
    }
    //Si une touche a ete relachee
    else if( event.type == SDL_KEYUP )
    {
        //ajustement de la vitesse
        switch( event.key.keysym.sym )
        {
            case SDLK_UP: yVel += POINT_HEIGHT / 2; break;
            case SDLK_DOWN: yVel -= POINT_HEIGHT / 2; break;
            case SDLK_LEFT: xVel += POINT_WIDTH / 2; break;
            case SDLK_RIGHT: xVel -= POINT_WIDTH / 2; break;
            default: break;
        }
    }
 
}
 
 
 
void Point::move(SDL_Surface* source, SDL_Surface* destination)
{
 
    //Bouge le point à gauche ou à droite
    x += xVel;
 
    //Si le point se rapproche trop des limites(gauche ou droite) de l'ecran
    if( ( x < 0 ) || ( x + POINT_WIDTH > LEVEL_WIDTH ) )
    {
        //On revient
        x -= xVel;
    }
 
    //Bouge le point en haut ou en bas
    y += yVel;
 
    //Si le point se rapproche trop des limites(haute ou basse) de l'ecran
    if( ( y < 0 ) || ( y + POINT_HEIGHT > LEVEL_HEIGHT ) )
    {
        //On revient
        y -= yVel;
    }
 
 
}
 
void Point::set_camera()
{
    //Centre la camera sur le point
    camera.x = ( x + POINT_WIDTH / 2 ) - SCREEN_WIDTH / 2;
    camera.y = ( y + POINT_HEIGHT / 2 ) - SCREEN_HEIGHT / 2;
 
    //Garde la camera sur les bords
    if( camera.x < 0 )
    {
        camera.x = 0;
    }
    if( camera.y < 0 )
    {
        camera.y = 0;
    }
    if( camera.x > LEVEL_WIDTH - camera.w )
    {
        camera.x = LEVEL_WIDTH - camera.w;
    }
    if( camera.y > LEVEL_HEIGHT - camera.h )
    {
        camera.y = LEVEL_HEIGHT - camera.h;
    }
}
 
 
void Point::show(SDL_Surface* source, SDL_Surface* destination)
{
 
    //On blitte la surface
    SDL_BlitSurface( source, 0, destination, &camera );
    SDL_Flip(destination);
 
 
 
}
 
SDL_Surface *load_image( std::string filename )
{
    //L'image qui est chargée
    SDL_Surface* loadedImage = NULL;
 
    //L'image optimisée qu'on va utiliser
    SDL_Surface* optimizedImage = NULL;
 
    //Chargement de l'image
    loadedImage = SDL_LoadBMP( filename.c_str() );
 
    //Si l'image a bien chargée
    if( loadedImage != NULL )
    {
        //Création de l'image optimisée
        optimizedImage = SDL_DisplayFormat( loadedImage );
 
        //Libération de l'ancienne image
        SDL_FreeSurface( loadedImage );
 
        //Si la surface a bien été optimisée
        if( optimizedImage != NULL )
        {
            //transparence
            SDL_SetColorKey( optimizedImage, SDL_RLEACCEL | SDL_SRCCOLORKEY, SDL_MapRGB( optimizedImage->format, 255, 255, 255 ) );
        }
    }
 
    //On retourne l'image optimisée
    return optimizedImage;
}

Voila je ne comprends pas je n'ai pas de scrolling =(

[loka]

Bonjour,

Si tu regardes bien le tuto, tu as quelque part dans le code un truc du genre :

Code :

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

        apply_surface( 0, 0, background, screen, &camera );

Je pense que ton problème vient de ce côté là

[SiOuZ]

Mais justement ca revient pas a faire :

Code :

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

SDL_BlitSurface( source, 0, destination, &camera );

??

[coyotte507]

Salut

Code :

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

monPoint.show(sprite,screen);

Cette fonction-là devrait pas plutôt prendre le fond en premier paramètre?

De plus:

Code :

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

apply_surface( 0, 0, background, screen, &camera );

revient à:

Code :

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

SDL_BlitSurface( source, &camera, destination,NULL);

[SiOuZ]

Bha screen contient deja le fond en faite.

Sinon j'ai modifié mon code pour avoir cela :

Code :

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

SDL_BlitSurface( source, &camera, destination,NULL);

Mais c'est encore pire qu'avant la camera reste fixe et mon sprite fait nimporte quoi avec les sdl_event.

Je suis vraiment bloqué ladessus =(

[coyotte507]

Salut,

Essaie de bien comprendre le tutoriel au lieu de prendre le code et de le modifier.

Dans le tutoriel, il y a une surface background plus grande que l'écran.

Et le principe du scrolling dans ce cas-là, c'est de copier la bonne partie du background sur l'écran.

C'est tout simple

Si ça marche toujours pas, reprends à partir du code de loka puis modifie le petit à petit, en vérifiant à chaque fois, jusqu'au stade où tu veux parvenir.

N'oublie pas la troisième surface, la surface background!

[SiOuZ]

Effectivement j'ai fait un peu nimporte quoi avec mon background , actuellement j'ai fait un sdl_texture de background ou celui ci je lui insert plusieurs texture , et après je fais un :

Code :

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

SDL_BlitSurface(background,NULL,screen,&position);

Sauf que mon background est noire , donc est-il possible d'inserer plusieurs textures dans un sdl_texture ? ( normalement oui ? )

Voici le code qui insert plusieurs textures dans mon background :

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
//Le point qu'on va utilise
                x = 0;
                y = 0;
 
        for (i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
        {
 
 
 
                for (j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
                {
                    position.x = i * TAILLE_BLOC;
                    position.y = j * TAILLE_BLOC;
 
                    switch(map[i][j])
                    {
 
 
 
 
 
                        case 0:
                            SDL_BlitSurface(texture1, NULL, background, &position);
                            //apply_surface(i,j,mapRotation[i][j],texture1,screen,NULL);
                            break;
                        case 1:
                            SDL_BlitSurface(texture2, NULL, background, &position);
                            //apply_surface(i,j,mapRotation[i][j],texture2,screen,&position);
                            break;
                        case 2:
 
                            //apply_surface(i,j,mapRotation[i][j],texture3,screen,&position);
                            switch(mapRotation[i][j])
                            {
                                // rotozoomSurface (SDL_Surface *src, double angle, double zoom, int smooth);
                                // Permet de faire une rotation de l'image, de la zoomer et de la lisser
                                // smooth = lissage
 
                                case 1:
                                        rotation = rotozoomSurface(texture3,90,1.0,1);
                                        break;
                                case 2:
                                        rotation = rotozoomSurface(texture3,180,1.0,1);
                                        break;
                                case 3:
                                        rotation = rotozoomSurface(texture3,270,1.0,1);
                                        break;
 
                            }
 
                            SDL_BlitSurface(rotation, NULL, background, &position);
                            break;
                    }
 
 
                }
        }

Je ne vois rien que me choc la , c'est bien le problème je supose ( mon script pour inserer les texture fonctionnait quand j'inserais directement dans screen et non dans background )

[coyotte507]

Code :

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

SDL_BlitSurface(background,NULL,screen,&position);

Non, on copie une partie du background directement sur l'écran, et pas tout le background aux coordonnées données par position.

C'est plutôt

Code :

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

SDL_BlitSurface(background,&rectangle_source,screen,NULL);

Pour ce qui est de la surface background toute noire, c'est bizarre, tu as bien utilisé SDL_CreateRGBSurface pour créer la surface avant de faire des copiages dessus?

[SiOuZ]

Code :

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

SDL_BlitSurface(background,&rectangle_source,screen,NULL);

Oui c'est ce que j'avais fait a la base, mais comme j'avais un ecran de fond noir je l'ai enleve pour voir si ce n'était pas cela qui posait problème ...

Pour ce qui est de la surface background toute noire, c'est bizarre, tu as bien utilisé SDL_CreateRGBSurface pour créer la surface avant de faire des copiages dessus?

Non je ne l'avais pas fait , mais je l'ai ensuite rajouté voici le bout de code :

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
 
    SDL_Surface *background = NULL;
 
 
 
    /* Create a 32-bit surface with the bytes of each pixel in R,G,B,A order,
       as expected by OpenGL for textures */
 
    Uint32 rmask, gmask, bmask, amask;
 
   /* SDL interprets each pixel as a 32-bit number, so our masks must depend
       on the endianness (byte order) of the machine */
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
    rmask = 0xff000000;
    gmask = 0x00ff0000;
    bmask = 0x0000ff00;
    amask = 0x000000ff;
#else
    rmask = 0x000000ff;
    gmask = 0x0000ff00;
    bmask = 0x00ff0000;
    amask = 0xff000000;
#endif
 
    background = SDL_CreateRGBSurface(SDL_SWSURFACE, SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP,rmask, gmask, bmask, amask);

Mais ce n'est guère mieux j'ai tjs un background noir

[coyotte507]

Pour créer une surface ne t'embête pas:

Code :

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

background = SDL_CreateRGBSurface(SDL_SWSURFACE, SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP,0,0,0,0);

Après, colle la map sur le background morceau par morceau et colle le background directement sur l'écran rien que pour voir s'il est noir (n'oublie pas le SDL_Flip)

Si ça ne marche toujours pas, tu peux toujours donner un lien vers un code compilable qui reproduit le problème (si possible abrégé), avec les fichiers images, etc.

Je ne vois pas trop quoi d'autre pourrait être le problème...

[SiOuZ]

Ah avec ta déclaration de surface j'ai bien mon fond !! ( étrange )

Bon sinon ca avance un peu la camera fonctionne a moitié ( ou pas du tout en faite ), quand je bouge le perso il me change que les 2 permières texture que contient mon screen , je ne sais pas pourquoi , voici le code :

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
        while( SDL_PollEvent( &event2 ) )
        {
            monPoint.handle_input(event2,sprite, screen);
 
            if( event2.type == SDL_QUIT )
            {
                //On quitte the programme
                continuer = 0;
            }
 
        }
 
 
       if (!chargerMap(map))
        {
                exit(EXIT_FAILURE);
        }
 
       if (!chargerMapRotation(mapRotation))
        {
                exit(EXIT_FAILURE);
        }
 
 
        //Met la camera
        monPoint.set_camera();
 
 
        //Le point qu'on va utilise
                x = 0;
                y = 0;
 
        for (i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
        {
               for (j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
               {
                    position.x = i * TAILLE_BLOC;
                    position.y = j * TAILLE_BLOC;
 
                    switch(map[i][j])
                    {
                        case 0:
                            SDL_BlitSurface(texture1, NULL, background, &position);
                            break;
                        case 1:
                            SDL_BlitSurface(texture2, NULL, background, &position);
                            break;
                        case 2:
                            SDL_BlitSurface(texture3, NULL, background, &position);
                            break;
                    }
 
 
                }
        }
 
        monPoint.set_background(x,y,background,screen);
        monPoint.move(sprite,screen);
        monPoint.show(sprite,screen);
 
        if( SDL_Flip( screen ) == -1 )
        {
            return 1;
        }
 
    }

Boucle for permet de constituer mon background ( cela fonctionne très bien ) , la fonction set_background permet de faire un blit mon sdl_rect *backgrouns dans screen.
Le point move permet de bouger mon sprite , et show de l'afficher , et set_camera d'initialiser ma camera , voici les fonctions en questions :

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
void Point::handle_input(SDL_Event event, SDL_Surface* affichePoint,SDL_Surface* screen)
{
 
 
    if( event.type == SDL_KEYDOWN )
    {
        //ajustement de la vitesse
        switch( event.key.keysym.sym )
        {
            case SDLK_UP: yVel -= POINT_HEIGHT / 2; break;
            case SDLK_DOWN: yVel += POINT_HEIGHT / 2; break;
            case SDLK_LEFT: xVel -= POINT_WIDTH / 2; break;
            case SDLK_RIGHT: xVel += POINT_WIDTH / 2; break;
            default: break;
        }
    }
    //Si une touche a ete relachee
    else if( event.type == SDL_KEYUP )
    {
        //ajustement de la vitesse
        switch( event.key.keysym.sym )
        {
            case SDLK_UP: yVel += POINT_HEIGHT / 2; break;
            case SDLK_DOWN: yVel -= POINT_HEIGHT / 2; break;
            case SDLK_LEFT: xVel += POINT_WIDTH / 2; break;
            case SDLK_RIGHT: xVel -= POINT_WIDTH / 2; break;
            default: break;
        }
    }
 
}
 
 
 
void Point::move(SDL_Surface* source, SDL_Surface* destination)
{
 
    //Bouge le point à gauche ou à droite
    x += xVel;
 
    //Si le point se rapproche trop des limites(gauche ou droite) de l'ecran
    if( ( x < 0 ) || ( x + POINT_WIDTH > LEVEL_WIDTH ) )
    {
        //On revient
        x -= xVel;
    }
 
    //Bouge le point en haut ou en bas
    y += yVel;
 
    //Si le point se rapproche trop des limites(haute ou basse) de l'ecran
    if( ( y < 0 ) || ( y + POINT_HEIGHT > LEVEL_HEIGHT ) )
    {
        //On revient
        y -= yVel;
    }
 
 
}
 
void Point::set_camera()
{
    //Centre la camera sur le point
    camera.x = ( x + POINT_WIDTH / 2 ) - SCREEN_WIDTH / 2;
    camera.y = ( y + POINT_HEIGHT / 2 ) - SCREEN_HEIGHT / 2;
 
    //Garde la camera sur les bords
    if( camera.x < 0 )
    {
        camera.x = 0;
    }
    if( camera.y < 0 )
    {
        camera.y = 0;
    }
    if( camera.x > LEVEL_WIDTH - camera.w )
    {
        camera.x = LEVEL_WIDTH - camera.w;
    }
    if( camera.y > LEVEL_HEIGHT - camera.h )
    {
        camera.y = LEVEL_HEIGHT - camera.h;
    }
}
 
 
void Point::set_background(int x,int y,SDL_Surface* source, SDL_Surface* destination)
{
        SDL_Rect offset;
 
        offset.x = x;
        offset.y = y;
 
        SDL_BlitSurface(source,&camera,destination,&offset);
}
 
void Point::show(SDL_Surface* source, SDL_Surface* destination)
{
    //On blitte la surface
    SDL_BlitSurface( source, NULL, destination, &camera );
    SDL_Flip(destination);
 
}

Donc le soucis viendrait du set_camera , mais je basé sur le wiki de loki donc je vois pas trop ou est le problème =(

[coyotte507]

Salut,

je n'ai pas étudié tous les problèmes mais voici ce que j'ai vu:

Tu charges ta map à chaque affichage, c'est vraiment assez lent, tu devrais le faire en dehors de la boucle while(), avant.

Où initialise-tu camera.w et camera.h?

La fonction point::show doit afficher le point à ses coordonnées, pas aux coordonnées de la camera:

Code :

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

1
2
3
4
5
6
7
8
void Point::show(SDL_Surface* source, SDL_Surface* destination)
{
    SDL_Rect point = {x-camera.x, y-camera.y, 0, 0};
    //On blitte la surface
    SDL_BlitSurface( source, NULL, destination, &point );
    SDL_Flip(destination);
 
}

Y'a-t-il encore des problèmes?

[SiOuZ]

Tout d'abord je m'étais apercu de ma spuditité concernant le chargement du background je l'ai sorti de la boucle juste après mon poste.

Où initialise-tu camera.w et camera.h?

Je l'initialise par l'appell de monPoint.set_camera();

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
void Point::set_camera()
{
    //Centre la camera sur le point
    camera.x = ( x + POINT_WIDTH / 2 ) - SCREEN_WIDTH / 2;
    camera.y = ( y + POINT_HEIGHT / 2 ) - SCREEN_HEIGHT / 2;
 
    //Garde la camera sur les bords
    if( camera.x < 0 )
    {
        camera.x = 0;
    }
    if( camera.y < 0 )
    {
        camera.y = 0;
    }
    if( camera.x > LEVEL_WIDTH - camera.w )
    {
        camera.x = LEVEL_WIDTH - camera.w;
    }
    if( camera.y > LEVEL_HEIGHT - camera.h )
    {
        camera.y = LEVEL_HEIGHT - camera.h;
    }
}

J'ai modifié le code que tu m'as dit il y a du progrès mais je ne comprends pas trop ce qu'on fait en faite avec cette ligne :

SDL_Rect point = {x-camera.x, y-camera.y, 0, 0};

X et Y sont les positions du sprite alors pourquoi on enlève la position de la camera sur X et Y je comprends vraiment pas.

Sinon ma camera se deplace correctement mais j'ai un bug d'affichage sur les zones non affiché a la base voici un screen :

http://img201.imageshack.us/my.php?image=testzts.jpg

[coyotte507]

Salut,
camera.w et camera.h ne sont pas initialisé dans la fonction que tu m'as présentée. (mais camera.x et .y si)

Code :

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

SDL_Rect point = {x-camera.x, y-camera.y, 0, 0};

D'après ce que j'ai compris x représente la position du point dans le niveau, et pas la position relative à la caméra. en faisant x-camera.x, j'ai la position relative à la caméra.

Pour le reste, j'ai des restriction sévères sur ma connexion internet donc je ne peux pas aller voir l'image du bug (désolé)

Néanmoins la fonction SDL_BlitSurface peut changer les rectangles passés en paramètre, c'est peut-être pour ça que tu as des bugs au niveau de l'affichage si tu réutilises ces rectangles sans réinitialiser leurs paramètres (notamment camera.w et camera.h). Mais ce n'est pas sûr que ce soit le problème.

Coyotte508

[SiOuZ]

J'ai modifier ma fonction set_camera pour initialiser camera.w et camera.h , mais cela ne change pas le problème

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
void Point::set_camera()
{
 
    camera.w = SCREEN_WIDTH;
    camera.h = SCREEN_HEIGHT;
 
    //Centre la camera sur le point
    camera.x = ( x + POINT_WIDTH / 2 ) - SCREEN_WIDTH / 2;
    camera.y = ( y + POINT_HEIGHT / 2 ) - SCREEN_HEIGHT / 2;
 
    //Garde la camera sur les bords
    if( camera.x < 0 )
    {
        camera.x = 0;
    }
    if( camera.y < 0 )
    {
        camera.y = 0;
    }
    if( camera.x > LEVEL_WIDTH - camera.w )
    {
        camera.x = LEVEL_WIDTH - camera.w;
    }
    if( camera.y > LEVEL_HEIGHT - camera.h )
    {
        camera.y = LEVEL_HEIGHT - camera.h;
    }
}

La je seche totalement

[coyotte507]

Bonsoir,

Est-ce que tu peux joindre le zip de ton projet?

je ne te promet rien.

[SiOuZ]

http://www.4shared.com/file/91897359/92bbb8f7/Code.html

Encore merci pour ton aide !

[Mat.M]

bon j'ai testé avec Visual C++ 6.0
Le personnage se déplace bien sur l'écran mais est-tu sur de vouloir faire un scrolling ?
Ton tableau de cases n'est pas assez grand et les limites semblent être dépassées lorsqu'on presse les touches de curseur


Bon ça y est je crois avoir trouvé l'erreur
Au lieu d'avoir cela

Code :

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

1
2
 
source = SDL_CreateRGBSurface(SDL_SWSURFACE, SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP,0,0,0,0);

il faut avoir cela:

Code :

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

1
2
 
 source = SDL_CreateRGBSurface(SDL_SWSURFACE, LEVEL_WIDTH, LEVEL_HEIGHT, SCREEN_BPP,0,0,0,0);

C'est normal que cela ne marchait pas tu allouais une SDL_Surface de 1024*728 alors que le niveau en dimensions de blocs fait le double !

[SofEvans]

Bonsoir,

J'ai essayer de regarder tes code mais je suis plus qu'un grand debutant en C++ alors je comprend pas trop.
Par contre, j'ai deja fais une camera en C avec la sdl.

J'ai aussi rencontrer le bug que j'ai vu et cela survenait lorsque mon personnage sortait du background ( par exemple : si ta un background de longueur 1000 et que ton personnage va en 1020 ... )
Essais de voir si tu a bien gerer ce cas.

Je te conseille aussi de jeter un oeil a ca pour bien voir ce qui se passe avec SDL_BlitSurface.

http://www.gnurou.org/files/images/S...g4.preview.png

en esperant ne pas avoir dit de connerie et avoir pu t'aider

[SiOuZ]

bon j'ai testé avec Visual C++ 6.0
Le personnage se déplace bien sur l'écran mais est-tu sur de vouloir faire un scrolling ?
Ton tableau de cases n'est pas assez grand et les limites semblent être dépassées lorsqu'on presse les touches de curseur


Bon ça y est je crois avoir trouvé l'erreur
Au lieu d'avoir cela

Code :

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

1
2
 
source = SDL_CreateRGBSurface(SDL_SWSURFACE, SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP,0,0,0,0);

il faut avoir cela:

Code :

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

1
2
 
 source = SDL_CreateRGBSurface(SDL_SWSURFACE, LEVEL_WIDTH, LEVEL_HEIGHT, SCREEN_BPP,0,0,0,0);

C'est normal que cela ne marchait pas tu allouais une SDL_Surface de 1024*728 alors que le niveau en dimensions de blocs fait le double !

C'était ca Je suis degouté d'avoir perdu un temps fou pour une erreur aussi stupide !