besoin d'aide pour simuler un saut

**noals** · 11/10/2012, 11h29

salut,

j'essaye de simuler un saut pour mon gameplay sans vraiment utiliser de physique.
par exemple, il n'y a pas de collision entre mon joueur et mon terrain mais la hauteur du joueur est défini en fonction de sa position et de la hauteur du terrain a cette position.

Code :

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

playerPos.Y=terrain->getHeight(playerPos.X,playerPos.Z);

et à partir de ça, j'essaye de trouver un algorythme pour que quand j'appuie sur la touche pour sauter, une boucle est déclancher qui simulerai le saut..

code de ma boucle de rendu pour le gameplay

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
 
		screenCenter.X=400;
		screenCenter.Y=300;
 
		camTargetRot.X=camTarget->getRotation().X+rotationSpeed*(screenCenter.Y-cursor.Y);		//rot vertical
		if(camTargetRot.X>89)camTargetRot.X=89;
		if(camTargetRot.X<1)camTargetRot.X=1;
		camTargetRot.Y=camTarget->getRotation().Y+rotationSpeed*(screenCenter.X-cursor.X)*-1;	//rot horizontal
		camTargetRot.Z=camTarget->getRotation().Z;
 
		playerRot.X=0;
		playerRot.Y=camTargetRot.Y;
		playerRot.Z=0;
 
		//cameraPos.X=camera->getPosition().X;
		//cameraPos.Y=camera->getPosition().Y;
		cameraPos.Z=camera->getPosition().Z+cameraDistance;
 
		playerPos.X=playerNode->getPosition().X;
		playerPos.Z=playerNode->getPosition().Z;
		playerPos.Y=terrain->getHeight(playerPos.X,playerPos.Z);
 
		if(keys[KEY_KEY_Z]) //moving foward
		{
			f32 roty_rad=playerRot.Y*PI/180; //convert to radian
			playerPos.Z += playerSpeed*cos(roty_rad);
			playerPos.X += playerSpeed*sin(roty_rad);
		}
		if(keys[KEY_KEY_S]) //moving back
		{
			f32 roty_rad=playerRot.Y*PI/180;
			playerPos.Z -= playerSpeed*cos(roty_rad);
			playerPos.X -= playerSpeed*sin(roty_rad);
		}
		if(keys[KEY_KEY_Q]) //straing left
		{
			f32 roty_rad=playerRot.Y;
			roty_rad -= 90;
			roty_rad *= PI/180;
			playerPos.Z += playerSpeed*cos(roty_rad);
			playerPos.X += playerSpeed*sin(roty_rad);
		}
		if(keys[KEY_KEY_D]) //straing right
		{
			f32 roty_rad=playerRot.Y;
			roty_rad += 90;
			roty_rad *= PI/180;
			playerPos.Z += playerSpeed*cos(roty_rad);
			playerPos.X += playerSpeed*sin(roty_rad);
		}
 
/////////////////////////////////////////////////////////////////////////////////
//////////////////////   LE SAUT
////////////////////////////////////////////////////////////////////////////////
 
		if(keys[KEY_KEY_E])
		{
			for(u32 jumptime=0;jumptime<200;)
			{
				u32 jump_value=playerPos.Y-terrain->getHeight(playerPos.X,playerPos.Z)/jumptime;
				playerPos.Y=playerPos.Y+jump_value;
				jumptime++;
				//playerPos.Y=playerPos.Y+35.0f;		//backup
			}
		}
 
		if(keys[KEY_KEY_A])playerPos.Y=playerPos.Y-18.0f;
 
		camera->setTarget(camTarget->getPosition());
		camera->setPosition(cameraPos);
		playerNode->setPosition(playerPos);
		playerNode->setRotation(playerRot);
		camTarget->setPosition(playerPos);
		camTarget->setRotation(camTargetRot);
 
		myCursor->setPosition(400,300);

