Discussion :

[zolkovic]

Bonjour,

Je suis nouveau sur ce forum, j'espère poster au bon endroit...

J'ai décidé de réaliser un Puzzle Bobble récemment, et ceci en C étant donné que j'ai quelques bases, je me suis alors servi de la librairie SDL.

Mais malheureusement, mes bases sont limitées et je bloque assez rapidement...

Je ne viens pas demander à ce qu'on me réalise un jeu à ma place mais simplement de l'aide point par point car j'ai vraiment beaucoup de mal.

A l'heure actuelle je sais diriger mon lanceur et lancer une boule dans la direction exacte de la flèche, mais seulement avec une boucle while, et donc la boule va trop vite et se déplace instantanément...

Et j'aimerai également générer une nouvelle boule quand on appuie sur espace, mais à part la lancer, je ne sais pas comment en créer une nouvelle ensuite.

Je joins le code source à ce post.

Toute aide, même minime sera grandement appréciée !

Pièce jointe 371130

[Bousk]

Salut,

tu devrais commencer par lire et comprendre cet article https://alexandre-laurent.developpez...boucle-de-jeu/

[ternel]

Je n'ai pas lu ton code (puisqu'il est dans une pièce jointe que je ne peux pas télécharger)

Normalement, tu as suivi la documentation de la SDL, et ta boucle principale est correctement constituée.
Partant de là, tu as une fonction pour limiter le nombre de séquences d'affichage par seconde. On parle de frame rate ou "FPS" (frames per second)

Dans l'idée, il suffirait d'attendre entre deux unités de temps.

Le principe est de ne pas lier le passage du temps physique du jeu à l'affichage.
Par exemple, la vitesse de ta balle ne doit pas être en pixels par image, mais en unité de distance par seconde.

Tu dois avoir dans ton code une conversion entre les unités, et simplement mesurer le temps entre deux frames.

En gros, sachant que je ne me souviens plus des fonctions SDL:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
time_t now = SDL_time();
while(le_jeu_continue(&physics)) {
    // lire les evenements sdl: une boucle sur les événéments, pour les prendre en compte
 
    time_t last = now;
    now = SDL_time();
    time_diff_t dt = now - last;
    update_physics(&physics, dt);
    draw(&physics);
}

[Kannagi]

Par exemple, la vitesse de ta balle ne doit pas être en pixels par image, mais en unité de distance par seconde.

J'ai peut être mal compris , mais a l'époque le temps n'était jamais utilisé dans les jeux (pour la simple raison qu’il était pas possible de le connaître tout simplement ).
De plus la multiplication était super longue donc c'était plutôt une mauvaise idée (et les nombre a virgule flottant n'existait pas pour ces machines).

Bref le gros défaut que je vois c'est que le posteur original me semble trop presser , enfaîte avant de se lancer a faire un jeu comme puzzle bobble , il faut faire (beaucoup) de fonction de rendu facilitant la création de ce type de jeu :
-Comme dit précédemment faire une fonction limitant les FPS
-faire une fonction gérant le background (tilemap)
-faire une fonction d'affichage de sprite (qui gère aussi l'animation)
-faire une fonction qui gère les evenement clavier (dans ton cas avoir un booleen qui indique si tel touche est pressé).

Quelque truc en vrac : oublier les double et privilégier les float , tu n'utilise pas les structures/tableau...
Faire un Puzzle Bobble en C/SDL me semble personnellement un peu complexe pour un débutant :p

[zolkovic]

Bonjour,

J'ai décidé de faire un Puzzle Bobble car j'en ai l'envie, je ne pense pas être trop ambitieux en choisissant de coder un jeu tel que celui-ci... J'ai déjà appris pas mal de choses et je trouve que c'est la meilleure méthode d'apprendre que de coder un jeu. Mais enfin bref ce n'est pas la question :p

Je vais alors faire un fichier à part contenant ces fonctions, en revanche je ne vois pas comment limiter les FPS, qu'entends-tu par cela ?

Bien à vous,

[Bousk]

je ne vois pas comment limiter les FPS, qu'entends-tu par cela ?

