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...

RigidBody2D

Hérite de : PhysicsBody2D < CollisionObject2D < Node2D < CanvasItem < Node < Object

Hérité par : PhysicalBone2D

Un corps physique 2D qui est déplacé par une simulation physique.

Description

RigidBody2D implémente la physique 2D complète. Il ne peut pas être contrôlé directement, au lieu de cela, vous devez appliquer des forces à celui-ci (gravité, impulsions, etc.), et la simulation physique calculera le mouvement résultant, la rotation, la réaction aux collisions et effets sur d'autres corps de physique dans son chemin.

Le comportement du corps peut être ajusté par lock_rotation, freeze, et freeze_mode. En changeant diverses propriétés de l'objet, comme mass, vous pouvez contrôler comment la simulation physique agit sur lui.

Un corps rigide maintiendra toujours sa forme et sa taille, même lorsque des forces lui sont appliquées. Il est utile pour les objets qui peuvent être interagis avec dans un environnement, comme un arbre qui peut être renversé ou une pile de caisses qui peut être bousculée.

Si vous devez directement affecter le corps, préférez _integrate_forces() car il vous permet d'accéder directement à l'état physique.

Si vous devez redéfinir le comportement physique par défaut, vous pouvez écrire une fonction d'intégration des forces personnalisée. Voir custom_integrator.

Note : Changer la transformation 2D ou linear_velocity d'un RigidBody2D peut très souvent conduire à des comportements imprévisibles. Cela se produit aussi lorsqu'un RigidBody2D est le descendant d'un nœud bougeant constamment, comme un autre RigidBody2D, car cela fera que sa transformation globale sera définie chaque fois que son ancêtre se déplace.

Tutoriels

Propriétés

float	angular_damp	`0.0`
DampMode	angular_damp_mode	`0`
float	angular_velocity	`0.0`
bool	can_sleep	`true`
Vector2	center_of_mass	`Vector2(0, 0)`
CenterOfMassMode	center_of_mass_mode	`0`
Vector2	constant_force	`Vector2(0, 0)`
float	constant_torque	`0.0`
bool	contact_monitor	`false`
CCDMode	continuous_cd	`0`
bool	custom_integrator	`false`
bool	freeze	`false`
FreezeMode	freeze_mode	`0`
float	gravity_scale	`1.0`
float	inertia	`0.0`
float	linear_damp	`0.0`
DampMode	linear_damp_mode	`0`
Vector2	linear_velocity	`Vector2(0, 0)`
bool	lock_rotation	`false`
float	mass	`1.0`
int	max_contacts_reported	`0`
PhysicsMaterial	physics_material_override
bool	sleeping	`false`

Méthodes

void	_integrate_forces(state: PhysicsDirectBodyState2D) virtual
void	add_constant_central_force(force: Vector2)
void	add_constant_force(force: Vector2, position: Vector2 = Vector2(0, 0))
void	add_constant_torque(torque: float)
void	apply_central_force(force: Vector2)
void	apply_central_impulse(impulse: Vector2 = Vector2(0, 0))
void	apply_force(force: Vector2, position: Vector2 = Vector2(0, 0))
void	apply_impulse(impulse: Vector2, position: Vector2 = Vector2(0, 0))
void	apply_torque(torque: float)
void	apply_torque_impulse(torque: float)
Array[Node2D]	get_colliding_bodies() const
int	get_contact_count() const
void	set_axis_velocity(axis_velocity: Vector2)

Signaux

body_entered(body: Node) 🔗

Émis lorsqu'une collision avec un autre PhysicsBody2D or TileMap arrive. Nécessite que contact_monitor soit défini à true et que max_contacts_reported soit défini assez haut pour détecter toutes les collisions. Les TileMap sont détectées si le TileSet a des Collision Shape2Ds.

body le Node, s'il existe dans l'arbre, de l'autre PhysicsBody2D ou TileMap.

body_exited(body: Node) 🔗

Émis lorsque la collision avec un autre PhysicsBody2D or TileMap se finit. Nécessite que contact_monitor soit défini à true et que max_contacts_reported soit défini assez haut pour détecter toutes les collisions. Les TileMap sont détectées si le TileSet a des Collision Shape2Ds.

body le Node, s'il existe dans l'arbre, de l'autre PhysicsBody2D ou TileMap.

body_shape_entered(body_rid: RID, body: Node, body_shape_index: int, local_shape_index: int) 🔗