j'ai essayé vite fait qq trucs pour voir comment je pourrai faire mais c'est un peu n'importe quoi.

disons qu'il faut que je puisse definir d'une certaine manière combien de temps ma pseudo animation durera.
il faut que je sépare ça en deux pour simuler l'ascension et la chute.
il faut qu'à partir du moment ou le saut soit déclancher, le joueur ne puisse plus bouger car il ne vol pas, il est en train de sauter. (il peut toujours pivoter)
il faut que la velocité du saut soit en rapport avec la vitesse (simplifiée) et la direction du joueur.
il faut qu'en fonction de la hauteur du lieu d'attérissage, la boucle du temps de saut s'arrête.

ce qui fait beaucoup de "il faut" et j'sais pas trop comment faire la.
mon projet pour l'instant :
http://www.fileden.com/files/2006/6/...5/Demo_III.zip

**Bousk** · 11/10/2012, 11h57

Bonjour,

problème complexe, mais pas compliqué en soit. Mais tout dépend de toi, ce que tu as et veux.

J'avais réalisé il y a quelque temps un mini jeu mario (les tous premiers avec DK qui balance les tonneaux).
L'idée initiale pour sauter était:
- j'enregistre la direction
- j'enregistre que je suis en saut
- je limite l'amplitude et hauteur du saut

Pour le 3° point, j'avais décidé qu'un saut serait une simple diagonale vers le haut de X pixels, puis vers le bas pour la chute.
La seule chose finalement qui avait posé "problème" c'est "quand le saut se termine ?" "comment déterminer que le saut est fini et qu'on a touché le sol ?" puisque le niveau n'est pas plat, on peut retomber "plus haut" que notre hauteur initiale
Après étude de la composition de mon écran, ma solution a été la plus simple, celle qui m'a sauté aux yeux : d'après la couleur du pixel sous mes pieds.

Le 1° point évite justement de pouvoir changer la direction du saut en vol.

- c'était dans le cadre d'un cours de C pour des étudiants de 1° année
- ils avaient 5j pour le réaliser (non bloqués, dont le week-end et mercredi libres)
- j'ai présenté ma proposition à leur projet pour laquelle je m'étais fixé 1 après-midi pour la réaliser

**noals** · 11/10/2012, 14h11

- j'enregistre la direction

ok, je pense qu'il faut que j'utilise des bool pour mes touches vu que déjà mes touches me font aller dans tel ou tel directions, forcément, si j'appuie sur un touche pour aller dans une direction, mon joueur va pas sauter à l'opposé.
il faut donc aussi que je définisse la longuer de mon saut.
donc
1/ ma direction
2/ longueur de saut

- j'enregistre que je suis en saut

booléen power.

- je limite l'amplitude et hauteur du saut

j'l'avais en tête, j'ai pas penser à l'écrire sur le coup.
3/hauteur de saut

Pour le 3° point, j'avais décidé qu'un saut serait une simple diagonale vers le haut de X pixels, puis vers le bas pour la chute.

pour moi le saut est vertical et l'algo doit calculer la courbe dans le temps selon la vitesse ou donc la direction.

La seule chose finalement qui avait posé "problème" c'est "quand le saut se termine ?" "comment déterminer que le saut est fini et qu'on a touché le sol ?" puisque le niveau n'est pas plat, on peut retomber "plus haut" que notre hauteur initiale
Après étude de la composition de mon écran, ma solution a été la plus simple, celle qui m'a sauté aux yeux : d'après la couleur du pixel sous mes pieds.

ben pour ça j'ai mon terrain->getHeight(), forcément le joueur ne va pas tomber plus bas que le sol mais il faut que je stop ma boucle de "temps" quand le joueur rentre en contacte avec le sol pour pouvoir resauter ensuite.

bref
-ma direction en fonction des touches = jump_direction
-la longueur du saut = jump_lenght
-la hauteur du saut = jump_height
-bool état de saut = is_jumping

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
 
