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

**noals** · 12/10/2012, 12h06

j'trouve l'idée bonne pour mon switch, j'savais pas comment différencier mes 8 directions dans le cas ou 2 directions sont utiliser en même temps alors j'ai pris des valeurs aléatoires pour chaques directions haut, bas, gauche, droite, qui font que quand 2 valeurs s'ajoutes, le résultat est unique et donc j'ai mes 8 direction différentes à la fin.
(jump_lenght est complètement inutile d'ailleur)

bref sinon pour l'instant ma priorité est d'avoir mon personnage qui s'élève progressivement et retombe comme pour simuler la physique mais sans force ni masse.

j'arrive pas à bien définir ma fonction de temps disons que j'ai du mal à fixer mes variables dans le temps je pense.
par exemple j'ai besoin de la hauteur du joueur comme hauteur de départ du saut mais j'sais pas trop où stocker ma valeur dans ma boucle.

j'sais pas trop quoi utiliser non plus, if ? for ? while ? faut que je revois ça sur le net ou dans mon bouquin.
'fin bref, j'ai du mal à visualiser la fonction, j'vais l'écrire sur papier pour essayer d'y voir plus clair.

edit :
j'ai cerner un de mes problèmes.
la hauteur de mon joueur est défini dans ma boucle de rendu par :

Code :

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

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

donc il faut que je mette ça dans le cas ou mon personage n'est pas en train de sauter vu que par default ma playerPos.Y est toujours la hauteur du terrain donc créer un résultat différent en ayant préalablement défini que le résultat ne change pas, c'est compliqué lol.

**Kaamui** · 12/10/2012, 14h50

Envoyé par noals

1/j'trouve l'idée bonne pour mon switch, j'savais pas comment différencier mes 8 directions dans le cas ou 2 directions sont utiliser en même temps alors j'ai pris des valeurs aléatoires pour chaques directions haut, bas, gauche, droite, qui font que quand 2 valeurs s'ajoutes, le résultat est unique et donc j'ai mes 8 direction différentes à la fin.
(jump_lenght est complètement inutile d'ailleur)

2/bref sinon pour l'instant ma priorité est d'avoir mon personnage qui s'élève progressivement et retombe comme pour simuler la physique mais sans force ni masse.

3/j'arrive pas à bien définir ma fonction de temps disons que j'ai du mal à fixer mes variables dans le temps je pense.
par exemple j'ai besoin de la hauteur du joueur comme hauteur de départ du saut mais j'sais pas trop où stocker ma valeur dans ma boucle.

4/j'sais pas trop quoi utiliser non plus, if ? for ? while ? faut que je revois ça sur le net ou dans mon bouquin.
'fin bref, j'ai du mal à visualiser la fonction, j'vais l'écrire sur papier pour essayer d'y voir plus clair.

1/pourquoi aurais-tu besoin de 8 directions ? tout ce qu'il te faut c'est un sens "vers la gauche", "vers la droite", "sur place", et un angle tu peux très bien faire que cet angle vaut 45° avec haut et gauche/droit enfoncé, 60° si que haut et la vitesse en X de ton perso n'est pas nulle, etc...

En plus tu ne peux pas sauté vers le bas, donc même avec ta technique 5 directions devraient suffire.

2/si on néglige les frottements de l'air dans une chute libre, la masse n'intervient pas dans l'équation. Pour ce qui est d'une force, tu en applique une dans tes formules car ce que tu appelle force physique ici ce n'est qu'une équation qui appliqué à un point crée des variations de position par rapport à ce même point.

3/tu ne devrais pas avoir une "fonction du temps". Dans le monde réel tu as les secondes pour interpréter une trajectoire (une durée complètement arbitraire qui fait office de "pulsation"). Dans le monde de la programmation, tu as le tour de boucle. En fonction de ton programme, un tour de boucle va s'exécuter en quelques millisecondes (on va dire 10ms avec l'affichage), et à chaque tour tu déplace ton joueur en X de quelques pixels (on va dire 5px).

Si tu pars sur ces valeurs, sur un écran 800*600 le déplacement de ton saut va être illisible (5px/10ms ~ 500px/s). Donc tu te doutes bien qu'il va falloir le ralentir, vu la vitesse de tes tours de boucle. Alors soit tu te prends la tête à essayer de mesurer le temps passé, soit tu ralenti l'avancement de ton personnage en divisant le déplacement final par 10 (pour l'exemple).

Dans mon exemple plus haut, je le fais dans INCREMENT_TEMPOREL.

Pour ce qui est de la hauteur de ton joueur : comment cela se fait que tu ne connaisse pas la position de ton joueur ?!?!! tu n'as pas un couple (x,z) dans les attributs de ta classe ?! C'est une erreur.

4/ sans conteste un 'if', car comme déjà expliqué, si tu utilise un while ou un for dans ta gestion du saut, tu va faire que le traitement de ton saut va s'effectuer tant que le saut ne sera pas terminé (ce qui parait logique), sauf qu'au lieu d'avoir un saut tu n'aura rien du tout (à part une téléportation) car si tu n'affiche pas au fur et à mesure la position de ton joueur, comment s'apercevoir qu'il saute ?

la seule boucle que tu dois avoir c'est ta boucle de jeu, un truc du style while (/*la partie n'est pas terminée || la fenetre n'a pas été fermé*/)

**noals** · 12/10/2012, 15h01

t'a répondu pendant que j'éditais mon post

edit :
j'ai cerner un de mes problèmes.
la hauteur de mon joueur est défini dans ma boucle de rendu par :

Code :

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

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

donc il faut que je mette ça dans le cas ou mon personage n'est pas en train de sauter vu que par default ma playerPos.Y est toujours la hauteur du terrain donc créer un résultat différent en ayant préalablement défini que le résultat ne change pas, c'est compliqué lol.

1/pourquoi aurais-tu besoin de 8 directions ? tout ce qu'il te faut c'est un sens "vers la gauche", "vers la droite", "sur place", et un angle tu peux très bien faire que cet angle vaut 45° avec haut et gauche/droit enfoncé, 60° si que haut et la vitesse en X de ton perso n'est pas nulle, etc...

euh.. parce que j'fait de la 3D ?
devant, derrière, gauche, droite et les diagonales
j'ai mis un lien vers une démo plus haut.

je ne comprend pas pourquoi tu dis que je ne connais pas la position de mon joueur et pour ce qui est d'afficher la progression du saut, c'est ce que j'essaye de faire... c'est pour ça que j'ai ouvert le sujet, avec mon edit ça devrait quand même simplifier mon problème.
j'posterai mes avancements.

**Kaamui** · 12/10/2012, 15h09

Envoyé par noals

t'a répondu pendant que j'éditais mon post

euh.. parce que j'fait de la 3D ?
devant, derrière, gauche, droite et les diagonales
j'ai mis un lien vers une démo plus haut.

je ne comprend pas pourquoi tu dis que je ne connais pas la position de mon joueur et pour ce qui est d'afficher la progression du saut, c'est ce que j'essaye de faire... c'est pour ça que j'ai ouvert le sujet, avec mon edit ça devrait quand même simplifier mon problème.
j'posterai mes avancements.

Ah ok autant pour moi, je croyais que tu le faisais en 2D.

Pour la position du joueur, c'est toi qui te demande comment stocker la hauteur de ton personnage dans la boucle, et comme ce n'est pas nécessaire de stocker une hauteur différente de celle que tu va modifier dans ton joueur justement je ne comprenais pas ce qu'il te fallait en plus.

**noals** · 13/10/2012, 10h24

j'viens de rencontrer d'autres problèmes.
voici mon 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
		if(keys[KEY_KEY_E])
		{
			is_idle=false;
			is_jumping = true;
		}
 
		//if(keys[KEY_KEY_A])playerPos.Y=playerPos.Y+18.0f;		//test
 
		if(is_jumping)
		{
			f32 jump_start_H = terrain->getHeight(		//ground height at playerPos
											playerNode->getPosition().X,
											playerNode->getPosition().Z);
			f32 jump_max_height= jump_start_H + jump_height;	//+defined jump height
 
			if(playerPos.Y<=jump_max_height)
			{
				playerPos.Y=playerPos.Y+1;
			}
			else
			{
				is_falling=true;
				is_jumping=false;
			}
		}
 
		if(is_falling)
		{
			if(playerPos.Y>terrain->getHeight(		//ground height at playerPos
											playerNode->getPosition().X,
											playerNode->getPosition().Z))
			{
				playerPos.Y=playerPos.Y-1;
			}
			else
			{
				is_idle=true;
				is_falling=false;
			}
		}
 
		if(is_idle)
		{
			playerPos.Y=terrain->getHeight(		//ground height at playerPos
											playerNode->getPosition().X,
											playerNode->getPosition().Z);
		}

la ce qu'il se passe, c'est que mon joueur saute mais son élévation se poursuis seulement si je laisse appuyer ma touche.
de plus, en laisant appuyer ma touche, si le joueur atteint (ou depasse?) la hauteur maximal, il reste bloquer dans les air et ne retombe plus.

je me demande si je me sert bien des bool.
faut peut-etre que je change mon event.receiver je crois et y mette ma (ou mes?) touche qui ne devrait pas être dans la boucle peut-etre, j'sais pas trop.

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
class myEventReceiver: public IEventReceiver
{
	public: virtual bool OnEvent(const SEvent& event)
	{
		switch(event.EventType)
		{
		case EET_MOUSE_INPUT_EVENT:
			switch(event.MouseInput.Event)
			{
				case EMIE_MOUSE_MOVED:
					cursor.X=event.MouseInput.X;
					cursor.Y=event.MouseInput.Y;
					return true;
				case EMIE_MOUSE_WHEEL:
					cameraDistance += event.MouseInput.Wheel/10;
					return true;
				default :
					return false;
			}
		case EET_KEY_INPUT_EVENT:
			keys[event.KeyInput.Key]=event.KeyInput.PressedDown;
			return true;
		default :
			return false;
		}
	}
};

de toute façon, faura que je puisse bloquer les touches pendant le saut et hardcoder le movement du saut en fonction de la direction.
je continuerai plus tard.

une idée, un conseil ?

edit : j'me suis fait un nouveau projet pour essayer de refaire mon event receiver donc j'continuerai mon saut apres ça.

edit2 : c'était une mauvaise idée , j'm'y perd encore plus à cause de ça.
faut juste que je change le event receiver pour mon saut je crois, j'sais pas trop, j'vais essayer des trucs.

**Kaamui** · 13/10/2012, 15h47

C'est plus simple que ça : il faut que tu ne traite que ton booléen dans ta gestion événementielle, et que tu traite ton saut que dans le cas ou ton booleen "saut en cours" est passé a vrai.

Code :

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

1
2
3
4
5
6
7
8
9
 
si (touche_presse::ta_touche_de_saut)
   ton_booleen = vrai
 
 
//[...] plus loin
 
si (ton_booleen)
  tes_formules_de_saut;

C'est tout^^

**noals** · 13/10/2012, 16h06

ben ouai mais si tu postes une fois que j'ai trouver les solutions, tu m'aides pas beaucoup lol. ><
'fin bref, donc j'aller éditer encore mon post pour dire ce que Kaamui à dit, j'continue de coder là.
apparement y'a des espions sur le channel ##programming de freenode lol

avec mes bool de cette façon, j'devrais pouvoir limiter mes touches à cause du saut, j'vais essayer, j'reposterai mes avancements plus tard.

**noals** · 13/10/2012, 18h30

pour l'instant, j'en suis là :

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
		if(is_idle)
		{
			playerPos.Y=terrain->getHeight(playerPos.X,playerPos.Z);
 
			if(keys[KEY_KEY_Z]) //moving forward
			{m_forward=true;}
			else m_forward=false;
			if(m_forward)
			{
				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
			{m_backward=true;}
			else m_backward=false;
			if(m_backward)
			{
				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
			{m_left=true;}
			else m_left=false;
			if(m_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
			{m_right=true;}
			else m_right=false;
			if(m_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);
			}
 
			if(keys[KEY_KEY_E]) //straing right
			{
				is_jumping=true;
				is_idle=false;	
			}
		}
 
//////////JUMPING
		if(is_jumping)
		{
			f32 jump_start_H = terrain->getHeight(		//ground height at playerPos
											playerNode->getPosition().X,
											playerNode->getPosition().Z);
			f32 jump_max_height= jump_start_H + jump_height;	//+defined jump height
 
			if(playerPos.Y<=jump_max_height)
			{
				playerPos.Y=playerPos.Y+1;
			}
			else
			{
				is_falling=true;
			}
		}
		if(is_falling)
		{
			is_jumping=false;
			if(playerPos.Y>terrain->getHeight(		//ground height at playerPos
											playerNode->getPosition().X,
											playerNode->getPosition().Z))
			{
				playerPos.Y=playerPos.Y-0.5;
			}
			else
			{
				is_idle=true;
				is_falling=false;
			}
		}

mon perso avance avec les touches, quand j'appuie sur le saut, il saute verticalement et les autres touches sont desactivées jusqu'à ce que le saut soit fini.

ma méthode de switch pour les directions n'a pas vraiment marcher aux premier essaie, problème de timing, j'ai décidé ensuite de la remplacer par des bool encore mais j'me suis retrouvé avec 16 ou plus bool à hard-coder, je cherche donc une autre méthode au cas ou.

il faut que je convertisse mes 9(incluant l'arret) directions en deux facteur X et Z tel que X et Z >0, <0, =0, faudrai que j'change ma façon de gérer la chute aussi peut-être, 'fin bref, doucement mais surement lol.

**noals** · 13/10/2012, 23h09

bon, faut encore que j'améliore mon code pour que le saut paraisse plus réaliste mais ma fonction fonctionne. ^^
j'ai juste utilisé des bool en fait et un petit tableau pour récupérer ma valeur de direction.
merci 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
		if(is_idle)
		{
			playerPos.Y=terrain->getHeight(playerPos.X,playerPos.Z);
 
			if(keys[KEY_KEY_Z]) //moving forward
			{
				m_forward=true;
				jump_direction[0]+=13;
				if(jump_direction[0]>13)jump_direction[0]=13;}
			else {m_forward=false;jump_direction[0]=0;}
 
			if(keys[KEY_KEY_S]) //moving back
			{
				m_backward=true;
				jump_direction[1]+=39;
			if(jump_direction[1]>39)jump_direction[1]=39;}
			else {m_backward=false;jump_direction[1]=0;}
 
			if(keys[KEY_KEY_Q]) //straing left
			{
				m_left=true;
				jump_direction[2]+=24;
				if(jump_direction[2]>24)jump_direction[2]=24;}
			else {m_left=false;jump_direction[2]=0;}
 
			if(keys[KEY_KEY_D]) //straing right
			{
				m_right=true;
				jump_direction[3]+=57;
				if(jump_direction[3]>57)jump_direction[3]=57;;}
			else {m_right=false;jump_direction[3]=0;}
 
			if(keys[KEY_KEY_E]) //jumping
			{
				is_jumping=true;
				is_idle=false;	
			}
		}
		if(m_forward)
		{
			f32 roty_rad=playerRot.Y*PI/180; //convert to radian
			playerPos.Z += playerSpeed*cos(roty_rad);
			playerPos.X += playerSpeed*sin(roty_rad);	
		}
		if(m_backward)
		{
			f32 roty_rad=playerRot.Y*PI/180;
			playerPos.Z -= playerSpeed*cos(roty_rad);
			playerPos.X -= playerSpeed*sin(roty_rad);
		}
		if(m_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(m_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);
		}
 
//////////JUMPING
		if(is_jumping)
		{
			jump_variable=jump_direction[0]+jump_direction[1]+jump_direction[2]+jump_direction[3];
			f32 jump_start_H = terrain->getHeight(		//ground height at playerPos
											playerNode->getPosition().X,
											playerNode->getPosition().Z);
			f32 jump_max_height= jump_start_H + jump_height;	//+defined jump height
 
			if(playerPos.Y<=jump_max_height)
			{
				if(jump_variable==0)			//no direction
				playerPos.Y=playerPos.Y+1;
				else if(jump_variable==13){	//forward
					playerPos.Y=playerPos.Y+1;
					m_forward=true;
					}
				else if(jump_variable==39){	//backward
					playerPos.Y=playerPos.Y+1;
					m_backward=true;
					}
				else if(jump_variable==24){	//left
					playerPos.Y=playerPos.Y+1;
					m_left=true;
					}
				else if(jump_variable==57){	//right
					playerPos.Y=playerPos.Y+1;
					m_right=true;
					}
				else if(jump_variable==37){	//forward + left
					playerPos.Y=playerPos.Y+1;
					m_forward=true;
					m_left=true;
					}
				else if(jump_variable==70){	//forward + right
					playerPos.Y=playerPos.Y+1;
					m_forward=true;
					m_right=true;
					}
				else if(jump_variable==63){	//backward + left
					playerPos.Y=playerPos.Y+1;
					m_backward=true;
					m_left=true;
					}
				else if(jump_variable==96){	//backward + right
					playerPos.Y=playerPos.Y+1;
					m_backward=true;
					m_right=true;
					}
			}
			else
			{
				is_falling=true;
			}
		}
		if(is_falling)
		{
			is_jumping=false;
			if(playerPos.Y>terrain->getHeight(		//ground height at playerPos
											playerNode->getPosition().X,
											playerNode->getPosition().Z))
			{
				playerPos.Y=playerPos.Y-0.5;
			}
			else
			{
				is_idle=true;
				is_falling=false;
			}
		}

besoin d'aide pour simuler un saut

C++

Discussions similaires

Partager

Partager