Émis quand une des Shape2D de ce RigidBody2D entre en collision avec un autre PhysicsBody2D ou d'une Shape2D d'une TileMap. Nécessite que contact_monitor soit défini à true et que max_contacts_reported soit défini assez haut pour détecter toutes les collisions. Les TileMap sont détectées si le TileSet a des Collision Shape2Ds.

body_rid le RID de l'autre PhysicsBody2D ou TileSet utilisé par le PhysicsServer2D.

body le Node, s'il existe dans l'arbre, du PhysicsBody2D ou du TileMap.

body_shape_index l'index de la Shape2D du PhysicsBody2D ou du TileMap utilisé par le PhysicsServer2D. Obtenez le nœud CollisionShape2D avec corps.shape_owner_get_owner(body.shape_find_owner(body_shape_index)).

local_shape_index l'index de la Shape2D de ce RigidBody2D utilisée par le PhysicsServer2D. Obtenez le nœud CollisionShape2D avec self.shape_owner_get_owner(self.shape_find_owner(local_shape_index)).

body_shape_exited(body_rid: RID, body: Node, body_shape_index: int, local_shape_index: int) 🔗

Émis lorsque la collision entre l'une des Shape2D de ce RigidBody2D et un autre PhysicsBody2D ou Shape2D de TileMap se termine. Nécessite que contact_monitor soit défini à true et que max_contacts_reported soit défini assez haut pour détecter toutes les collisions. Les TileMaps sont détectées si le TileSet a des Collision Shape2Ds.

body_rid le RID de l'autre PhysicsBody2D ou CollisionObject2D d'une TileSet utilisé par le PhysicsServer2D.

body le Node, s'il existe dans l'arbre, de l'autre PhysicsBody2D ou TileMap.

