De Scratch Wiki en français


La gravité


La gravité est une force physique présente dans tout l'univers s’exerçant sur chaque corps ayant une masse. Ce corps est attiré et attire d'autres corps (ayant également une masse) plus ou moins fort en fonction de la différence de leurs masses et de la distance qui les sépare.

Ex. : La Terre attire toutes les créatures vers son centre (c'est pour cela que l'on retombe quand on saute). La Lune attire l'eau des mers et océans, ce qui provoque les marées, etc.

On peut facilement reproduire ce phénomène sur Scratch en cas de besoin, pour certains types de jeux par exemple. On retrouve notamment la gravité dans de nombreux projets du type "platformer". Cette partie importante dans la physique peut même s’avérer être une composante primordiale sur Scratch dans le gameplay d'un jeu de plateformes, par exemple.

Il est avant tout nécessaire de redéfinir la manière dont l'on contrôle la position d'un sprite.

En effet, des blocs de mouvement sont implémentés dans Scratch pour permettre une meilleure accessibilité aux débutants. Nous allons apprendre à nous en servir et à créer nos propres blocs pour comprendre et reproduire le plus fidèlement la gravité dans Scratch.

Les coordonnées (X,Y,Z)

Les 3 axes des 3 dimensions

La position d'un sprite peut être définie dans l'espace par des coordonnées de variables x, y et z. Ces variables sont représentatives de la position dans les 3 dimensions que compte l'espace.

  • La variable x représente la position sur l'axe des abscisses (axe horizontal).
  • La variable y représente la position sur l'axe des ordonnées (axe vertical).
  • La variable z représente la position sur l'axe de la cote (axe de profondeur).

Le dernier axe, la cote, n'est pas présent sur Scratch. En effet, la scène de l'éditeur est un plan en deux dimensions, pas de place pour la 3ᵉ…

La scène sera donc caractérisée par un axe x et un axe y.

Dans un jeu où la gravité intervient, une force (en physique, mais un script de déplacement dans Scratch) fera se déplacer un objet (un sprite) dans une direction (horizontale ou verticale). Le sprite sera donc déplacé vers un axe (x ou y) à une certaine vitesse pour arriver à un point précis.

La vitesse et l'accélération

La vitesse en fonction du temps (accélération)
La distance en fonction du temps (accélération)

En physique la gravité est considérée comme une accélération. Plus l'objet/mobile est haut, plus il aura le temps de tomber plus vite dans sa chute. Sa vitesse augmentera de manière croissante et régulière tandis que la distance que l'objet parcourra durant sa chute sera exponentielle (on peut le matérialiser par un courbe qui augmente de plus en plus).

La notion d'accélération correspond à la valeur que l'on ajoutera à la variable « vitesse », qui fera glisser le sprite ver le bas (ou autre direction si la gravité ne s'applique pas vers le bas). Chaque instant, la vitesse de chute du sprite sera augmentée de « valeur d'accélération ». Le sprite tombera de « valeur de vitesse » cases en « temps » unités de temps.

L'accélération sera exprimée en [m/s²] (mètre par seconde au carré). La vitesse en [m/s] (mètre par seconde). Le temps en [s] (seconde).

Par exemple, sur terre, l'accélération est de 9,81 [m/s²]. Donc chaque objet qui n'est pas retenu augmentera sa vitesse de chute de 9,81 [m/s] chaque seconde.

C'est donc avec les variables de vitesse et d'accélération que le Scratcheur pourra contrôler le déplacement des sprites.







Influence des variables

Une valeur positive de la variable qui représentera l'accélération (verticale) se traduira par un déplacement vers le bas.

En contrepartie, une valeur négative se traduira par un déplacement vers le haut.

Autrement, une valeur nulle dans la variable impliquera une immobilité verticale.

Reproduire la gravité dans Scratch

1. Le moyen le plus simple

La gravitation se traduit par un mouvement permanent du sprite vers le centre de l'astre sur lequel il se trouve (sur Scratch, c'est vers le bas de la scène, le sol ou le plancher des vaches, appelez-le comme vous voulez...).

On peut donc s'approcher d'une sorte de gravité en faisant constamment descendre le sprite vers ce sol.

Pratiquement :

1. Créer un sprite sol.

2. Mettre le script 1 ou 2 dans le sprite qui doit tomber.

Moyen 1 :

Avec un sprite appelé « sol ».

quand le drapeau vert pressé
répéter indéfiniment
attendre jusqu'à ce que <non <touche le (sol v) ?>>
répéter jusqu'à ce que <non <touche le (sol v) ?>>
ajouter (2) à y
fin
répéter jusqu'à ce que <touche le (sol v)?>
ajouter (-2) à y
fin
fin

Moyen 2 :

Avec les blocs de couleur (si votre sol est noir).

quand le drapeau vert pressé
répéter indéfiniment
attendre jusqu'à ce que <non <couleur (#000000) touchée?>>
répéter jusqu'à ce que <non <couleur (#000000) touchée?>>
ajouter (2) à y
fin
répéter jusqu'à ce que <couleur (#000000) touchée?>
ajouter (-2) à y
fin
fin

2. Gravité réaliste