if(is_jumping = 1)
{
     playerPos=playerNode->getPosiion();
     jump_max_height=terrain->getHeight(playerPos.X,playerPos.Z)+jump_height;
     playerPos.X=playerPos.X+jump_lenght*jump_direction.X;
     playerPos.Z=playerPos.Z+jump_lenght*jump_direction.Z;
     if(playerPos.Y<jump_max_height)
     {
          playerPos.Y=playerPos.Y+ ? jump_force ?;
     }
     else
     {
          if(playerPos.Y>terrain->getHeight(? new player pos ?))
          {
               playerPos.Y=playerPos.Y- ? jump_force ?;
          }
          else
          {
               is_jumping = 0;
          }
     }
}

un truc dans le genre je pense mais j'ai un problème avec les changements dans le temps, j'sais pas trop comment les appliquer.

normalement c'est un truc du genre

Code :

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

1
2
3
4
5
6
7
 
time =0
dif_time = 1
while(time<jump_time)
{
     time=time+dif_time;
}

il faudrait que je trouve combien de temps je mets pour que mon saut s'effectue ce qui est définissable mais j'sais pas trop comment définir mon unité pour l'instant d'ou mon essaie vite fait avec

Code :

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

1
2
3
4
5
6
7
8
 
			for(u32 jumptime=0;jumptime<200;)
			{
				u32 jump_value=playerPos.Y-terrain->getHeight(playerPos.X,playerPos.Z)/jumptime;
				playerPos.Y=playerPos.Y+jump_value;
				jumptime++;
				//playerPos.Y=playerPos.Y+35.0f;		//backup
			}

'fin bon j'ai de quoi faire déjà.
merci pour la réponse.

**Bousk** · 11/10/2012, 14h22

Tu peux rencontrer un autre "problème", dans le cas où une frame déplace de plusieurs unités, afin d'éviter de tomber à travers le sol.
Il faut détecter que le mouvement précédent ne te met pas en contact avec le sol entre temps.

**Kaamui** · 11/10/2012, 14h29

Salut,

Premièrement, qu'une boucle se lance pour simuler le saut me semble ne pas être la meilleure solution car :
- soit c'est bloquant, et dans ce cas fais comment pour updater ton affichage durant le saut ?
- soit tu as dupliqué toute une partie de ton code pour que l'affichage s'effectue également dans ce cas là.

j'ai réalisé il y a quelque temps un tutoriel sur le sujet (mais avec l'API SFML).

en effet, le problème est assez simple, et se résume a quelques opérations dans un simple if de ta gestion des évènements clavier :

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
 
void Personnage::Deplacement(const sf::Input& clavier)
{
    if(saut_en_cours) 
    {
            //On vérifie qu'on ne va pas traverser le sol au prochain instant t
            if(sprite.GetPosition().y + ((0.5*G*instant_t*instant_t)-sin(ANGLE)*instant_t*Vy)<= POSITION_DU_SOL) 
            {
                //si il n'y a pas de risque...
                sprite.Move(sens*cos(ANGLE)*instant_t*Vx,(0.5*G*instant_t*instant_t)-sin(ANGLE)*instant_t*Vy);
                //N'oublions pas que nous travaillons avec SFML, l'axe y augmente en valeur au fur 
                //et à mesure qu'on descend dans la fenêtre, c'est pourquoi on met 
                //-sin(...) au lieu de +sin(..)
 
                instant_t += INCREMENT_TEMPOREL;
            }
            else //...dans le cas contraire, on finit le saut
            {
                sprite.SetPosition(sprite.GetPosition().x + (sens*(cos(ANGLE)*instant_t*Vx)), POSITION_DU_SOL);
                instant_t = 0;
                saut_en_cours = false;
            }
    }
    else
    {
        if(clavier.IsKeyDown(sf::Key::Space))
        {
            saut_en_cours = true;
        }
        if(clavier.IsKeyDown(sf::Key::Up))
        {
            sprite.Move(0,-1);
            sens = 0;
        }
        if (clavier.IsKeyDown(sf::Key::Down))
        {
            //On vérifie qu'on ne traverse pas le sol
            if (sprite.GetPosition().y + 1 < POSITION_DU_SOL)
                sprite.Move(0,1);
            sens = 0;
        }
        if(clavier.IsKeyDown(sf::Key::Left))
        {
            sprite.Move(-1,0);
            sens = -1;
        }
 
        if(touche.IsKeyDown(sf::Key::Right))
        {
            sprite.Move(1,0);
            sens = 1;
        }
 
    }
 
}

