Discussion :

[sorry60]

Salut,

Je me pose des questions sur l'élaboration d'un scrolling dans un jeu style RPG.
J'ai pensé à une solution, je la soumets à vos avis :

Declarer 2 buffers :
un de la taille de l'ecran : SDL_Surface *screen
un beaucoup plus grand de la taille de la map entiere : SDL_Surface *map
On blit toutes les tiles dans map.
Puis on blit le centre de map dans screen, quelque chose dans le genre :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
SDL_Surface *screen = SDL_setVideo....;
SDL_Surface map = SDL_CreateRGBSurface....;
SDL_Rect scr;
SDL_Rect dest;
/* on suppose que map contient toutes les tiles */
/* on positionne screen au centre de map*/
src.x = map->w/2;
src.y = map->h/2;
src.w = screen->w;
src.h = screen->h;
SDL_BlitSurface(map,&src,screen,NULL);
SDL_Flip(screen);

Ainsi quand le perso se deplace, il suffit de modifié src.x et src.y et de refaire le blit :

Code :

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

1
2
3
4
5
6
7
/* Par exemple le scrolling va vers le haut avec une vitesse SPEED */
src.x = map->w/2;
src.y = map->h/2 - SPEED;
src.w = screen->w;
src.h = screen->h;
SDL_BlitSurface(map,&src,screen,NULL);
SDL_Flip(screen);

voila, j'attends vos commentaires..car il y a surement mieux
Je n'ai pas testé cette solution, c'etait juste une approche sur papier (enfin surtout dans ma tete).
Merci pour vos réponses

Sorry

[mat.M]

Oui cela semble correct.
En fait pour faire un défilement il faut définir comme une fenêtre qui représente l'écran sa résolution; cette fenêtre laisse apparaitre une partie d'une carte large ( map)

[sorry60]

Oui cela semble correct.
En fait pour faire un défilement il faut définir comme une fenêtre qui représente l'écran sa résolution; cette fenêtre laisse apparaitre une partie d'une carte large ( map)

OK merci, j'implemente ça de suite

[mat.M]

Oui cela semble correct.
En fait pour faire un défilement il faut définir comme une fenêtre qui représente l'écran sa résolution; cette fenêtre laisse apparaitre une partie d'une carte large ( map)

OK merci, j'implemente ça de suite

quand il y aura quelque chose à voir fais nous signe ...

signé Clint

[Azharis]

Je suis justement en train d'apprendre à faire des RPG 2D et je viens de finir la gestion de ma première map.

Pour ce qui est de ta solution, elle est bien mais j'ai opté pour une autre que je vais essayer de t'expliquer.

J'ai une classe CChipset qui possède une surface pointant vers le bitmap contenant tous mes tiles avec chaque tile assigné à un numéro, et une classe CMap qui contient un tableau aussi grand que le nombre de tile de la map (pour une map de 200 * 100 tiles, le tableau fera 20000 cases), chaque case ayant le numéro du tile correspondant.

Lorsqu'il faut afficher la carte, je la centre sur le personnage (si les bords me le permettent) puis j'affiche seulement les tiles qui apparaissent en les blittants un par un.

[sorry60]

Je suis justement en train d'apprendre à faire des RPG 2D et je viens de finir la gestion de ma première map.

Pour ce qui est de ta solution, elle est bien mais j'ai opté pour une autre que je vais essayer de t'expliquer.

J'ai une classe CChipset qui possède une surface pointant vers le bitmap contenant tous mes tiles avec chaque tile assigné à un numéro, et une classe CMap qui contient un tableau aussi grand que le nombre de tile de la map (pour une map de 200 * 100 tiles, le tableau fera 20000 cases), chaque case ayant le numéro du tile correspondant.

Lorsqu'il faut afficher la carte, je la centre sur le personnage (si les bords me le permettent) puis j'affiche seulement les tiles qui apparaissent en les blittants un par un.

HS : tu apprends ça à l'ecole ou pour ton plaisir ?

[Azharis]

Malheureusement c'est pour le plaisir, j'aurais aimer être à une école pour apprendre ça.

Pourquoi cette question ?

[sorry60]