Rien qui ne soit pas dans l'article indiqué plus haut.

[zolkovic]

Bonjour,
Suite à quelques soucis j'ai dû laisser le projet de côté durant un mois,
Up si possible...

Voici ma situation qui n'a guère avancé:
J'arrive à lancer ma boule avec une trajectoire qui m'a l'air bonne, en revanche j'ai placé ma boucle dans le while !(gameover) et cette boucle (dans une boucle) provoque un déplacement de ma boule instantané, peut-être devrai-je effectuer le déplacement de ma boule ailleurs ? (Dans le case SDLK_SPACE ?)

Ensuite j'aimerai quand je rappuie sur ESPACE (touche pour lancer la boule), en créer une nouvelle sans déplacer la première.

Je verrai pour le placement des boules (en triangle) ensuite.

Cordialement.

[yildiz-online]

!(gameover)

Tu n'utilises pas de state machine pour séparer les différentes phases de ton jeu (écran titre, chargement, jeu, game over...) et gérer leurs transitions?

peut-être devrai-je effectuer le déplacement de ma boule ailleurs

Pour faire un déplacement, c'est une translation de ton vecteur de position par le vecteur de destination normalisé * la vitesse * le temps écoulé depuis la dernière frame
Tu gères le temps?

[nanosoft]

Bonjour zolkovic,

Pour gérer les différentes boules tu devrais définir un tableau de structure qui contient les différents attributs des boules:
Position, vitesse, active ou non etc...
Pour ne pas avoir un déplacement instantané de ta boule, il faut gérer le temps.
La manière la plus efficace est de faire tourner la boucle principale (celle de while !(gameover) { ... } ) avec une période fixe.
As-tu regardé les liens proposés plus haut ?
Voici un petit exemple d'organisation de la boucle principale avec une fonction Gesframe() qui permet de la faire tourner avec une période constante égale à t_frame.
A chaque tour de boucle tu as un incrément de temps constant, il te suffit de définir un nombre de pixels de déplacement pour choisir la vitesse.

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
while(continuer)
    {
        while (SDL_PollEvent(&event))
        {
        switch(event.type) // en fonction de chaque évènement du Poll
            {
            case SDL_QUIT: continuer = 0; break;
 
            // ...  les différents  case d'évènements
 
            }   // fin switch(event.type)
 
        }  // fin SDL_PollEvent(&event)
 
	//  Diverses actualisations ..
 
        //   --------- Blits et Affichage
 
	SDL_Flip(Screen);
 
	// gestion boucle période constante
 
       GesFrame();   //  Gestion du timing de la boucle
 
    }   // fin while(continuer)
 
 
// Fonctions :
 
void GesFrame()
{
    tempsActuel = SDL_GetTicks();       // Temps de fin d'éxécution (depuis début boucle)
    if (tempsActuel - tempsPrecedent < t_frame)
    {   // on rajoute un délai pour obtenir t_frame
        SDL_Delay(t_frame - (tempsActuel - tempsPrecedent));
    }
    tempsPrecedent = SDL_GetTicks();    // Temps de fin de la boucle (= début de la suivante !)
}

[yildiz-online]

Code :

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

1
2
3
4
5
6
7
8
9
void GesFrame()
{
    tempsActuel = SDL_GetTicks();       // Temps de fin d'éxécution (depuis début boucle)
    if (tempsActuel - tempsPrecedent < t_frame)
    {   // on rajoute un délai pour obtenir t_frame
        SDL_Delay(t_frame - (tempsActuel - tempsPrecedent));
    }
    tempsPrecedent = SDL_GetTicks();    // Temps de fin de la boucle (= début de la suivante !)
}

Ca c'est un frame limiter, c'est utile pour sauver le ventilo du CPU d'une mort atroce sur une machine trop véloce, mais pas pour gérer le temps en tant que tel.

Il faut garder à l'esprit que l'application peut avoir des chutes de framerate sous la limite prévue et donc chaque appel de fonction impacté doit connaître le temps passé depuis la dernière frame pour garder un comportement cohérent, peu importe la vitesse du jeu.

