Attention: Here be dragons
This is the latest
(unstable) version of this documentation, which may document features
not available in or compatible with released stable versions of Godot.
Checking the stable version of the documentation...
CharacterBody3D
Hérite de : PhysicsBody3D < CollisionObject3D < Node3D < Node < Object
Un corps physique 3D spécialisé pour les personnages déplacés par script.
Description
CharacterBody3D est une classe spécialisée pour les corps physiques qui sont destinés à être contrôlés par l'utilisateur. Ils ne sont pas affectés par la physique du tout, mais ils affectent les autres corps physiques sur leur chemin. Ils sont principalement utilisés pour fournir à l'API de haut niveau un moyen de déplacer des objets avec de la détection de mur et de pente (la méthode move_and_slide()) en plus de la détection générale de collisions fournie par PhysicsBody3D.move_and_collide(). Cela la rend utile pour les corps physiques hautement configurables qui doivent se déplacer de manière spécifique et se entrer en collision avec le monde, comme c'est souvent le cas avec des personnages contrôlés par l'utilisateur.
Pour les objets de jeu qui ne nécessitent pas de détection de mouvement ou de collision complexe, comme des plates-formes mobiles, AnimatableBody3D est plus simple à configurer.
Tutoriels
Propriétés
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
Méthodes
void |
|
get_floor_angle(up_direction: Vector3 = Vector3(0, 1, 0)) const |
|
get_floor_normal() const |
|
get_last_motion() const |
|
get_platform_angular_velocity() const |
|
get_platform_velocity() const |
|
get_position_delta() const |
|
get_real_velocity() const |
|
get_slide_collision(slide_idx: int) |
|
get_slide_collision_count() const |
|
get_wall_normal() const |
|
is_on_ceiling() const |
|
is_on_ceiling_only() const |
|
is_on_floor() const |
|
is_on_floor_only() const |
|
is_on_wall() const |
|
is_on_wall_only() const |
|
Énumérations
enum MotionMode: 🔗
MotionMode MOTION_MODE_GROUNDED = 0
À appliquer lorsque les notions de murs, de plafond et de sol sont pertinentes. Dans ce mode, le mouvement du corps réagira aux pentes (accélération/ralentissement). Ce mode est adapté pour les jeux au sol comme les jeux de plate-forme.
MotionMode MOTION_MODE_FLOATING = 1
À appliquer quand il n'y a pas de notion de sol ou de plafond. Toutes les collisions seront rapportées comme on_wall. Dans ce mode, lorsque vous glissez, la vitesse sera toujours constante. Ce mode est adapté pour les jeux sans sol comme les jeux dans l'espace.
enum PlatformOnLeave: 🔗
PlatformOnLeave PLATFORM_ON_LEAVE_ADD_VELOCITY = 0
Ajoute la vitesse de la dernière plateforme à la vitesse velocity lorsque vous quittez une plateforme mobile.
PlatformOnLeave PLATFORM_ON_LEAVE_ADD_UPWARD_VELOCITY = 1
Ajoute la vitesse de la dernière plateforme à la vitesse velocity lorsque vous quittez une plateforme mobile, mais les mouvements descendants sont ignorés. Cela est utile pour garder la hauteur de saut complète même lorsque la plateforme descend.
PlatformOnLeave PLATFORM_ON_LEAVE_DO_NOTHING = 2
Ne fait rien quand quitte la plateforme.
Descriptions des propriétés
bool floor_block_on_wall = true 🔗
Si true, le corps ne pourra se déplacer que sur le sol. Cette option évite d'être en mesure de marcher sur les murs, elle permettra cependant de descendre en glissant sur eux.
bool floor_constant_speed = false 🔗
Si false (par défaut), le corps se déplace plus rapidement sur les pentes descendantes et ralentit sur les pentes ascendantes.
Si true, le corps se déplace toujours à la même vitesse sur le sol, peu importe la pente. Notez que vous devez utiliser floor_snap_length pour rester sur une pente descendante à vitesse constante.
float floor_max_angle = 0.7853982 🔗
Angle maximal (en radians) où une pente est toujours considérée comme un sol (ou un plafond), plutôt qu'un mur, lorsqu'on appelle move_and_slide(). La valeur par défaut est de 45 degrés.
float floor_snap_length = 0.1 🔗
Définit une distance de aimantation. Lorsque défini à une valeur différente de 0.0, le corps est maintenu attaché aux pentes lors de l'appel à move_and_slide(). Le vecteur d'aimantation est déterminé par la distance donnée le long de la direction opposée au vecteur up_direction.
Tant que le vecteur d'aimantation est en contact avec le sol et que le corps se déplace contre up_direction, le corps restera attaché à la surface. L'aimantation n'est pas appliquée si le corps se déplace le long de up_direction, ce qui signifie qu'il contient la vitesse de montée verticale, de sorte qu'il sera en mesure de se détacher du sol lors d'un saut ou lorsque le corps est poussé par quelque chose. Si vous voulez appliquer une aimantation sans tenir compte de la vitesse, utilisez apply_floor_snap().
bool floor_stop_on_slope = true 🔗
Si true, le corps ne glissera pas sur les pentes lors de l'appel à move_and_slide() lorsque le corps est debout et immobile.
Si false, le corps glissera sur les pentes du sol lorsque velocity applique une force descendante.
Nombre de fois maximal où le corps peut changer de direction avant qu'il s'arrête lors de l'appel à move_and_slide(). Doit être supérieur à zéro.
MotionMode motion_mode = 0 🔗
void set_motion_mode(value: MotionMode)
MotionMode get_motion_mode()
Définit le mode de mouvement qui définit le comportement de move_and_slide().
int platform_floor_layers = 4294967295 🔗
Les couches de collision qui seront incluses pour détecter les corps de sol qui agiront comme des plates-formes mobiles à être suivies par le CharacterBody3D. Par défaut, les corps du sol sont détectées et propagent leur vitesse.
PlatformOnLeave platform_on_leave = 0 🔗
void set_platform_on_leave(value: PlatformOnLeave)
PlatformOnLeave get_platform_on_leave()
Définit le comportement à appliquer lorsque vous quittez une plate-forme mobile. Par défaut, pour être physiquement correct, lorsque vous quittez la plateforme, sa vitesse est appliquée.
int platform_wall_layers = 0 🔗
Les couches de collision qui seront incluses pour détecter les corps de mur qui agiront comme des plates-formes mobiles à être suivies par le CharacterBody3D. Par défaut, tous les corps de murs sont ignorés.
Marge supplémentaire utilisée pour la récupération de collision lors de l'appel à move_and_slide().
Si le corps est au plus à cette distance d'un autre corps, elle les considérera comme en collision et seront repoussés avant d'exécuter le mouvement réel.
Une valeur plus élevée signifie qu'elle est plus flexible pour détecter la collision, ce qui aide à détecter constamment les murs et les sols.
Une valeur inférieure force l'algorithme de collision à utiliser une détection plus exacte, de sorte qu'il peut être utilisé dans les cas qui nécessitent spécifiquement une précision, p.ex. à très basse échelle pour éviter le jittering visible, ou pour la stabilité avec une pile de corps de personnages.
bool slide_on_ceiling = true 🔗
Si true, lors d'un saut contre le plafond, le corps glissera, si false, il sera arrêté et tombera verticalement.
Vector3 up_direction = Vector3(0, 1, 0) 🔗
Vecteur pointant vers le haut, utilisé pour déterminer ce qui est un mur et ce qui est un sol (ou un plafond) lors de l'appel à move_and_slide(). Vaut Vector3.UP par défaut. Comme le vecteur sera normalisé, il ne peut pas être égal à Vector3.ZERO, si vous voulez que toutes les collisions soient signalées comme des murs, envisagez d'utiliser MOTION_MODE_FLOATING pour motion_mode.
Vector3 velocity = Vector3(0, 0, 0) 🔗
Vecteur de vitesse actuelle (typiquement mètres par seconde), utilisé et modifié pendant les appels à move_and_slide().
Note : Une erreur courante est de définir cette propriété à la vitesse souhaitée multipliée par delta, ce qui produit un vecteur de mouvement (généralement en mètres).
float wall_min_slide_angle = 0.2617994 🔗
Angle minimum (en radians) où le corps est autorisé à glisser lorsqu'il rencontre un mur. La valeur par défaut est égale à 15 degrés. Lorsque motion_mode vaut MOTION_MODE_GROUNDED, il affecte uniquement le mouvement si floor_block_on_wall vaut true.
Descriptions des méthodes
void apply_floor_snap() 🔗
Permet d'appliquer manuellement une aimantation au sol indépendamment de la vélocité du corps. Cette fonction ne fait rien lorsque is_on_floor() renvoie true.
float get_floor_angle(up_direction: Vector3 = Vector3(0, 1, 0)) const 🔗
Renvoie l'angle de collision du sol au dernier point de collision selon la direction du haut up_direction, qui est par défaut Vector3.UP. Cette valeur est toujours positive et seulement valide après avoir appelé move_and_slide() et lorsque is_on_floor() renvoie true.
Vector3 get_floor_normal() const 🔗
Renvoie la normale de la collision du sol au dernier point de collision. Cette valeur est seulement valide après avoir appelé move_and_slide() et lorsque is_on_floor() renvoie true.
Attention : La normale de la collision n'est pas toujours identique à la normale de la surface.
Vector3 get_last_motion() const 🔗
Renvoie le dernier mouvement appliqué au CharacterBody3D lors du dernier appel à move_and_slide(). Le mouvement peut être divisé en plusieurs sous-mouvements lorsqu'un glissement se produit, et cette méthode renvoie le dernier, ce qui est utile pour récupérer la direction actuelle du mouvement.
KinematicCollision3D get_last_slide_collision() 🔗
Retourne une KinematicCollision3D si une collision s'est produite. La valeur retournée contient des informations sur la dernière collision qui s'est produite lors du dernier appel à move_and_slide(). Retourne null si aucune collision ne s'est produite. Voir aussi get_slide_collision().
Vector3 get_platform_angular_velocity() const 🔗
Renvoie la vitesse angulaire de la plate-forme au dernier point de collision. Seulement valide après avoir appelé move_and_slide().
Vector3 get_platform_velocity() const 🔗
Renvoie la vitesse linéaire de la plate-forme au dernier point de collision. Seulement valide après avoir appelé move_and_slide().
Vector3 get_position_delta() const 🔗
Renvoie le déplacement (le différentiel de position) qui s'est produit lors du dernier appel à move_and_slide().
Vector3 get_real_velocity() const 🔗
Renvoie la vitesse réelle actuelle depuis le dernier appel à move_and_slide(). Par exemple, lorsque vous grimpez sur une pente, vous vous déplacerez en diagonale même si la vitesse est horizontale. Cette méthode renvoie le mouvement diagonal, par opposition à velocity qui renvoie la vitesse demandée.
KinematicCollision3D get_slide_collision(slide_idx: int) 🔗
Renvoie un KinematicCollision3D qui contient des informations sur une collision qui s'est produite au cours du dernier appel à move_and_slide(). Comme le corps peut entrer en collision plusieurs fois pendant un seul appel à move_and_slide(), vous devez spécifier l'index de la collision dans une plage de 0 à (get_slide_collision_count() - 1). Voir aussi get_last_slide_collision().
int get_slide_collision_count() const 🔗
Renvoie le nombre de fois où le corps est entré en collision et a changé de direction durant le dernier appel à move_and_slide().
Vector3 get_wall_normal() const 🔗
Renvoie la normale de collision du mur au dernier point de collision. Seulement valable après avoir appelé move_and_slide() et lorsque is_on_wall() renvoie true.
Attention : La normale de la collision n'est pas toujours identique à la normale de la surface.
Renvoie true si le corps était entré en collision avec le plafond lors du dernier appel à move_and_slide(). Sinon, renvoie false. Le vecteur haut up_direction et l'angle maximal floor_max_angle sont utilisés pour déterminer si une surface est un "plafond" ou non.
bool is_on_ceiling_only() const 🔗
Renvoie true si le corps était entré en collision avec seulement le plafond lors du dernier appel à move_and_slide(). Sinon, renvoie false. Le vecteur haut up_direction et l'angle maximal floor_max_angle sont utilisés pour déterminer si une surface est un "plafond" ou non.
Renvoie true si le corps est entré en collision avec le sol lors du dernier appel à move_and_slide(). Sinon, renvoie false. La direction du haut up_direction et l'angle maximal floor_max_angle sont utilisés pour déterminer si une surface est un "sol" ou non.
bool is_on_floor_only() const 🔗
Renvoie true si le corps est entré en collision seulement avec le sol lors du dernier appel à move_and_slide(). Sinon, renvoie false. La direction du haut up_direction et l'angle maximal floor_max_angle sont utilisés pour déterminer si une surface est un "sol" ou non.
Renvoie true si le corps était entré en collision avec un mur lors du dernier appel à move_and_slide(). Renvoie false sinon. La direction haut up_direction et l'angle maximal floor_max_angle sont utilisés pour déterminer si une surface est un « mur » ou non.
bool is_on_wall_only() const 🔗
Renvoie true si le corps était entré seulement en collision avec un mur lors du dernier appel à move_and_slide(). Renvoie false sinon. La direction haut up_direction et l'angle maximal floor_max_angle sont utilisés pour déterminer si une surface est un « mur » ou non.
Déplace le corps selon la vitesse velocity. Si le corps entre en collision avec un autre, il glisse sur l'autre corps plutôt que de s'arrêter immédiatement. Si l'autre corps est un CharacterBody3D ou un RigidBody3D, il sera également affecté par le mouvement de l'autre corps. Vous pouvez utiliser ceci pour faire des plates-formes mobiles et tournantes, ou pour faire que des nœuds poussent d'autres nœuds.
Cette méthode doit être utilisée dans Node._physics_process() (ou dans une méthode appelée par Node._physics_process()), car elle utilise automatique la valeur delta de l'étape de physique dans son calcul. Dans le cas contraire, la simulation avancera à une vitesse incorrecte.
Modifie velocity si une collision de glissement s'est produite. Pour obtenir la dernière collision, appelez get_last_slide_collision(), pour des informations plus détaillées sur les collisions qui se sont produites, utilisez get_slide_collision().
Lorsque le corps touche une plate-forme mobile, la vitesse de la plateforme est automatiquement ajoutée au mouvement du corps. Si une collision survient en raison du mouvement de la plate-forme, elle sera toujours la première dans les collisions de glissement.
Renvoie true si le corps est entré en collision, sinon, renvoie false.