Linden Vehicle Tutorial/fr

== Les Véhicules ==
La création de véhicules dans Second Life est une nouvelle fonctionnalité à présent disponible via le LSL. Ce tutorial détaille les bases nécessaires à la création de ces véhicules, des informations complémentaires sont consultables dans les pages relatives aux fonctions et aux codes décrits ici. 
Il existe, à ce jour, deux méthodes permettant de rendre un objet mobile dans SL. L’une d’elle consiste à le transformer en véhicule. Cette méthode est suffisamment souple pour créer des véhicules qui glissent, lévitent, volent ou flottent. De plus certains comportements spécifiques peuvent être créés :
*Le contrôle des moteurs linéaires et angulaires pour pousser un objet dans une direction ou le faire pivoter sur lui même.
*Le contrôle du braquage au niveau des vitesses linéaires et angulaires
*Le contrôle des frottements linéaires et angulaires.
*Le contrôle de la lévitation au dessus d’un terrain ou de l’eau ou à une altitude fixe.
*Le contrôle de l’inclinaison dans les virages.
== Vue Générale ==
Il est possible de configurer le comportement d’un objet grâce aux fonctions llSetVehicleType,
llSetVehicleFloatParam, llSetVehicleFloatParam, llSetVehicleRotationParam, llSetVehicleFlags/fr et llRemoveVehicleFlags.
Les fonctionnalités disponibles au travers de ces fonctions sont décrites un peu plus loin. La chose importante à noter ici est que le comportement d’un véhicule est défini par une série de paramètres ajustables. Ce sont ces paramètres qui permettront de décider si un objet pourra flotter comme un bateau ou glisser comme un traîneau.
Il existe par ailleurs, une série de codes permettant de déroger au fonctionnement standard. Une partie de ces codes ne sont par ailleurs effectifs que dans certaines situations.
Par exemple, le code VEHICLE_FLAG_HOVER_WATER_ONLY fera léviter un objet sans tenir compte de l’altitude du terrain mais ce code ne fonctionnera que si l’objet est capable de léviter.
== Points d’attention==
La notion de véhicules a été récemment ajoutée à Second life et certains de leur comportement évolueront encore. Il est possible, par exemple, que les limites décrites dans la suite du document évoluent (ou aient même déjà évolué). Afin d’être sure d’avoir des informations à jour, n’hésitez pas à vous reporter aux fiches descriptives des fonctions et des valeurs.
Il n’est pas recommandé de mixer certaines fonctionnalités avec celles relatives aux véhicules. 
Les fonctions permettant d’appliquer des poussées sur des objets ne doivent pas être combinées à celles relatives aux véhicules : llSetBuoyancy, llSetForce, llSetTorque et llSetHoverHeight 
Il est déconseiller de mixer les fonctions suivantes avec celles relatives aux véhicules aux risque de provoquer un comportement curieux ou inattendu : llLookAt, llRotLookAt, llMoveToTarget et llTargetOmega.
Si vous pensez avoir trouvé une anomalie relative aux véhicules, il vous est possible d’envoyer une copie de votre script à "Andrew Linden" avec un commentaire ou note explicative. Nommer vos envois "Bugged Vehicle XX" ou XX correspond à vos initiales. Le véhicule et le script seront examinés aussi vite que possible.
== Les définitions ==
Les termes roulis ou tangages et sont souvent utilisés pour décrire un type de rotation effectuée par des bateaux ou des avions selon un axe qui leur est relatif (par exemple, un bateau tangue selon un axe central à sa coque).
http://en.wikipedia.org/wiki/Tait-Bryan_angles
La « technique de la main droite » est souvent utilisée comme introduction aux cours de physique afin de définir les rotations positives. Un exemple courant consiste à utiliser la « technique de la main droite » pour modéliser le roulement d’un bateau ou d’un avion. Placez votre pouce dans l’axe de l’avion (axe x) et repliez les doigts vers l’intérieur de la main, votre main s’incline naturellement dans le sens ou l’avion devrait pivoter, votre main effectue une rotation dans le sens positif.
http://en.wikipedia.org/wiki/Right_hand_rule
La plupart des paramètres contrôlant le comportement des véhicules sont sous la forme : VEHICLE_COMPORTEMENT_TIMESCALE
Le délai (ou timescale) appliqué au COMPORTEMENT être interprétable comme le temps nécessaire pour que l’action induite fasse effet (délai entre la décision et son entière application). Les fonctions travaillent sur une échelle exponentielle, un cœfficient de 1/e est appliqué (e correspond à l’exposant (environ 2.718281828)). 
Si vous souhaitez un véhicule très maniable, utilisez un délai court (une seconde voire moins). Un délai de 300 secondes (5 minutes) ou plus désactivera un comportement.
Pour des raisons techniques, il existe un délai minimal de l’ordre du dixième de seconde. Mettre un délai à 0 sera toujours équivalent au plus petit délai possible.
== Paramétrer le type de véhicule ==
Avant de commencer à définir les paramètres d’un véhicule, il est indispensable d’indiquer le type de véhicule. Cette donnée est fixée avec la fonction llSetVehicleType et un paramètre de type VEHICLE_TYPE_*. Le paramètre VEHICLE_TYPE_NONE désactivera le mode véhicule. Consultez la page sur pour connaître les options disponibles. Cette liste devrait s’agrandir avec le temps.
Paramétrer le type de véhicule est indispensable pour permettre à un objet de se comporter comme un véhicule et pour définir des paramètres par défaut.
Pour chaque type de véhicule, vous trouverez la liste des valeurs par défaut. Ce ne sont pas nécessairement des valeurs optimales et il est possible de les modifier. Il est obligatoire d’indiquer un type de véhicule même pour créer un véhicule original ou expérimental
Indiquer un type de véhicule ne rend pas automatiquement l’objet mobile, mais vous devriez éviter de créer un véhicule lorsque votre objet est libre de ces mouvements et placé au sommet d’une colline car il pourrait commencer à se déplacer tout seul.
Nous sommes toujours à la recherche de paramètres optimaux, si vous pensez avoir trouvé un jeu de règles plus réaliste ou efficace, vous pouvez les envoyer à Andrew Linden via un script ou une note.
== Le braquage linéaire et angulaire ==
Une fonction récurrente des véhicules réels est l’existence d’un axe préférentiel de déplacement. Cet axe vient de leurs roues, de leurs ailes, de leur forme ou de leur méthode de propulsion. Ils ont tendance à se déplacer selon cet axe et/ou d’y revenir naturellement. Cet axe est statique dans le référentiel du véhicule.
Prenons par exemple une fléchette, elle possède des palmes à l’arrière qui, par les frottements de l’air, est capable de naturellement s’aligner dans le sens du mouvement. C’est cet effet qui est appelé « braquage angulaire » (rotation de l’objet).
Un engin sur roues présente un effet différent, quand un skateboard est poussé dans une direction, il a tendance à se réorienter dans l’axe de roulement. C’est cet effet qui est appelé « braquage linéaire » (rotation de la vitesse)
Ainsi, un véhicule de Second Life est un véhicule avec un braquage linéaire et angulaire le long d’axes préférentiels dans le référentiel de la prim racine.
Prenons le cas d’un véhicule avec un axe préférentiel x :
* dans le cas du braquage linéaire, le script aura tendance à influer sur la direction jusqu'à ce qu’elle pointe dans le sens positif de l’axe x.
* dans le cas du braquage angulaire, le script aura tendance à influer sur le véhicule jusqu’à ce qu’il pointe dans le sens du mouvement. 
Les fonctionnalités applicables aux autres axes, sont décrites plus loin, comme l’attracteur vertical qui soumet un véhicule à une force d’attraction (sur l’axe z)
Le référentiel du véhicule peut être différent de celui de la prim en utilisant VEHICLE_REFERENCE_FRAME. Cette fonctionnalité sera étudiée dans la suite du document.
Selon le type de véhicule, il peut être souhaitable d’avoir un braquage linéaire ou angulaire plus ou moins fort. La force (ou vitesse d’application) du braquage est contrôlée à l’aide la fonction llSetVehicleFloatParam
Les deux types de braquage ont un délai d’application (ou timescale) qui détermine à quelle vitesse le braquage influe sur le véhicule. Ce délai est un coefficient exponentiel représentant le temps nécessaire au braquage pour être entièrement appliqué au véhicule. Les véhicules se braquant rapidement doivent avoir un petit délai, par exemple une fléchette doit avoir un braquage angulaire de moins de 2 secondes et un braquage linéaire de plusieurs secondes, car elle aura tendance à se réorienter avant d’influer sur sa direction. Pour une fléchette, vous pourriez utiliser les paramètres suivants :
<lsl>
llSetVehicleFloatParam(VEHICLE_ANGULAR_DEFLECTION_TIMESCALE, 2.0);
llSetVehicleFloatParam(VEHICLE_LINEAR_DEFLECTION_TIMESCALE, 6.0);
</lsl>
Chacun des braquages a un coefficient d’efficacité variant de 0.0 à 1.0, à la différence des autres paramètres, il ne va pas de « élastique» (0.0) à « amorti » (1.0) mais de « pas de braquage » (0.0) à « braquage maximum » (1.0). Ils se comportent un peu comme les délais d’application, mais sont normés entre 0 et 1.
== Le déplacement du véhicule ==
Une fois activé, le véhicule peut toujours être poussé et tourné par impulsion (forces extérieures ou scripts utilisant llApplyImpulse), mais il faut garder à l’esprit les moteurs linéaires et angulaires rendent les mouvements plus fluides et rendent les déplacement bien plus paramétrable. Le déplacement d’un véhicule peut être piloté avec la fonction llSetVehicleVectorParam.
Pour déplacer un objet à 5 mètres/seconde le long de son axe x (l’axe de la vue subjective), il suffit d’ajouter la ligne suivante à votre script :
<lsl>llSetVehicleVectorParam(VEHICLE_LINEAR_MOTOR_DIRECTION, <5, 0, 0>);</lsl>
Pour éviter aux véhicules de se déplacer trop vite, la vitesse maximale est de 30 mètres/seconde. Cette limitation vient des contraintes du moteur physique de SL et pourra être étendue ultérieurement.
Jouer sur la vitesse ne suffit pas à créer des véhicules intéressants. 
Vous pourriez par exemple vouloir créer une voiture capable d’atteindre immédiatement sa vitesse limite ou qui au contraire accélérerait progressivement. Cet effet peut être configuré avec le paramètre VEHICLE_LINEAR_MOTOR_TIMESCALE. Ce paramètre représente le temps nécessaire (sur une échelle exponentielle) au véhicule pour atteindre sa vitesse maximale.
Que se passerait il si vous lanciez un véhicule à la pleine vitesse (vitesse du moteur linéaire)? En théorie, le véhicule devrait partir en ligne droite et ne jamais s’arrêter.
En fait, ce phénomène est également configurable grâce à une fonction simulant une perte de vitesse progressive. Immédiatement après qu’un moteur ait été sollicité, il commence alors à réduire sa vitesse selon un délai paramétré par VEHICLE_LINEAR_MOTOR_DECAY_TIMESCALE. De cette façon, passé un certain temps, les moteurs cessent d’avoir de l’effet et le véhicule s’arrête tout seul.
Vu que ce délai ne peut dépasse 120 secondes et qu’il est permanent, il garantit qu’un véhicule ne roulera jamais éternellement (sans action manuelle et sans boucle logique).
Ce paramètre peut être employé pour appliquer une impulsion. On peut par exemple configurer les touches haut/bas pour allumer ou atteindre le moteur d’une voiture, les deux touches modifie simplement le temps nécessaire au véhicule pour s’arrêter (délai court = moteur éteint, petite impulsion avant de s’arrêter ; délai long = moteur allumé, grand impulsion avant arrêt du véhicule).
Un moteur est réinitialisée à chaque fois que son paramétrage est modifié, un vector de vitesse nul n’a pas le même sens qu’une perte de vitesse rapide (délai nul). Dans le premier cas, le moteur va chercher à atteindre la vitesse nul, dans le second cas, le véhicule s’arrête immédiatement.
::VEHICLE_LINEAR_MOTOR_TIMESCALE est le temps nécessaire au moteur pour appliquer la nouvelle vitesse.
::VEHICLE_LINEAR_MOTOR_DECAY_TIMESCALE est le temps nécessaire au moteur pour repasser à une vitesse nulle.
Mélanger les deux paramètres risque d’occasionner beaucoup de frustration vu leurs effets très différents...
De plus, si la perte de vitesse est plus rapide que le temps nécessaire pour atteindre la vitesse cible du véhicule, alors l’efficacité globale du moteur est diminuée en conséquence.
== L’orientation du véhicule ==
Tout comme le moteur linéaire, il existe également un moteur angulaire (toujours actif) et dont la direction et la puissance sont configurables. Par exemple pour faire tourner un véhicule de 5 degrés/seconde autour de son axe Z (axe haut/bas), il suffit d’ajouter les lignes suivantes à votre script :
<lsl>vector angular_velocity = <0, 0, 5 * PI / 180>;
llSetVehicleVectorParam(VEHICLE_ANGULAR_MOTOR_DIRECTION, angular_velocity);</lsl>
Il n’est actuellement pas possible de réaliser plus de 2 rotations / seconde. (4*PI radians/sec).
Comme pour le moteur linéaire, il existe deux paramètres de temps :
VEHICLE_ANGULAR_MOTOR_TIMESCALE et VEHICLE_ANGULAR_MOTOR_DECAY_TIMESCALE qui correspondent au temps nécessaire pour atteindre la vitesse maximale et au temps nécessaire pour repasser à une vitesse nulle (mis à 120 secondes par défaut)
Lorsque vous pivotez, vous souhaitez sûrement éviter que votre véhicule ne tourne trop vite ou trop longtemps. :
* Une façon de faire, consiste à utiliser le moteur angulaire avec une perte de vitesse longue mais avec un fort coefficient de frottement angulaire (de façon à provoquer une perte de vitesse rapide lorsque le moteur est arrêté). Puis d’appliquer une importante vitesse angulaire lorsque la touche est pressée et de repasser la vitesse à 0 lorsqu’elle est relâchée.
* Une autre façon de faire, consiste d’appliquer une petite durée au VEHICLE_ANGULAR_MOTOR_DECAY_TIMESCALE et d’utiliser une impulsion plus forte en jouant sur la réduction de la vitesse plutôt que sur les frottement.
Comme pour le moteur linéaire, une vitesse angulaire nulle est différente d’une perte de vitesse immédiate (délai nul). Une vitesse nulle imposera une transition depuis la vitesse actuelle du moteur angulaire, alors qu’un délai nul stoppera immédiatement la rotation.
Pour certains véhicules, il sera possible d’appliquer une inclinaison pour tourner. Cette inclinaison est visible lorsque des avions ou des motos effectuent un virage. Cette inclinaison est réalisée suivant l’axe de roulement du véhicule. Cette fonctionnalité n’est disponible que lorsque l’attracteur vertical (décrit plus bas) est activé.
== L’attracteur vertical ==
Certains véhicules comme les bateaux gardent toujours leur face supérieure orientée vers le haut. Ce phénomène peut être reproduit à l’aide de l’attracteur vertical qui permet d’exécuter de petits bonds le long de l’axe z. 
Cette fonctionnalité s’utilise avec VEHICLE_VERTICAL_ATTRACTION_TIMESCALE pour contrôler la période des rebonds (ou la vitesse d’amortissement) et VEHICLE_VERTICAL_ATTRACTION_EFFICIENCY pour contrôler le phénomène d’amortissement (0.0 : oscillations autour de la position d’équilibre // 1.0 : amortissement progressif vers la position d’équilibre)
<lsl>llSetVehicleVectorParam(VEHICLE_VERTICAL_ATTRACTION_TIMESCALE, 4.0);
llSetVehicleVectorParam(VEHICLE_VERTICAL_ATTRACTION_EFFICIENCY, 0.5);</lsl>
L’attracteur vertical est désactivé si l’on positionne une période (ou timescale) supérieure à 300 secondes.
Il faut noter que l'attracteur vertical empêchera les véhicules de plonger et de grimper. Ainsi, si vous souhaitez réaliser une avion, il vous faudra probablement désactiver l'attracteur le long de l'axe de roulement à l'aide du code :VEHICLE_FLAG_LIMIT_ROLL_ONLY
 
<lsl>llSetVehicleFlags(VEHICLE_FLAG_LIMIT_ROLL_ONLY);</lsl>
== L’inclinaison ==
Cette fonctionnalité permet de pivoter le véhicule au moyen de rotations sur l'axe de roulement du véhicule.
L'attracteur vertical doit être activé si l'on souhaite utiliser cette fonction.
L'amplitude de l'inclinaison est liée au paramètre VEHICLE_BANKING_EFFICIENCY qui indique l’amplitude de la rotation (et parfois la vitesse du véhicule autour de son axe préférentiel de déplacement).
Le paramètre varie entre -1 et +1. 
* Si le paramètre est positif, lors d’une rotation positive le long de l'axe de roulement (inclinaison sur la droite) un couple négatif est appliqué ce qui fait tourner le véhicule à droite. C’est le phénomène observé sur les avions et les motos dans un virage.
* Si le paramètre est négatif, lors d’une rotation positive le long de l'axe de roulement (inclinaison sur la droite), un couple positif est appliqué, ce qui fait tourner le véhicule à gauche. Ce phénomène ne correspond à aucune réalité physique, mais peut être utilisé par exemple pour créer des véhicules atypiques.
 
Le paramètre VEHICLE_BANKING_MIX permet de changer les critères d'inclinaison au lieu de laisser le moteur physique décider de l’inclinaison optimale.
Prenons par exemple une moto, dans la réalité, elle ne peut s’incliner que lorsqu’elle est en mouvement, alors que dans les jeux vidéo, elle est capable de s’incliner au point mort. L'interface des joueurs étant limitée, il est bien plus facile de contrôler un véhicule de cette façon. 
Ce paramètre permet de combiner des inclinaisons réalistes et non réalistes. Il varie entre 0.0 (statique) et 1.0 (dynamique). "Statique" signifie que l'inclinaison dépend uniquement de la rotation de l'objet (application des lois physiques) alors que "dynamique" signifie que le vitesse de rotation est également prise en compte. Trouver la meilleure valeur nécessitera probablement beaucoup de tests.
 
Le temps nécessaire à l'inclinaison pour contrecarrer une vitesse angulaire préexistante le long de l'axe Z (et devenir visible) est déterminée par VEHICLE_BANKING_TIMESCALE. Plus la valeur sera petite, plus l'inclinaison sera prise en compte rapidement.
== Les frottements (ou résistances) ==
VEHICLE_LINEAR_FRICTION_TIMESCALE est un vector qui configure, pour les 3 axes, le temps nécessaire au véhicule pour s'arrêter complètement (à cause des "frottements").
Les 3 valeurs sont dépendantes les unes des autres. Une voiture aura par exemple peu de frottement le long de son axe x et z (afin qu'elle puisse avancer, reculer, monter et descendre des pentes) alors qu'elle aura d'importants frottement le long de l'axe y (droite/gauche)
 
<lsl>llSetVehicleVectorParam(VEHICLE_LINEAR_FRICTION_TIMESCALE, <1000, 1000, 3>);</lsl>
 
Plus le délai est important, plus faibles sont les frottements, par conséquent, il faut indiquer une valeur élevée pour désactiver ce phénomène le long d'un axe.
 
Il est possible d'indiquer le coefficient de frottement linéaire comme un scalaire (float). Ce choix a pour conséquence de donner la même valeur aux 3 champs.
Les deux exemples suivants sont similaires et rendent les frottements négligeables.
<lsl>// Positionne tous les temps d'arrêt par frottement à 1000
llSetVehicleVectorParam(VEHICLE_LINEAR_FRICTION_TIMESCALE, <1000, 1000, 1000>);
// Idem, mais avec moins de données.
llSetVehicleFloatParam(VEHICLE_LINEAR_FRICTION_TIMESCALE, 1000);</lsl>
VEHICLE_ANGULAR_FRICTION_TIMESCALE est un paramètre de type vector qui définit le temps nécessaire au moteur angulaire pour s'arrêter à cause des frottements. Il fonctionne comme le paramètre du moteur linéaire.
== La flottabilité ==
Les véhicules ont une flottabilité indépendante de la fonction llSetBuoyancy. Il est recommandé d'éviter de mélanger les deux fonctions.
Un véhicule acquière la flottabilité à l'aide du paramètre VEHICLE_BUOYANCY : 0.0 = aucune flottabilité // 1.0 = zéro gravité.
 
La flottabilité est différente de la lévitation. 
Pour que la lévitation fonctionne sans risquer de décalage lors de l’emploi du paramètre VEHICLE_HOVER_HEIGHT, le paramètre VEHICLE_BUOYANCY doit être positionné à 1.0
== La lévitation ==
La lévitation est activée lorsque la paramètre VEHICLE_HOVER_TIMESCALE prend une valeur inférieure à 300 secondes (des valeurs supérieures désactivent également la fonctionnalité). 
Ce paramètre indique le temps nécessaire au véhicule pour se mettre en lévitation.
La plupart des véhicules fonctionnent mieux avec un temps de lévitation de quelques secondes (voire moins). Plus le temps sera court, plus le comportement du véhicule sera influencé par son poids.
 
Il faut noter que les frottements (cf. VEHICLE_LINEAR_FRICTION_TIMESCALE) peuvent influencer la mise en lévitation. 
 
La lévitation est indépendante de la flottabilité mais VEHICLE_BUOYANCY doit être mise à 1.0, sinon le véhicule ne lévitera pas tant que la hauteur cible de lévitation VEHICLE_HOVER_HEIGHT ne compense pas la gravité, de plus le véhicule ne flottera jamais à la bonne hauteur.
 
Le paramètre VEHICLE_HOVER_EFFICIENCY permet de configurer la lévitation, il varie de 0.0 (avec oscillation) à 1.0 (stable)
Lorsque le paramètre est à 0, le véhicule oscille à une altitude un peu plus basse que l'altitude cible et la période des oscillations correspond à peu près à celle définie par VEHICLE_HOVER_TIMESCALE (la vraie période est un peu plus longue)
 
De part les limitations du moteur physique de SL, la lévitation ne prend en compte que les zones terrestres et marines, il est actuellement impossible de léviter au dessus de prims telles un pont ou une maison.
 
Par défaut un véhicule lévitera au dessus de l'eau et de la terre, certains paramètres permettent de modifier ce comportement : 
VEHICLE_HOVER_WATER_ONLY est à utiliser pour les bateaux (lévitation en zone marine uniquement)
VEHICLE_HOVER_TERRAIN_ONLY est à utiliser pour un tank susceptible d'aller sous l'eau (lévitation sur terre uniquement).
VEHICLE_HOVER_GLOBAL_HEIGHT est à utiliser pour un sous-marin ou un ballon.
Ces codes ne sont pas compatibles, et les mélanger risque de générer des comportements atypiques. Ces codes sont à utiliser avec la fonction llSetVehicleFlags.
 
Le paramètre VEHICLE_HOVER_HEIGHT permet de décider à quelle altitude le véhicule doit léviter (au dessus de l'eau, de la terre ou en hauteur absolue). La valeur maximale est de 100 mètres
 
Le point de lévitation est fixé par le centre de gravité (parfois difficile à repérer pour des personnes non entraînées), par ailleurs le centre change lorsqu'une personne est assise sur l'objet.
== Référentiels relatifs ==
Les véhicules se basent sur leurs axes x (avant/arrière), y (droite/gauche) et z (haut/bas) pour décider de leur mouvement. Par défaut ces axes sont identiques à ceux de la prim racine, mais cela suppose que la prim racine soit parfaitement orientée afin que les deux référentiels correspondent. Ce n'est pas toujours possible, comme, par exemple, dans le cas de véhicules préconstruits.
 
C'est dans ce type de situation que le paramètre VEHICLE_REFERENCE_FRAME devient utile car il permet de réorienter les axes du véhicule de manière indépendante du référentiel de la prim.
 
Par exemple, supposons que nous ayons construit une fusée à partir d'un grand cylindre, d'un cône pour l'avant et avec le cylindre comme prim principale.
Idéalement, la fusée devrait se déplacer le cône en 'avant, or l'axe de déplacement avant l'axe x (qui pointe à l'horizontal du sol). Le script suivant effectue une rotation de façon à ce que l'axe x, remplace l'axe z (vers le haut).
<lsl>// Tourne le référentiel du véhicule de -PI/2 autour de l'axe y (axe gauche/droite)
rotation rot =llEuler2Rot(<0, PI/2, 0>);
llSetVehicleRotationParam(VEHICLE_REFERENCE_FRAME, rot);</lsl>
 
Un autre exemple : Prenons une navette spatiale qui souhaite voler l'horizontalement avec l'attracteur vertical mais décoller et atterrir verticalement (également avec l'attracteur). En vol, le nez de la navette doit être vers l'avant, mais lors de l'atterrissage, il doit être orienté vers le haut. Pour que la navette puisse atterrir avec l'attracteur actif, il suffit d'effectuer un rotation du référentiel de +PI/2 selon l'axe y, de cette façon, la tête de la navette se relève et permet l'atterrissage. Tout en conservant l'attracteur, la navette pourra se poser en utilisant les frottements ou une diminution de la lévitation pour se poser.