[nanosoft]

Ca c'est un frame limiter, c'est utile pour sauver le ventilo du CPU d'une mort atroce sur une machine trop véloce, mais pas pour gérer le temps en tant que tel.

Bah, cela fait très bien les deux : la boucle tourne à période constante.

Il faut garder à l'esprit que l'application peut avoir des chutes de framerate sous la limite prévue et donc chaque appel de fonction impacté doit connaître le temps passé depuis la dernière frame pour garder un comportement cohérent, peu importe la vitesse du jeu.

Tout à fait, avec cette fonction si il y a une chute de framerate supérieure à celle choisie : on ne rajoute pas de délais.

[yildiz-online]

Ben non, elle limite le framerate max, mais elle ne permet pas de rattraper si le framerate est trop bas.
Une boucle ne tournera jamais à vitesse constante sur n'importe quelle machine, c'est utopique.

[Kannagi]

Je confirme que son code fait bel et bien un fps constant , par contre débat largement mené est la précision du sleep , néanmoins si on veut un framerate 'au cycle prés' alors je pense qu'il faut activé la Vsync (mais il n'y a pas de code portable pour cela donc...).

Parce que vitesse*time , animation*time etc etc , c'est si on considère que le temps passé par clock est précis , ce qui n'est pas le cas

De plus je dis ça au cas ou les émulateur ne font nullement cela et pourtant ça reste lourd en calcul interpréter chaque instruction , et j'ai jamais joué sur un émulateur SNES , Neo Geo etc etc en me disant "ouaw les fps sont pas constants"

[nanosoft]

elle ne permet pas de rattraper si le framerate est trop bas

Je ne vois pas comment on pourrait, à moins de remonter le temps !

Une boucle ne tournera jamais à vitesse constante

Ben si ! même si n'est pas très précis comme le dit justement Kannagi.
(ce n'est pas utopique puisque l'on rajoute un délai pour ce faire)

[yildiz-online]

Donc quoi qu'il arrive, même avec 10x plus de poly que ce que ta CG peut supporter, tu restes à 60 FPS constant?

C'est révolutionnaire ton code.

[zolkovic]

Bonjour,

J'ai réussi à limiter la vitesse de la boule selon une vélocité donnée, j'ai également réussi à faire les rebonds sur les parois droites et gauches.

Maintenant prochaine étape, en appuyant sur ESPACE au lieu de la ramener à son lieu initial, j'aimerai laisser la première à son endroit actuel et en générer une nouvelle.

J'aimerai également qu'elles se placent selon un tableau bub_array[x][y] (car dans un bubble shooter les boules se placent à des emplacements précis)

Je vois joins mon code ci-dessous pour plus de compréhension.

Merci à tous pour vos réponses.

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
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
// COMPIL THIS FILE WITH : gcc -Wall -g -std=c99 sdlanim.c `sdl-config --cflags --libs` -lm -o sdlanim
 
#include "math.h"
#include "SDL.h"
 
#define PI 3.14159265359
#define SCREEN_WIDTH 720    // horizontal size of the frame
#define SCREEN_HEIGHT 540   // vertical size of the frame
#define BOARD_LEFT 200      // x-coord of the left border of the game board
#define BOARD_RIGHT 520     // x-coord of the right border of the game board
#define BOARD_TOP 31        // y-coord of the top border of the game board
#define BOARD_BOTTOM 422    // y-coord of the bottom border of the game board (will be useful in next levels)
#define LAUNCHER_WIDTH 187  // width of the launcher surface
#define LAUNCHER_HEIGHT 157 // height of the launcher surface
#define LAUNCHER_CENTER 94  // y-coord of the launcher center
#define LAUNCHER_DIV 48     // PI/LAUNCHER_DIV is the angular distance between each of the 45 launcher orientations
#define BUB_SIZE 40         // horizontal and vertical size of the bubble surface
#define VELOCITY 1          // bubbles velocity
#define BUB_NX 8            // max. number of bubbles in horizontal direction
#define BUB_NY 11           // max. number of bubbles in vertical direction
 
 
int gameover, launched, reset, launcherDirection, bub_array[BUB_NY][BUB_NX];
float angle, dX, dY, BPosX, BPosY;
SDL_Rect launcherRect, bubblePosition;
 