Malheureusement c'est pour le plaisir, j'aurais aimer être à une école pour apprendre ça.

Pourquoi cette question ?

Justement car moi aussi j'aimerais une école pour apprendre ça

[JEG]

Hello, dans mon projet j'ai opté pour une solution similaire à celle d'Azharis, qui permet de garder de bonne performances quand la taille de la carte est vraiment très grande. (plus qu'énorme dans mon cas)

en fait mon backbuffer est de la taille suivante :

* (largeurEcran/largeurTile + 2)*largeurTile, pour la largeur
* (hauteurEcran/HauteurTile + 2)*hauteurTile, pour la hauteur

les "+2" servent à faire un scroll fin, ca rajoute deux colonnes de tiles à gauch e et à droite, et deux rangées en haut et en bas.

cf le lien dans ma signature si tu veux essayer pour voir ce que ca donne.

[Zenol]

Je suis justement en train d'apprendre à faire des RPG 2D et je viens de finir la gestion de ma première map.

Pour ce qui est de ta solution, elle est bien mais j'ai opté pour une autre que je vais essayer de t'expliquer.

J'ai une classe CChipset qui possède une surface pointant vers le bitmap contenant tous mes tiles avec chaque tile assigné à un numéro, et une classe CMap qui contient un tableau aussi grand que le nombre de tile de la map (pour une map de 200 * 100 tiles, le tableau fera 20000 cases), chaque case ayant le numéro du tile correspondant.

Lorsqu'il faut afficher la carte, je la centre sur le personnage (si les bords me le permettent) puis j'affiche seulement les tiles qui apparaissent en les blittants un par un.

Saufe que cette technique commence a devenir lourde quand tu a plusieures couches de titles diférents. Je prend le cas extrème ou tu a 10 couches comportant des mlenges de diférents fichiers bitmaps... Dans ce cas, il vaut mieu se raporter a l'utilisation d'une unique surface, si on veut eviter de perdre du temp avec le blit.

[mat.M]

Je suis justement en train d'apprendre à faire des RPG 2D et je viens de finir la gestion de ma première map.

Pour ce qui est de ta solution, elle est bien mais j'ai opté pour une autre que je vais essayer de t'expliquer.

J'ai une classe CChipset qui possède une surface pointant vers le bitmap contenant tous mes tiles avec chaque tile assigné à un numéro, et une classe CMap qui contient un tableau aussi grand que le nombre de tile de la map (pour une map de 200 * 100 tiles, le tableau fera 20000 cases), chaque case ayant le numéro du tile correspondant.

Lorsqu'il faut afficher la carte, je la centre sur le personnage (si les bords me le permettent) puis j'affiche seulement les tiles qui apparaissent en les blittants un par un.

je suis d'accord avec JC Master c'est trop lourd à gérer.
Et en plus le joueur va se perdre dans une zone de jeux si grande

[sorry60]

Bonjour à tous,

J'ai implémenté la méthode dont je parlais tout au début (les 2 buffers).
Je la trouve nickel

Merci pour vos avis, j'en prends note au cas où

[Azharis]

Par hasard vous ne sauriez pas où est-ce que l'on peut trouver des tuto (de préférence en français) sur les layer pour les map car je n'arrive pas a en trouver ?

[JEG]

La solution 1 marche bien quand la map est statique, mais si tous les tiles sont animés, alors ca ne conviendra plus, il faudra à chaque passage réactualiser le backbuffer, donc toute la carte.

Dans la solution 2, il faudra certes réactualiser le backbuffer, mais uniquement la portion affichée, et ensuite basculer en une seule fois le backbuffer sur l'affichage.

[sorry60]

Par hasard vous ne sauriez pas où est-ce que l'on peut trouver des tuto (de préférence en français) sur les layer pour les map car je n'arrive pas a en trouver ?

C'est quoi un layer ?

[Laurent Gomila]

C'est quoi un layer ?

Une couche. En 2D on peut utiliser plusieurs couches pour le rendu : le décor, les entités animées, le texte, ... Ca permet de déterminer un ordre d'affichage.

[Zenol]

Bon, alors moi aussi je vais en profiter pour poser ma question sur le scroll.
J'ai une classe MAP, qui contien des objets BLOCK contenent eux même des SPRIT.
Chaque sprit a ses x&y.(Comme sa sa peut paraitre lourd, saufe que les sprits sont "ponctuelles". Pour ce qui est le fond, il est gèrer par un seul element qui apartient a MAP)

Donc, j'ésite entre plusieures solution pour efectuer le scroll :
1 : Ge génère une surface de (largeur+2*32)*(hauteur+2*32)pixels, et dedan je selectione largeur*hauteur pixels que j'afiche.
2 : Je passe en paramêtre a la fonction BlitSurface de MAP le scrollx et le scrolly et cette fonction se débroille pour tout bliter sur une surface de largeur*hauteur pixels.

J'ai choisi la 2, saufe que la, je ne voi pas trop comment cette fonction peut se débroiller...
Déja, rien que pour l'afichage du fond, qui est un simple caré qui se répète, je ne sais pas exactement comment faire...

J'aurais aimer pourvoir décaler les images a bliter, et dans ce cas j'aurais bliter (2*hauteur+2*largeur)-4 chipset de plus(corespond au bordures), seulement si Rect.x ou Rect.y voir les deux sont negatife, la partie qui devrais disparaitre se retrouve bliter de l'aure coté de l'image!

De quels fasont me conseillez vous de procèder?

[JEG]

J'ai beaucoup de mal à te comprendre JC_Master, surtout sur la notion de chipset (???), mais je vais essayer de t'expliquer la méthode que j'utilise (avec laquelle j'obtiens de très bonne performances, et qui me permet d'afficher des cartes gigantesques) :

Imaginons que ma résolution est de 1280*960, que mes tiles sont de 64*64.

Donc à chaque instant je dois afficher au minimum 20*15 tiles à l'écran.

Je crée donc un backbuffer (bitmap en mémoire) de la meme taille que ma résolution (1280*960).

A chaque nécessité d'afficher, je regarde à quelle position x, y de la carte je suis et je prends tous les tiles contenues entre (x-11 et x+11) et (y-8 et y+9). Je les affiches ensuite dans le backbuffer en prenant on compte un offset (pixelsX et pixelY) qui correspond à mon scroll, et ensuite j'affiche le backbuffer sur la surface d'affichage.

Les exemples de RPG que j'ai pu regarder font comme ca, et ca permet de gérer les sprites animés (arbres qui se balancent, herbe qui bouge).

Dans mon jeu, la hauteur (cooredonnée z) est aussi pris en compte dans les tiles affichés, ansi que les layers (différentes couches bitmap pour un meme sprite). et j'obtiens de très bonnes performances.

Est-ce que ca a répondu à tes interrogations ?

[Zenol]

Donc, tu prend tous les chipset(petits careaux de 64*64) de -(NbLargeur/2+1) à +(NbLargeur/2+1) et pareille en hauteur. Comme si tu prenais la bardure. Puis tu dit que tu utilise un x et y pour décaler.. Mais comment tu fait sa? Tu créer une surface de la taille de NbLargeur+2, puis tu découpe l'écran dedan, ou tu modifi les paramêtres de blit des petits careaux pour les décaler de x et y?
Si c'est la deuxième solution(et je croi avoir comprit que c'est sa) comment te débroille tu pour que sa ne pose pas de problème avec par exemple le careau en haut a gauche qui risque d'avoir Rect.x = -3, Rect.y = -8 sachan que SDL vas blit ce qui déborde de l'autre coté de la carte?

[JEG]

c'est bien la deuxième solution. je dessine mes carreaux en -3 et -8.
Et pourquoi ca ne les affiche pas de l'autre côté, c'est très simple : c'est parceque je n'utilise pas SDL ! (je programme en .Net et tout marche correctement, en GDI+ ou avec DirectX)

Si tu veux vraiment utiliser SDL, alors je pense qu'il va te falloir effectivement créer un backbuffer de taille (NbLargeur+2)*64, tout dessiner dedans et ensuite découper dedans la portion que tu vas blitter à l'écran.

En terme de performances, ca va revenir grosso-modo au même.