Alors certes c'est en SFML, mais cela ne change pas grand chose.
la fonction move est équivalent à monObjet.posX += x et pareil en y, les constantes POSITION_DU_SOL, G, etc je penses que tu devines ce qu'elle font, etc..

A noter que des améliorations peuvent être apportées, ainsi que des modifications assez simples, selon tes besoins (bloquer/libérer les directions pendant un saut, etc)... il est également possible de modifier la formule pour baser les calculs sur la position précédente, pour gagner en performance (permet de gagner quelques opérations arithmétiques) mais à moins que tu sois dans un domaine ou chaque tour de clock de ton processeur est précieux, tu peux laisser les formules tel quel.

Si tu as des question n'hésite pas.

1/disons qu'il faut que je puisse definir d'une certaine manière combien de temps ma pseudo animation durera.
2/il faut que je sépare ça en deux pour simuler l'ascension et la chute.
3/il faut qu'à partir du moment ou le saut soit déclancher, le joueur ne puisse plus bouger car il ne vol pas, il est en train de sauter. (il peut toujours pivoter)
4/il faut que la velocité du saut soit en rapport avec la vitesse (simplifiée) et la direction du joueur.
5/il faut qu'en fonction de la hauteur du lieu d'atterrissage, la boucle du temps de saut s'arrête.

1/Le temps que prend le saut ? inutile. les seuls paramètres nécessaires à la réalisation d'un saut sont la vitesse de ton objet au moment ou il entre en chute libre (au moment où son dernier doigt de pied quitte le sol

) et l'angle de sont saut (pour un saut optimal en longueur, 45°, mais là c'est HS

).

2/pas besoin de séparer les deux, avec ces deux paramètre, et une petite formule très simple à comprendre, le saut sera réellement simulé du début à la fin (Cf. code du dessus)

3/bloquer les directions ? un booléen mis à true au moment ou on appuie sur la touche de saut, c'est tout (Cf. code)

4/ça tombe bien ça fait partit des deux paramètres qui doivent être renseignés

5/ tout ce qu'il faut pour le temps, c'est une variable à 0 au moment du saut, et que tu incrémentes à chaque tour de frame (ou à chaque tour dans ta boucle de jeu), et que tu remets à 0 une fois le saut finit

**noals** · 11/10/2012, 18h16