body_shape_index l'index de la Shape2D de l'autre PhysicsBody2D ou TileMap utilisé par le PhysicsServer2D. Obtenez le nœud CollisionShape2D avec body.shape_owner_get_owner(body.shape_find_owner(body_shape_index).

local_shape_index l'index de la Shape2D de ce RigidBody2D utilisé par le PhysicsServer2D. Obtenez le nœud CollisionShape2D avec self.shape_owner_get_owner(self.shape_find_owner(local_shape_index).

sleeping_state_changed() 🔗

Émis lorsque le moteur de physique change l'état de sommeil du corps.

Note : Changer la valeur de sleeping ne déclenchera pas ce signal. Il est seulement émis si l'état de sommeil est changé par le moteur de physique ou si emit_signal("sleeping_state_changed") est utilisé.

Énumérations

enum FreezeMode: 🔗

FreezeMode FREEZE_MODE_STATIC = 0

Mode de gel du corps statique (par défaut). Le corps n'est pas affecté par la gravité et les forces. Il ne peut être déplacé que par le code de l'utilisateur et n'entre pas en collision avec d'autres corps le long de son chemin.

FreezeMode FREEZE_MODE_KINEMATIC = 1

Mode de gel du corps cinématique. Semblable à FREEZE_MODE_STATIC, mais collisionne avec d'autres corps le long de son chemin lorsqu'il est déplacé. Utile pour un corps gelé qui doit être animé.

enum CenterOfMassMode: 🔗

CenterOfMassMode CENTER_OF_MASS_MODE_AUTO = 0

Dans ce mode, le centre de masse du corps est calculé automatiquement en fonction de ses formes. Cela suppose que les origines des formes sont aussi leur centre de masse.

CenterOfMassMode CENTER_OF_MASS_MODE_CUSTOM = 1

Dans ce mode, le centre de masse du corps est défini par center_of_mass. La valeur par défaut est à l'origine du corps.

enum DampMode: 🔗

DampMode DAMP_MODE_COMBINE = 0

Dans ce mode, la valeur d'amortissement du corps est ajoutée à toute valeur définie dans les zones ou la valeur par défaut.

DampMode DAMP_MODE_REPLACE = 1

Dans ce mode, la valeur d'amortissement du corps remplace toute valeur définie dans les zones ou la valeur par défaut.

enum CCDMode: 🔗

CCDMode CCD_MODE_DISABLED = 0

Détection de collision continue désactivée. C'est le moyen le plus rapide pour détecter les collisions de corps, mais peut manquer les petits objets en mouvement rapide.

CCDMode CCD_MODE_CAST_RAY = 1

Détection de collision continue activée par raycasting. C'est plus rapide que le shapecasting mais moins précis.

CCDMode CCD_MODE_CAST_SHAPE = 2

Détection de collisions continue activée en utilisant le shapecasting. C'est la méthode de détection de collisions continue la plus lente et la plus précise.

Descriptions des propriétés

float angular_damp = 0.0 🔗

void set_angular_damp(value: float)
float get_angular_damp()

Amortit la rotation du corps. Par défaut, le corps utilisera le paramètre de projet ProjectSettings.physics/2d/default_angular_damp ou toute redéfinition de valeur définie par une Area2D où se trouve le corps. Selon angular_damp_mode, vous pouvez définir que angular_damp soit ajouté à ou va remplacer la valeur d'amortissement du corps.

Voir ProjectSettings.physics/2d/default_angular_damp pour plus de détails sur l'amortissement.

DampMode angular_damp_mode = 0 🔗

void set_angular_damp_mode(value: DampMode)
DampMode get_angular_damp_mode()

Définit comment angular_damp est appliqué.

float angular_velocity = 0.0 🔗

void set_angular_velocity(value: float)
float get_angular_velocity()

La vitesse de rotation du corps en radians par seconde.

bool can_sleep = true 🔗

void set_can_sleep(value: bool)
bool is_able_to_sleep()

Si true, le corps peut entrer en mode sommeil lorsqu'il n'y a pas de mouvement. Voir sleeping.

Vector2 center_of_mass = Vector2(0, 0) 🔗

void set_center_of_mass(value: Vector2)
Vector2 get_center_of_mass()

Le centre de masse personnalisé du corps, relatif à la position d'origine du corps, quand center_of_mass_mode est défini à CENTER_OF_MASS_MODE_CUSTOM. C'est le point d'équilibre du corps, où les forces appliquées ne provoquent qu'une accélération linéaire. Appliquer des forces en dehors du centre de masse provoque une accélération angulaire.

Lorsque center_of_mass_mode est défini à CENTER_OF_MASS_MODE_AUTO (valeur par défaut), le centre de masse est automatiquement calculé, mais cela ne met pas à jour la valeur de center_of_mass.

CenterOfMassMode center_of_mass_mode = 0 🔗

void set_center_of_mass_mode(value: CenterOfMassMode)
CenterOfMassMode get_center_of_mass_mode()

Définit la manière dont le centre de masse du corps est défini.

Vector2 constant_force = Vector2(0, 0) 🔗

void set_constant_force(value: Vector2)
Vector2 get_constant_force()

Les forces positionnelles constantes totales du corps appliquées lors de chaque mise à jour de physique.

Voir add_constant_force() et add_constant_central_force().

float constant_torque = 0.0 🔗

void set_constant_torque(value: float)
float get_constant_torque()

Les forces de rotation constantes totales du corps appliquées lors de chaque mise à jour de physique.

Voir add_constant_torque().

bool contact_monitor = false 🔗

void set_contact_monitor(value: bool)
bool is_contact_monitor_enabled()

Si true, le RigidBody2D émet des signaux lorsqu'il entre en collision avec un autre corps.

Note : Par défaut, les contacts maximaux indiqués sont fixés à 0, ce qui signifie que rien ne sera enregistré, voir max_contacts_reported.

CCDMode continuous_cd = 0 🔗

void set_continuous_collision_detection_mode(value: CCDMode)
CCDMode get_continuous_collision_detection_mode()

Mode de détection de collision continu.

La détection de collision continue tente de prédire où un corps en mouvement va entrer en collision au lieu de le déplacer et de corriger son mouvement après la collision. La détection de collision continue est plus lente, mais plus précise et manque moins de collisions avec de petits objets en mouvement rapide. Des méthodes de raycasting et de shapecasting sont disponibles.

bool custom_integrator = false 🔗

void set_use_custom_integrator(value: bool)
bool is_using_custom_integrator()

Si true, l'intégration des forces standardes (comme la gravité ou l'amortissement) sera désactivée pour ce corps. En dehors de la réponse à une collision, le corps ne se déplacera que selon la méthode _integrate_forces(), si cette méthode virtuelle est redéfinie.

Définir cette propriété appellera la méthode PhysicsServer2D.body_set_omit_force_integration() en interne.

bool freeze = false 🔗

void set_freeze_enabled(value: bool)
bool is_freeze_enabled()

If true, the body is frozen. Gravity and forces are not applied anymore.

See freeze_mode to set the body's behavior when frozen.

Note: For a body that is always frozen, use StaticBody2D or AnimatableBody2D instead.

FreezeMode freeze_mode = 0 🔗

void set_freeze_mode(value: FreezeMode)
FreezeMode get_freeze_mode()

The body's freeze mode. Determines the body's behavior when freeze is true.

Note: For a body that is always frozen, use StaticBody2D or AnimatableBody2D instead.

float gravity_scale = 1.0 🔗