void centralizeBubble()
{
  bubblePosition.x = SCREEN_WIDTH / 2 - BUB_SIZE / 2;
  bubblePosition.y = SCREEN_HEIGHT - LAUNCHER_HEIGHT + LAUNCHER_CENTER - BUB_SIZE / 2;
  BPosX = bubblePosition.x;
  BPosY = bubblePosition.y;
  reset = 1;
}
 
void HandleEvent(SDL_Event event)
{
  switch (event.type)
  {
  case SDL_QUIT:
    gameover = 1;
    break;
 
  case SDL_KEYDOWN:
    switch (event.key.keysym.sym)
    {
    case SDLK_ESCAPE:
    case SDLK_q:
      gameover = 1;
      break;
    case SDLK_SPACE:
      if (!launched)
      {
        if (reset)
        {
          launched = 1;
          reset = 0;
          angle = PI - launcherDirection * PI / LAUNCHER_DIV;
          dX = VELOCITY * cos(angle);
          dY = -VELOCITY * sin(angle);
        }
        else
          centralizeBubble();
      }
      break;
    case SDLK_LEFT:
      if (launcherRect.y >= LAUNCHER_HEIGHT)
      {
        launcherRect.y -= LAUNCHER_HEIGHT;
        launcherDirection-=1;
      }
      break;
    case SDLK_RIGHT:
      if (launcherRect.y <= 43 * LAUNCHER_HEIGHT)
      {
        launcherRect.y += LAUNCHER_HEIGHT;
        launcherDirection+=1;
      }
      break;
    }
    break;
  }
}
 
int main(int argc, char *argv[])
{
  SDL_Surface *screen, *temp, *lcher, *bckg, *bub;
  SDL_Rect backgroundPosition, lcherPos, bubSrc;
  int colorkey;
 
  SDL_Init(SDL_INIT_VIDEO);
 
  SDL_WM_SetCaption("SDL Animation", "SDL Animation");
 
  screen = SDL_SetVideoMode(SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0);
 
  SDL_EnableKeyRepeat(70, 70);
 
  temp = SDL_LoadBMP("frame_launcher.bmp");
  lcher = SDL_DisplayFormat(temp);
  SDL_FreeSurface(temp);
 
  colorkey = SDL_MapRGB(screen->format, 255, 0, 255);
  SDL_SetColorKey(lcher, SDL_SRCCOLORKEY | SDL_RLEACCEL, colorkey);
 
  temp = SDL_LoadBMP("frame_1p.bmp");
  bckg = SDL_DisplayFormat(temp);
  SDL_FreeSurface(temp);
 
  SDL_SetColorKey(bckg, SDL_SRCCOLORKEY | SDL_RLEACCEL, colorkey);
 
  temp = SDL_LoadBMP("bub_blue.bmp");
  bub = SDL_DisplayFormat(temp);
  SDL_FreeSurface(temp);
 
  SDL_SetColorKey(bub, SDL_SRCCOLORKEY | SDL_RLEACCEL, colorkey);
 
  lcherPos.x = SCREEN_WIDTH / 2 - LAUNCHER_WIDTH / 2;
  lcherPos.y = SCREEN_HEIGHT - LAUNCHER_HEIGHT;
 
  centralizeBubble();
 
  launcherRect.x = 0;
  launcherRect.y = 0;
  launcherRect.w = LAUNCHER_WIDTH;
  launcherRect.h = LAUNCHER_HEIGHT;
 
  bubSrc.x = 0;
  bubSrc.y = 0;
  bubSrc.w = BUB_SIZE;
  bubSrc.h = BUB_SIZE;
 
  gameover = 0;
  launched = 0;
  launcherDirection = 2;
  angle = PI - launcherDirection * PI / LAUNCHER_DIV;
  dX = VELOCITY * cos(angle);
  dY = -VELOCITY * sin(angle);
 
  while (!gameover)
  {
    SDL_Event event;
 
    if (SDL_PollEvent(&event))
    {
      HandleEvent(event);
    }
 
    SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
    backgroundPosition.x = 0;
    backgroundPosition.y = 0;
    SDL_BlitSurface(bckg, NULL, screen, &backgroundPosition);
 
    if (launched)
    {
      if (BPosY <= BOARD_TOP + 1)
      {
	launched = 0;
      }
      if (BPosX <= BOARD_LEFT + 1)
      {
        BPosX = BPosX + 1;
	dX = -dX;
      }
      if (BPosX + BUB_SIZE >= BOARD_RIGHT - 1)
      {
	BPosX = BPosX - 1;
	dX = -dX;
      }
      BPosX += dX;
      BPosY += dY;
      bubblePosition.x = (int)BPosX;
      bubblePosition.y = (int)BPosY;
    }
    SDL_BlitSurface(lcher, &launcherRect, screen, &lcherPos);
    SDL_BlitSurface(bub, &bubSrc, screen, &bubblePosition);
    SDL_UpdateRect(screen, 0, 0, 0, 0);
  }
 
  /* clean up */
  SDL_FreeSurface(lcher);
  SDL_FreeSurface(bckg);
  SDL_Quit();
 
  return 0;
}