pour l'instant, j'ai fait ça

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
		if(keys[KEY_KEY_Z]) //moving forward
		{
			jump_variable += 13;
			f32 roty_rad=playerRot.Y*PI/180; //convert to radian
			playerPos.Z += playerSpeed*cos(roty_rad);
			playerPos.X += playerSpeed*sin(roty_rad);
			j_direction_f.Z=cos(roty_rad);
			j_direction_f.X=sin(roty_rad);
		}
		else jump_variable -= 13;
 
		if(keys[KEY_KEY_S]) //moving back
		{
			jump_variable += 39;
			f32 roty_rad=playerRot.Y*PI/180;
			playerPos.Z -= playerSpeed*cos(roty_rad);
			playerPos.X -= playerSpeed*sin(roty_rad);
			j_direction_b.Z=cos(roty_rad)*-1;
			j_direction_b.X=sin(roty_rad)*-1;
		}
		else jump_variable -= 39;
 
		if(keys[KEY_KEY_Q]) //straing left
		{
			jump_variable = 24;
			f32 roty_rad=playerRot.Y;
			roty_rad -= 90;
			roty_rad *= PI/180;
			playerPos.Z += playerSpeed*cos(roty_rad);
			playerPos.X += playerSpeed*sin(roty_rad);
			j_direction_l.Z=cos(roty_rad);
			j_direction_l.X=sin(roty_rad);
		}
		else jump_variable -= 24;
 
		if(keys[KEY_KEY_D]) //straing right
		{
			jump_variable += 57;
			f32 roty_rad=playerRot.Y;
			roty_rad += 90;
			roty_rad *= PI/180;
			playerPos.Z += playerSpeed*cos(roty_rad);
			playerPos.X += playerSpeed*sin(roty_rad);
			j_direction_r.Z=cos(roty_rad);
			j_direction_r.X=sin(roty_rad);
		}
		else jump_variable -= 57;
 
		switch(jump_variable)
		{
			case 13:							//forward
				jump_direction.X=j_direction_f.X*jump_lenght;
				jump_direction.Z=j_direction_f.Z*jump_lenght;
				break;
			case 39:							//back
				jump_direction.X=j_direction_b.X*jump_lenght;
				jump_direction.Z=j_direction_b.Z*jump_lenght;
				break;
			case 24:							//left
				jump_direction.X=j_direction_l.X*jump_lenght;
				jump_direction.Z=j_direction_l.Z*jump_lenght;
				break;
			case 57:							//right
				jump_direction.X=j_direction_r.X*jump_lenght;
				jump_direction.Z=j_direction_r.Z*jump_lenght;
				break;
			case 37:							//forward + left
				jump_direction.X=j_direction_f.X+j_direction_l.X*jump_lenght;
				jump_direction.Z=j_direction_f.Z+j_direction_l.X*jump_lenght;
				break;
			case 70:							//forward + right
				jump_direction.X=j_direction_f.X+j_direction_r.X*jump_lenght;
				jump_direction.Z=j_direction_f.Z+j_direction_r.X*jump_lenght;
				break;
			case 63:							//back + left
				jump_direction.X=j_direction_b.X+j_direction_l.X*jump_lenght;
				jump_direction.Z=j_direction_b.Z+j_direction_l.X*jump_lenght;
				break;
			case 96:							//back + right
				jump_direction.X=j_direction_b.X+j_direction_r.X*jump_lenght;
				jump_direction.Z=j_direction_b.Z+j_direction_r.X*jump_lenght;
				break;
			default:
				jump_direction.X=0;
				jump_direction.Z=0;
				break;
		}
 
		if(keys[KEY_KEY_E])
		{
			is_jumping = true;
 
		}
		else is_jumping = false;
 
		//if(keys[KEY_KEY_A])playerPos.Y=playerPos.Y-18.0f;
 
		if(is_jumping)
		{
			f32 g_height = terrain->getHeight(		//ground height at playerPos
											playerNode->getPosition().X,
											playerNode->getPosition().Z);
			if(playerNode->getPosition().Y>g_height)
			{
 
			}
		}

je récupère la valeur à ajouter à la position de mon joueur selon la direction de celui ci et je la met dans un vecteur en la multipliant par une longueur de saut défini au préalable.

j'continuerai plus tard.

**Kaamui** · 12/10/2012, 09h34

Envoyé par noals

