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
Eredita: PhysicsBody2D < CollisionObject2D < Node2D < CanvasItem < Node < Object
Ereditato da: PhysicalBone2D
Un corpo fisico 2D che viene spostato da una simulazione fisica.
Descrizione
RigidBody2D implementa la fisica 2D completa. Non può essere controllato direttamente, ma è necessario applicargli delle forze (gravità, impulsi, ecc.) e la simulazione fisica calcolerà il movimento risultante, la rotazione, reagirà alle collisioni e influenzerà altri corpi fisici sul suo percorso.
Il comportamento del corpo può essere regolato tramite lock_rotation, freeze e freeze_mode. Modificando varie proprietà dell'oggetto, come mass, puoi controllare come la simulazione fisica agisce su di esso.
Un corpo rigido manterrà sempre la sua forma e dimensione, anche quando gli vengono applicate delle forze. È utile per oggetti con cui è possibile interagire in un ambiente, come un albero che può essere abbattuto o una pila di casse che può essere spinta.
Se devi influenzare direttamente il corpo, preferisci implementare _integrate_forces() in quanto ti consente di accedere direttamente allo stato fisico.
Se hai bisogno di sovrascrivere il comportamento fisico predefinito, puoi scrivere una funzione di integrazione delle forze personalizzata. Vedi custom_integrator.
Nota: Cambiare la trasformazione 2D o linear_velocity di un RigidBody2D molto spesso può portare ad alcuni comportamenti imprevedibili. Questo accade anche quando un RigidBody2D è il discendente di un nodo in continuo movimento, come un altro RigidBody2D, poiché ciò causerà l'impostazione della sua trasformazione globale ogni volta che il suo antenato si muove.
Tutorial
Proprietà
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
Metodi
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) |
get_colliding_bodies() const |
|
get_contact_count() const |
|
void |
set_axis_velocity(axis_velocity: Vector2) |
Segnali
Emesso quando avviene una collisione con un altro PhysicsBody2D o TileMap. Richiede che contact_monitor sia impostato su true e che max_contacts_reported sia impostato su un valore alto abbastanza da rilevare tutte le collisioni. Le TileMap sono rilevate se il TileSet ha contiene collisioni Shape2D.
body è il Node, se esiste nell'albero, dell'altro PhysicsBody2D o TileMap.
Emesso quando termina una collisione con un altro PhysicsBody2D o TileMap. Richiede che contact_monitor sia impostato su true e che max_contacts_reported sia impostato su un valore alto abbastanza da rilevare tutte le collisioni. Le TileMap sono rilevate se il TileSet ha contiene collisioni Shape2D.
body è il Node, se esiste nell'albero, dell'altro PhysicsBody2D o TileMap.
body_shape_entered(body_rid: RID, body: Node, body_shape_index: int, local_shape_index: int) 🔗
Emesso quando uno degli Shape2D di questo RigidBody2D entra in collisione con un altro Shape2D di PhysicsBody2D o TileMap. Richiede che contact_monitor sia impostato su true e che max_contacts_reported sia impostato su un valore alto abbastanza da rilevare tutte le collisioni. I TileMap sono rilevati se il TileSet contiene collisioni Shape2D.
body_rid è il RID del CollisionObject2D dell'altro PhysicsBody2D o TileSet utilizzato dal PhysicsServer2D.
body è il Node, se presente nell'albero, dell'altro PhysicsBody2D o TileMap.
body_shape_index l'indice dello Shape2D dell'altro PhysicsBody2D o TileMap utilizzato dal PhysicsServer2D. Ottieni il nodo CollisionShape2D con body.shape_owner_get_owner(body.shape_find_owner(body_shape_index)).
local_shape_index è l'indice dello Shape2D di questo RigidBody2D utilizzato dal PhysicsServer2D. Ottieni il nodo CollisionShape2D con 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) 🔗
Emesso quando termina la collisione tra uno degli Shape2D di questo RigidBody2D e un altro Shape2D di PhysicsBody2D o TileMap. Richiede che contact_monitor sia impostato su true e che max_contacts_reported sia impostato su un valore alto abbastanza da rilevare tutte le collisioni. I TileMap sono rilevati se il TileSet contiene collisioni Shape2D.
body_rid è il RID del CollisionObject2D dell'altro PhysicsBody2D o TileSet utilizzato dal PhysicsServer2D.
body è il Node, se presente nell'albero, dell'altro PhysicsBody2D o TileMap.
body_shape_index l'indice dello Shape2D dell'altro PhysicsBody2D o TileMap utilizzato dal PhysicsServer2D. Ottieni il nodo CollisionShape2D con body.shape_owner_get_owner(body.shape_find_owner(body_shape_index)).
local_shape_index è l'indice dello Shape2D di questo RigidBody2D utilizzato dal PhysicsServer2D. Ottieni il nodo CollisionShape2D con self.shape_owner_get_owner(self.shape_find_owner(local_shape_index)).
sleeping_state_changed() 🔗
Emesso quando il motore fisico cambia lo stato di riposo del corpo.
Nota: La modifica del valore sleeping non attiverà questo segnale. Viene emesso solo se lo stato di riposo viene modificato dal motore fisico o se viene utilizzato emit_signal("sleeping_state_changed").
Enumerazioni
enum FreezeMode: 🔗
FreezeMode FREEZE_MODE_STATIC = 0
Modalità di congelamento di corpo statico (predefinita). Il corpo non è influenzato dalla gravità e dalle forze. Può essere spostato solo tramite codice utente e non entra in collisione con altri corpi lungo il suo percorso.
FreezeMode FREEZE_MODE_KINEMATIC = 1
Modalità di congelamento di corpo cinematico. Simile a FREEZE_MODE_STATIC, ma si scontra con altri corpi lungo il suo percorso quando viene spostato. Utile per un corpo congelato che deve essere animato.
enum CenterOfMassMode: 🔗
CenterOfMassMode CENTER_OF_MASS_MODE_AUTO = 0
In questa modalità, il centro di massa del corpo viene calcolato automaticamente in base alle sue forme. Ciò presuppone che le origini delle forme siano anche il loro centro di massa.
CenterOfMassMode CENTER_OF_MASS_MODE_CUSTOM = 1
In questa modalità, il centro di massa del corpo è impostato tramite center_of_mass. Il valore predefinito è la posizione di origine del corpo.
enum DampMode: 🔗
DampMode DAMP_MODE_COMBINE = 0
In questa modalità, il valore di smorzamento del corpo è aggiunto a qualsiasi valore impostato nelle aree o al valore predefinito.
DampMode DAMP_MODE_REPLACE = 1
In questa modalità, il valore di smorzamento del corpo sostituisce qualsiasi valore impostato nelle aree o il valore predefinito.
enum CCDMode: 🔗
CCDMode CCD_MODE_DISABLED = 0
Rilevamento continuo delle collisioni disabilitato. Questo è il modo più rapido per rilevare le collisioni tra corpi, ma potrebbe non rilevare oggetti piccoli e in rapido movimento.
CCDMode CCD_MODE_CAST_RAY = 1
Rilevamento continuo delle collisioni abilitato tramite proiezione di raggi. È più veloce della proiezione di forme ma meno preciso.
CCDMode CCD_MODE_CAST_SHAPE = 2
Rilevamento continuo delle collisioni abilitato tramite proiezione di forme. Questo è il metodo di rilevamento più lento e il più preciso.
Descrizioni delle proprietà
Smorza la rotazione del corpo. Come predefinito, il corpo utilizzerà impostazione del progetto ProjectSettings.physics/2d/default_angular_damp, o un valore sostitutivo impostato da un'Area2D in cui si trova il corpo. A seconda di angular_damp_mode, è possibile impostare angular_damp in modo che sia aggiunto o sostituito al valore di smorzamento del corpo.
Vedi ProjectSettings.physics/2d/default_angular_damp per ulteriori dettagli sullo smorzamento.
DampMode angular_damp_mode = 0 🔗
Definisce come angular_damp è applicato.
float angular_velocity = 0.0 🔗
La velocità di rotazione del corpo in radianti al secondo.
Se true, il corpo può entrare in modalità di riposo quando non c'è movimento. Vedi sleeping.
Vector2 center_of_mass = Vector2(0, 0) 🔗
Il centro di massa personalizzato del corpo, relativo alla posizione di origine del corpo, quando center_of_mass_mode è impostato su CENTER_OF_MASS_MODE_CUSTOM. Questo è il punto di equilibrio del corpo, dove le forze applicate provocano solo accelerazione lineare. Le forze applicate all'esterno del centro di massa provocano accelerazione angolare.
Quando center_of_mass_mode è impostato su CENTER_OF_MASS_MODE_AUTO (valore predefinito), il centro di massa è calcolato automaticamente, ma ciò non aggiorna il valore di center_of_mass.
CenterOfMassMode center_of_mass_mode = 0 🔗
void set_center_of_mass_mode(value: CenterOfMassMode)
CenterOfMassMode get_center_of_mass_mode()
Definisce il modo in cui è impostato il centro di massa del corpo.
Vector2 constant_force = Vector2(0, 0) 🔗
Le forze posizionali costanti totali del corpo applicate durante ogni aggiornamento della fisica.
Vedi add_constant_force() e add_constant_central_force().
Le forze rotazionali costanti totali del corpo applicate durante ogni aggiornamento della fisica.
Vedi add_constant_torque().
bool contact_monitor = false 🔗
Se true, il RigidBody2D emetterà segnali quando entra in collisione con un altro corpo.
Nota: Per impostazione predefinita, il numero massimo di contatti riportati è impostato su 0, il che significa che non sarà registrato nulla, vedi max_contacts_reported.
void set_continuous_collision_detection_mode(value: CCDMode)
CCDMode get_continuous_collision_detection_mode()
La modalità di rilevamento continuo delle collisioni.
Il rilevamento continuo delle collisioni cerca di prevedere dove un corpo in movimento entrerà in collisione, invece di spostarlo e correggerne il movimento in caso di collisione. Il rilevamento continuo delle collisioni è più lento, ma più preciso e manca meno collisioni con oggetti piccoli e in rapido movimento. Sono disponibili i metodi di proiezione di raggi e di forme.
bool custom_integrator = false 🔗
Se true, l'integrazione predefinita delle forze (come gravità o smorzamento) sarà disabilitata per questo corpo. A parte la risposta alla collisione, il corpo si muoverà solo come determinato dal metodo _integrate_forces(), se tale metodo virtuale è sovrascritto.
Impostando questa proprietà sarà chiamato internamente il metodo PhysicsServer2D.body_set_omit_force_integration().
Se true, il corpo è congelato. La gravità e altre forze non sono più applicate.
Vedi freeze_mode per impostare il comportamento del corpo quando è congelato.
Note: Per un corpo che è sempre congelato, usa invece StaticBody2D o AnimatableBody2D.
FreezeMode freeze_mode = 0 🔗
void set_freeze_mode(value: FreezeMode)
FreezeMode get_freeze_mode()
La modalità di congelamento del corpo. Determina il comportamento del corpo quando freeze è true.
Note: Per un corpo che è sempre congelato, usa invece StaticBody2D o AnimatableBody2D.
Moltiplica la gravità applicata al corpo. La gravità del corpo è calcolata dall'impostazione del progetto ProjectSettings.physics/2d/default_gravity e/o da qualsiasi vettore di gravità aggiuntivo applicato dagli Area2D.
Il momento di inerzia del corpo. È come la massa, ma per la rotazione: determina la quantità di coppia necessaria per ruotare il corpo. Il momento di inerzia è solitamente calcolato automaticamente dalla massa e dalle forme, ma questa proprietà consente di impostare un valore personalizzato.
Se impostato su 0, l'inerzia viene calcolata automaticamente (valore predefinito).
Nota: Questo valore non cambia quando l'inerzia viene calcolata automaticamente. Usa il PhysicsServer2D per ottenere l'inerzia calcolata.
@onready var ball = $Ball
func get_ball_inertia():
return 1.0 / PhysicsServer2D.body_get_direct_state(ball.get_rid()).inverse_inertia
private RigidBody2D _ball;
public override void _Ready()
{
_ball = GetNode<RigidBody2D>("Ball");
}
private float GetBallInertia()
{
return 1.0f / PhysicsServer2D.BodyGetDirectState(_ball.GetRid()).InverseInertia;
}
Smorza il movimento del corpo. Come predefinito, il corpo utilizzerà l'impostazione ProjectSettings.physics/2d/default_linear_damp o qualsiasi valore di sostituzione impostato da un'Area2D in cui si trova il corpo. A seconda di linear_damp_mode, è possibile impostare linear_damp in modo che sia aggiunto o sostituito al valore di smorzamento del corpo.
Consulta ProjectSettings.physics/2d/default_linear_damp per ulteriori dettagli sullo smorzamento.
DampMode linear_damp_mode = 0 🔗
Definisce come linear_damp è applicato.
Vector2 linear_velocity = Vector2(0, 0) 🔗
La velocità lineare del corpo in pixel al secondo. Può essere usata sporadicamente, ma non impostarla per ogni frame, perché la fisica potrebbe essere eseguita in un altro thread e funzionare a una granularità diversa. Usa _integrate_forces() come ciclo di processo per un controllo preciso dello stato del corpo.
Se true, il corpo non può ruotare. La gravità e le forze applicano solo un movimento lineare.
La massa del corpo.
int max_contacts_reported = 0 🔗
Il numero massimo di contatti che saranno registrati. Richiede un valore maggiore di 0 e contact_monitor impostato su true per iniziare a registrare i contatti. Usa get_contact_count() per recuperare il conteggio o get_colliding_bodies() per recuperare i corpi con cui si è verificata una collisione.
Nota: Il numero di contatti è diverso dal numero di collisioni. Le collisioni tra bordi paralleli risulteranno in due contatti (uno a ciascuna estremità) e le collisioni tra facce parallele risulteranno in quattro contatti (uno a ciascun angolo).
PhysicsMaterial physics_material_override 🔗
void set_physics_material_override(value: PhysicsMaterial)
PhysicsMaterial get_physics_material_override()
La sostituzione del materiale di fisica per il corpo.
Se a questa proprietà è assegnato un materiale, sarà utilizzato al posto di qualsiasi altro materiale di fisica, come ad esempio uno ereditato.
Se true, il corpo non si muoverà e non calcolerà le forze finché non sarà riattivato da un altro corpo, ad esempio tramite una collisione, o utilizzando i metodi apply_impulse() o apply_force().
Descrizioni dei metodi
void _integrate_forces(state: PhysicsDirectBodyState2D) virtual 🔗
Chiamato durante l'elaborazione di fisica, consente di leggere e modificare in modo sicuro lo stato di simulazione per l'oggetto. Per impostazione predefinita, viene chiamato prima dell'integrazione predefinita delle forze, ma la proprietà custom_integrator consente di disabilitare l'integrazione delle forze predefinita e di eseguire un'integrazione delle forze completamente personalizzata per un corpo.
void add_constant_central_force(force: Vector2) 🔗
Aggiunge una forza direzionale costante senza influenzare la rotazione che continua a essere applicata nel tempo finché non viene cancellata con constant_force = Vector2(0, 0).
Ciò equivale a usare add_constant_force() al centro di massa del corpo.
void add_constant_force(force: Vector2, position: Vector2 = Vector2(0, 0)) 🔗
Aggiunge una forza posizionata costante senza influenzare la rotazione che continua a essere applicata nel tempo finché non viene cancellata con constant_force = Vector2(0, 0).
position è lo scostamento dall'origine del corpo in coordinate globali.
void add_constant_torque(torque: float) 🔗
Aggiunge una forza rotazionale costante senza influenzare la posizione che continua a essere applicata nel tempo finché non viene cancellata con constant_torque = 0.
void apply_central_force(force: Vector2) 🔗
Applica una forza direzionale senza influenzare la rotazione. Una forza è dipendente dal tempo e pensata per essere applicata a ogni aggiornamento della fisica
Ciò equivale a usare apply_force() al centro di massa del corpo.
void apply_central_impulse(impulse: Vector2 = Vector2(0, 0)) 🔗
Applica un impulso direzionale senza influenzare la rotazione.
Un impulso è indipendente dal tempo! Applicare un impulso a ogni frame risulterebbe in una forza dipendente dal frame rate. Per questo motivo, dovrebbe essere utilizzato solo quando si simulano impatti singoli (altrimenti, utilizza le funzioni "_force").
Ciò equivale a usare apply_impulse() al centro di massa del corpo.
void apply_force(force: Vector2, position: Vector2 = Vector2(0, 0)) 🔗
Applica una forza posizionata al corpo. Una forza è dipendente dal tempo e deve essere applicata a ogni aggiornamento della fisica.
position è lo scostamento dall'origine del corpo in coordinate globali.
void apply_impulse(impulse: Vector2, position: Vector2 = Vector2(0, 0)) 🔗
Applica un impulso posizionato al corpo.
Un impulso è indipendente dal tempo! Applicare un impulso a ogni frame risulterebbe in una forza dipendente dal frame rate. Per questo motivo, dovrebbe essere utilizzato solo quando si simulano impatti singoli (altrimenti, utilizza le funzioni "_force").
position è lo scostamento dall'origine del corpo in coordinate globali.
void apply_torque(torque: float) 🔗
Applica una forza rotazionale senza influenzare la posizione. Una forza è dipendente dal tempo e deve essere applicata a ogni aggiornamento della fisica.
Nota: inertia è necessaria affinché ciò funzioni. Per avere inertia, un CollisionShape2D attivo deve essere un figlio del nodo, oppure puoi impostare manualmente inertia.
void apply_torque_impulse(torque: float) 🔗
Applica un impulso rotazionale al corpo senza influenzare la posizione.
Un impulso è indipendente dal tempo! Applicare un impulso a ogni frame risulterebbe in una forza dipendente dal frame rate. Per questo motivo, dovrebbe essere utilizzato solo quando si simulano impatti una sola volta (altrimenti, usa le funzioni "_force").
Nota: inertia è necessaria affinché ciò funzioni. Per avere inertia, un CollisionShape2D attivo deve essere un figlio del nodo, oppure puoi impostare manualmente inertia.
Array[Node2D] get_colliding_bodies() const 🔗
Restituisce una lista dei corpi in collisione con questo corpo. Richiede che contact_monitor sia impostato su true e che max_contacts_reported sia impostato su un valore alto abbastanza da rilevare tutte le collisioni.
Nota: Il risultato di questo test non è immediato dopo aver spostato gli oggetti. Per le prestazioni, la lista delle collisioni è aggiornata una volta per frame e prima del passaggio di fisica. Si consiglia invece di usare i segnali.
int get_contact_count() const 🔗
Restituisce il numero di contatti che questo corpo ha con altri corpi. Per impostazione predefinita, restituisce 0 a meno che i corpi non siano configurati per monitorare i contatti (vedi contact_monitor).
Nota: Per recuperare i corpi in collisione, usa get_colliding_bodies().
void set_axis_velocity(axis_velocity: Vector2) 🔗
Imposta la velocità del corpo sull'asse fornito. La velocità nell'asse vettoriale fornito sarà impostata come la lunghezza vettoriale fornita. Ciò è utile per un comportamento di salto.