La gravité est, comme je l'ai expliqué plus haut, une accélération, et donc une modification de la vitesse en fonction du temps. On peut obtenir une chute plus fluide et réaliste en ajoutant une valeur négative à la vitesse à chaque instant en cas de chute.

Cette valeur doit être un multiple de 9,81 (ce qui correspond à l'accélération terrestre de 9,81 [m/s²]).

Pour plus de fluidité, on n'actualisera pas la vitesse toutes les 1 [s], mais un certain nombre de fois par seconde.

On peut actualiser la vitesse 10 fois par seconde. Il faudra donc augmenter la vitesse de (« force de gravité »/10).

En effet cette valeur correspond à l’accélération subie en un dixième de seconde, ou 10 (nombre de fois actualisés par seconde) × 9,81[m/s²] (valeur de l'accélération) / 10 (Division pour équilibrer) = 9,81.

Le tour est joué !

Pratiquement :

1. On crée 3 variables (« accélération », « vitesse » et « diviseur »).

2. Mettre le script dans le sprite qui doit tomber.

quand le drapeau vert pressé
mettre [diviseur v] à [10]
mettre [vitesse v] à [1]
mettre [accélération v] à [9.81]
répéter indéfiniment
répéter jusqu'à ce que <couleur (#000000) touchée?>
glisser en ((1) / (diviseur)) secondes à x: (abscisse x) y: ((ordonnée y) - ((vitesse::variables) / (diviseur)))
fin
mettre [vitesse v] à [1]
répéter jusqu'à ce que <non <couleur [#000000] touchée?>>
ajouter (1) à y
fin
fin

quand le drapeau vert pressé
répéter indéfiniment
si <non <couleur [#000000] touchée?>> alors
attendre ((1)/(diviseur)) secondes
ajouter ((accélération)/(diviseur)) à [vitesse v]::variables
sinon
mettre [vitesse v] à (0)
fin

Créer un jeu de plateforme en Scratch

La gravité est utilisée dans plusieurs jeux comme les jeux de plateformes, en anglais “platformer”, pour ce genre de jeu il faut une gravité plutôt fluide, mais aussi un moyen de ne pas passer à travers les murs, voici donc comment faire : Attention pour faire cette gravité il faut savoir utiliser les blocs personnalisés. Pour commencer il faut :

  1. créer un bloc « Plateforme Physique hauteur de saut : (y) la vitesse de déplacement : (vitesse) friction : (friction) ».
  2. créer 3 variables : x vel, y vel et pente.
  3. créer un sprite “platform's”.
  4. Mettre le script suivant dans le sprite qui doit tomber sauter et se déplacer.
quand le drapeau vert pressé
répéter indéfiniment 
Plateforme Physique hauteur de saut : (12) la vitesse de déplacement : (2) friction : (0.9) :: custom
end


définir Plateforme Physique hauteur de saut : (y) la vitesse de déplacement : (vitesse :: custom-arg) friction : (friction :: custom-arg)
si <<<touche (flèche droite v) pressée ?> ou <<souris pressée ?> et <(souris x) < (abscisse x)>>> ou <touche (d v) pressée ?>> alors 
  ajouter (vitesse :: custom-arg) à [x vel. v]::variables
end
si <<<touche (flèche gauche v) pressée ?> ou <<souris pressée ?> et <(souris x) > (abscisse x)>>> ou <touche (a v) pressée ?>> alors 
  ajouter ((vitesse :: custom-arg) * (-1)) à [x vel. v]::variables
end
mettre [x vel. v] à ((x vel.::variables) * (friction :: custom-arg))
ajouter (x vel.::variables) à x
si <touche le (platform's v) ?> alors 
  mettre [pente v] à [0]
  répéter jusqu'à ce que <<non <touche le (platform's v) ?>> ou <(pente::variables) = [8]>> 
    ajouter (1) à [pente v]::variables
    ajouter (1) à y::variables
  end
  si <touche le (platform's v) ?> alors 
    ajouter ((pente::variables) * (-1)) à y
    répéter ([plafond v] de ([abs v] de (x vel.::variables))) fois 
      si <touche le (platform's v) ?> alors 
        ajouter ((([abs v] de (9)) / (x vel.::variables)) * (-1)) à x
      end
    end
    mettre [xvel v] à [0]
  end
end
ajouter (y vel.::variables) à y vel
si <touche le (platform's v) ?> alors 
  répéter ([plafond v] de ([abs v] de (x vel.::variables))) fois 
    si <touche le (platform's v) ?> alors 
      ajouter ((([abs v] de (y vel.::variables)) / (y vel.::variables)) * (-1)) à y
    end
  end
  si <<(([abs v] de (y vel.::variables)) / (y vel.::variables)) = [1]> et <<<touche (flèche haut v) pressée ?> ou <<souris pressée ?> et <(souris y) > (ordonnée y)>>> ou <touche (w v) pressée ?>>> alors 
    mettre [y vel. v] à (y :: custom-arg)
  sinon 
    mettre [y vel. v] à [0]
  end
sinon 
  ajouter (-1) à [y vel. v]::variables
end
Cet article fait partie de la catégorie des tutos
Tous les articles de cette catégorie :