void set_gravity_scale(value: float)
float get_gravity_scale()

Multiplie la gravité appliquée au corps. La gravité du corps est calculée à partir du paramètre du projet ProjectSettings.physics/2d/default_gravity et/ou de tout vecteur de gravité supplémentaire appliqué par des Area2Ds.

float inertia = 0.0 🔗

void set_inertia(value: float)
float get_inertia()

Le moment d'inertie du corps. C'est comme la masse, mais pour la rotation : il détermine combien de couple il faut pour tourner le corps. Le moment d'inertie est généralement calculé automatiquement à partir de la masse et des formes, mais cette propriété vous permet de définir une valeur personnalisée.

Si elle est définie à 0, l'inertie est automatiquement calculée (valeur par défaut).

Note : Cette valeur ne change pas lorsque l'inertie est automatiquement calculée. Utilisez PhysicsServer2D pour obtenir l'inertie calculée.

@onready var balle = $Balle

func obtenir_inertie_balle():
    return 1.0 / PhysicsServer2D.body_get_direct_state(ball.get_rid()).inverse_inertia

private RigidBody2D _balle;

public override void _Ready()
{
    _balle = GetNode<RigidBody2D>("Balle");
}

private float ObtenirInertieBalle()
{
    return 1.0f / PhysicsServer2D.BodyGetDirectState(_ball.GetRid()).InverseInertia;
}

float linear_damp = 0.0 🔗

void set_linear_damp(value: float)
float get_linear_damp()

Amortit le mouvement du corps. Par défaut, le corps utilisera le paramètreProjectSettings.physics/2d/default_linear_damp ou toute redéfinition de valeur définie par une Area2D où se trouve le corps. Selon linear_damp_mode, vous pouvez définir que linear_damp soit ajouté à ou va remplacer la valeur d'amortissement du corps.

Voir ProjectSettings.physics/2d/default_linear_damp pour plus de détails sur l'amortissement.

DampMode linear_damp_mode = 0 🔗

void set_linear_damp_mode(value: DampMode)
DampMode get_linear_damp_mode()

Définit comment linear_damp est appliqué.

Vector2 linear_velocity = Vector2(0, 0) 🔗

void set_linear_velocity(value: Vector2)
Vector2 get_linear_velocity()

La vitesse linéaire du corps en pixels par seconde. Peut être utilisé sporadiquement, mais ne pas définir à chaque trame, car la physique peut s'exécuter dans un autre fil d'exécution et s'exécute à une granularité différente. Utilisez _integrate_forces() comme boucle de traitement pour un contrôle précis de l'état du corps.

bool lock_rotation = false 🔗

void set_lock_rotation_enabled(value: bool)
bool is_lock_rotation_enabled()

Si true, le corps ne peut pas pivoter. La gravité et les forces n'appliquent qu'un mouvement linéaire.

float mass = 1.0 🔗

void set_mass(value: float)
float get_mass()

La masse du corps.

int max_contacts_reported = 0 🔗

void set_max_contacts_reported(value: int)
int get_max_contacts_reported()

Le nombre maximal de contacts qui seront enregistrés. Nécessite une valeur supérieure à 0 et contact_monitor défini à true pour commencer à enregistrer les contacts. Utilisez get_contact_count() pour récupérer le compte ou get_colliding_bodies() pour récupérer les corps qui sont entrés en collision avec.

Note : Le nombre de contacts est différent du nombre de collisions. Les collisions entre des bords parallèles se traduiront par deux contacts (un à chaque extrémité), et les collisions entre les faces parallèles se traduiront par quatre contacts (un à chaque coin).

PhysicsMaterial physics_material_override 🔗

void set_physics_material_override(value: PhysicsMaterial)
PhysicsMaterial get_physics_material_override()

Le matériau physique de remplacement pour le corps.

Si un matériau est affecté à cette propriété, il sera utilisé au lieu de tout autre matériau physique, tel qu'un matériau hérité.

bool sleeping = false 🔗

void set_sleeping(value: bool)
bool is_sleeping()

Si true, le corps ne bougera pas et ne calculera pas les forces jusqu'à ce qu'un autre corps le réveille à cause, par exemple, d'une collision, ou en utilisant les méthodes apply_impulse() ou apply_force().

Descriptions des méthodes

void _integrate_forces(state: PhysicsDirectBodyState2D) virtual 🔗

Appelé pendant le traitement physique, vous permettant de lire et de modifier en toute sécurité l'état de simulation de l'objet. Par défaut, elle est appelée avant l'intégration des forces standardes, mais la propriété custom_integrator vous permet de désactiver l'intégration des forces standardes et de faire une intégration des forces entièrement personnalisée pour un corps.