pour l'instant, j'ai fait ça

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
		if(keys[KEY_KEY_Z]) //moving forward
		{
			jump_variable += 13;
			f32 roty_rad=playerRot.Y*PI/180; //convert to radian
			playerPos.Z += playerSpeed*cos(roty_rad);
			playerPos.X += playerSpeed*sin(roty_rad);
			j_direction_f.Z=cos(roty_rad);
			j_direction_f.X=sin(roty_rad);
		}
		else jump_variable -= 13;
 
		if(keys[KEY_KEY_S]) //moving back
		{
			jump_variable += 39;
			f32 roty_rad=playerRot.Y*PI/180;
			playerPos.Z -= playerSpeed*cos(roty_rad);
			playerPos.X -= playerSpeed*sin(roty_rad);
			j_direction_b.Z=cos(roty_rad)*-1;
			j_direction_b.X=sin(roty_rad)*-1;
		}
		else jump_variable -= 39;
 
		if(keys[KEY_KEY_Q]) //straing left
		{
			jump_variable = 24;
			f32 roty_rad=playerRot.Y;
			roty_rad -= 90;
			roty_rad *= PI/180;
			playerPos.Z += playerSpeed*cos(roty_rad);
			playerPos.X += playerSpeed*sin(roty_rad);
			j_direction_l.Z=cos(roty_rad);
			j_direction_l.X=sin(roty_rad);
		}
		else jump_variable -= 24;
 
		if(keys[KEY_KEY_D]) //straing right
		{
			jump_variable += 57;
			f32 roty_rad=playerRot.Y;
			roty_rad += 90;
			roty_rad *= PI/180;
			playerPos.Z += playerSpeed*cos(roty_rad);
			playerPos.X += playerSpeed*sin(roty_rad);
			j_direction_r.Z=cos(roty_rad);
			j_direction_r.X=sin(roty_rad);
		}
		else jump_variable -= 57;
 
		switch(jump_variable)
		{
			case 13:							//forward
				jump_direction.X=j_direction_f.X*jump_lenght;
				jump_direction.Z=j_direction_f.Z*jump_lenght;
				break;
			case 39:							//back
				jump_direction.X=j_direction_b.X*jump_lenght;
				jump_direction.Z=j_direction_b.Z*jump_lenght;
				break;
			case 24:							//left
				jump_direction.X=j_direction_l.X*jump_lenght;
				jump_direction.Z=j_direction_l.Z*jump_lenght;
				break;
			case 57:							//right
				jump_direction.X=j_direction_r.X*jump_lenght;
				jump_direction.Z=j_direction_r.Z*jump_lenght;
				break;
			case 37:							//forward + left
				jump_direction.X=j_direction_f.X+j_direction_l.X*jump_lenght;
				jump_direction.Z=j_direction_f.Z+j_direction_l.X*jump_lenght;
				break;
			case 70:							//forward + right
				jump_direction.X=j_direction_f.X+j_direction_r.X*jump_lenght;
				jump_direction.Z=j_direction_f.Z+j_direction_r.X*jump_lenght;
				break;
			case 63:							//back + left
				jump_direction.X=j_direction_b.X+j_direction_l.X*jump_lenght;
				jump_direction.Z=j_direction_b.Z+j_direction_l.X*jump_lenght;
				break;
			case 96:							//back + right
				jump_direction.X=j_direction_b.X+j_direction_r.X*jump_lenght;
				jump_direction.Z=j_direction_b.Z+j_direction_r.X*jump_lenght;
				break;
			default:
				jump_direction.X=0;
				jump_direction.Z=0;
				break;
		}
 
		if(keys[KEY_KEY_E])
		{
			is_jumping = true;
 
		}
		else is_jumping = false;
 
		//if(keys[KEY_KEY_A])playerPos.Y=playerPos.Y-18.0f;
 
		if(is_jumping)
		{
			f32 g_height = terrain->getHeight(		//ground height at playerPos
											playerNode->getPosition().X,
											playerNode->getPosition().Z);
			if(playerNode->getPosition().Y>g_height)
			{
 
			}
		}

je récupère la valeur à ajouter à la position de mon joueur selon la direction de celui ci et je la met dans un vecteur en la multipliant par une longueur de saut défini au préalable.

j'continuerai plus tard.

Je suis désolé mais je trouve ça extremement complexe (et long), et puis le switche case ... c'est moyen quand même

besoin d'aide pour simuler un saut

C++

Vue hybride

Discussions similaires

Partager

Partager