[nanosoft]

Bonjour,

Pour créer de nouvelles balles, fais une structure puis un tableau avec le nombre maxi de balles.
Exemple ci-dessous pour cent (t'as pas cent balles ?)

Autre chose : il faudrait mieux un "while" plutôt qu'un "if" ligne 144 pour dépiler tous les évènements en attente.
Sinon c'est un seul à chaque tour de la boucle principale.

Bonne continuation, c'est bien parti !

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
typedef struct
{
    int statut;		// Balle affichée ou non
    double Pbx;		// Positions
    double Pby;
    double Vbx;		// Vitesses
    double Vby;
    double angTir;	// angle de tir au départ
}Ball;
 
Ball Balle[101];
 
// exemple de fonction :
 
void resetBalles()
{
    int i;
    for(i=1;i<101;i++)
    {
        Balle[i].statut=OFF;
    }
}

[zolkovic]

Bonne continuation, c'est bien parti !

Bonjour nanosoft,
Tout d'abord merci ! J'espère alors l'avoir fini d'ici 10 jours

J'ai en effet créé un tableau bub_array[BUB_NX][BUB_NY] dont toutes ses cases sont initialisées à 0, je vais fonctionner de la manière suivante: la case vaudra 0 si pas de boule, sinon le chiffre de la couleur (pour l'instant je ne travaille qu'avec une couleur de boule qui est le bleu), ici ce sera 1 pour les boules bleues.

L'idée de créer une structure me semble bonne mais je ne sais pas si elle est nécessaire puisque qu'avec le tableau on aura alors les coordonnées x et y grâce au x et y du tableau ainsi que la couleur de la boule.

Mais ayant une largeur du plateau de 320, sur la première ligne 8 boules peuvent passer, comment puis-je trouver simplement la position la plus proche lorsqu'elle atterrit en haut ?

Je verrai les collisions une fois que je saurai en lancer plusieurs...

Merci

[nanosoft]

L'idée de créer une structure me semble bonne mais je ne sais pas si elle est nécessaire

Cela te simplifierait la vie pour les fonctions où il faut traiter toutes les balles comme l'affichage : tu peux faire une boucle et juste incrémenter l'indice.

comment puis-je trouver simplement la position la plus proche lorsqu'elle atterrit en haut ?

Par exemple en faisant une division entière de la positionx par 40 : cela donne un entier entre 0 et 7, ensuite faire un switch{} pour afficher à la position voulue suivant les cas.

[zolkovic]

Pas bête pour la division entière ! J'aurai dû y penser...
En revanche pour la structure je vais me pencher dessus, mais ensuite comment pourrai-je faire pour ne plus toucher aux .x et .y de la première boule mais d'une nouvelle ?

Cordialement