void add_constant_central_force(force: Vector2) 🔗

Ajoute une force directionnelle constante n'affectant pas la rotation, qui continue d'être appliquée au cours du temps jusqu'à ce qu'elle soit enlevée avec constant_force = Vector2(0, 0).

Ceci est équivalent à utiliser add_constant_force() au centre de masse du corps.

void add_constant_force(force: Vector2, position: Vector2 = Vector2(0, 0)) 🔗

Ajoute une force positionnée constante au corps qui continue d'être appliquée au cours du temps jusqu'à ce qu'elle soit enlevée avec constant_force = Vector2(0, 0).

position est le décalage depuis l'origine du corps dans les coordonnées globales.

void add_constant_torque(torque: float) 🔗

Ajoute une force de rotation constante n'affectant pas la positon, qui continue d'être appliquée au cours du temps jusqu'à ce qu'elle soit enlevée avec constant_torque = 0.

void apply_central_force(force: Vector2) 🔗

Applique une force directionnelle n'affectant pas la rotation. Une force est dépendante du temps et destinée à être appliquée chaque mise à jour physique.

Ceci est équivalent à utiliser apply_force() au centre de masse du corps.

void apply_central_impulse(impulse: Vector2 = Vector2(0, 0)) 🔗

Applique une impulsion directionnelle n'affectant pas la rotation.

Une impulsion est indépendante du temps ! Appliquer une impulsion à chaque trame entraînerait une force dépendante du taux de rafraîchissement. Pour cette raison, elle ne devrait être utilisée que pour simuler des impacts ponctuels (utilisez les fonctions "_force" sinon).

Ceci est équivalent à utiliser apply_impulse() au centre de masse du corps.

void apply_force(force: Vector2, position: Vector2 = Vector2(0, 0)) 🔗

Applique une force positionnée au corps. Une force est dépendante du temps et destinée à être appliquée à chaque mise à jour physique.

position est le décalage depuis l'origine du corps dans les coordonnées globales.

void apply_impulse(impulse: Vector2, position: Vector2 = Vector2(0, 0)) 🔗

Applique une impulsion positionnée au corps.

Une impulsion est indépendante du temps ! Appliquer une impulsion à chaque trame entraînerait une force dépendante du taux de rafraîchissement. Pour cette raison, elle ne devrait être utilisée que pour simuler des impacts ponctuels (utilisez les fonctions "_force" sinon).

position est le décalage depuis l'origine du corps dans les coordonnées globales.

void apply_torque(torque: float) 🔗

Applique une force de rotation sans affecter la position. Une force est dépendante du temps et destinée à être appliquée à chaque mise à jour physique.

Note : L'inertie (inertia) est nécessaire pour que cela fonctionne. Pour avoir de l’inertie (inertia), un CollisionShape2D actif doit être un enfant du nœud, ou vous pouvez définir manuellement inertia.

void apply_torque_impulse(torque: float) 🔗

Applique une impulsion de rotation au corps sans affecter la position.

Une impulsion est indépendante du temps ! Appliquer une impulsion à chaque trame entraînerait une force dépendante du taux de rafraîchissement. Pour cette raison, elle ne devrait être utilisée que pour simuler des impacts ponctuels (utilisez les fonctions "_force" sinon).

Note : L'inertie (inertia) est nécessaire pour que cela fonctionne. Pour avoir de l’inertie (inertia), un CollisionShape2D actif doit être un enfant du nœud, ou vous pouvez définir manuellement inertia.

Array[Node2D] get_colliding_bodies() const 🔗

Renvoie une liste des corps en collision avec celui-ci. Nécessite contact_monitor d'être défini à true et max_contacts_reported d'être défini assez haut pour détecter toutes les collisions.

Note : Le résultat de ce test n'est pas immédiat après le déplacement des objets. Pour la performance, la liste des collisions est mise à jour une fois par trame et avant l'étape de physique. Envisagez d'utiliser des signaux à la place.

int get_contact_count() const 🔗

Renvoie le nombre de contacts que ce corps a avec d'autres corps. Par défaut, cela renvoie 0 sauf si les corps sont configurés pour surveiller les contacts (voir contact_monitor).

Note : Pour récupérer les corps en collision, utilisez get_colliding_bodies().

void set_axis_velocity(axis_velocity: Vector2) 🔗

Définit la vélocité du corps sur l'axe donné. La vélocité dans l'axe du vecteur donné sera définie comme la longueur du vecteur donné. Utile pour le comportement lors d'un saut.