godotengine/godot-docs-l10n
1
0
Fork 0
mirror of https://github.com/godotengine/godot-docs-l10n.git synced 2025-12-31 09:49:22 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
4.x
godot-docs-l10n/classes/it/class_physicsserver2d.rst
Rémi Verschelde b20bcbb88b Sync classref with 4.5 branch
2025-09-30 13:31:55 +02:00

2636 lines
195 KiB
ReStructuredText
Raw Permalink Blame History

:github_url: hide
.. _class_PhysicsServer2D:
PhysicsServer2D
===============
**Eredita:** :ref:`Object<class_Object>`
**Ereditato da:** :ref:`PhysicsServer2DExtension<class_PhysicsServer2DExtension>`
Un'interfaccia server per l'accesso di basso livello alla fisica 2D.
.. rst-class:: classref-introduction-group
Descrizione
----------------------
PhysicsServer2D è il server responsabile di tutta la fisica 2D. Può creare e manipolare direttamente tutti gli oggetti fisici:
- Uno *spazio* è un mondo autonomo per una simulazione fisica. Contiene corpi, aree e giunti. Il suo stato può essere interrogato per informazioni sulle collisioni e le intersezioni. Inoltre, è possibile modificare diversi parametri della simulazione.
- Una *forma* è una forma geometrica come una sfera, un rettangolo, una capsula o un poligono. Può essere utilizzata per rilevare le collisioni aggiungendola a un corpo/area, possibilmente con un'ulteriore trasformazione relativa all'origine del corpo/area. Più forme (trasformate) possono essere aggiunte ai corpi/aree e una singola forma può essere aggiunta più volte a corpi/aree con diverse trasformazioni locali.
- Un *corpo* è un oggetto fisico che può essere in modalità statica, cinematica o rigida. Il suo stato (come posizione e velocità) può essere interrogato e aggiornato. È possibile impostare un callback di integrazione della forza per personalizzare la fisica del corpo.
- Un'*area* è una regione nello spazio che può essere utilizzata per rilevare i corpi e le aree che entrano ed escono da essa. È possibile impostare un callback di monitoraggio dei corpi per segnalare le forme dei corpi in entrata/uscita e, allo stesso modo per le forme di altre aree. La gravità e lo smorzamento possono essere ignorati all'interno dell'area impostando i parametri dell'area.
- Un *giunto* è un vincolo, tra due corpi o su un corpo, rispetto a un punto. È possibile regolare i parametri come il bias del giunto e la lunghezza di riposo di un giunto a molla.
Gli oggetti fisici in **PhysicsServer2D** possono essere creati e manipolati in modo indipendente; non devono essere associati ai nodi nell'albero di scene.
\ **Nota:** Tutti i nodi fisici 2D utilizzano internamente il server di fisica. L'aggiunta di un nodo fisico all'albero di scene causerà la creazione di un oggetto fisico corrispondente nel server di fisica. Un nodo corpo rigido registra un callback che aggiorna la trasformazione del nodo con la trasformazione del rispettivo oggetto corpo nel server di fisica (ad ogni aggiornamento della fisica). Un nodo area registra un callback per informare il nodo area sulle sovrapposizioni con il rispettivo oggetto area nel server di fisica. Il nodo raycast interroga lo stato diretto dello spazio rilevante nel server di fisica.
.. rst-class:: classref-reftable-group
Metodi
------------
.. table::
:widths: auto
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`area_add_shape<class_PhysicsServer2D_method_area_add_shape>`\ (\ area\: :ref:`RID<class_RID>`, shape\: :ref:`RID<class_RID>`, transform\: :ref:`Transform2D<class_Transform2D>` = Transform2D(1, 0, 0, 1, 0, 0), disabled\: :ref:`bool<class_bool>` = false\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`area_attach_canvas_instance_id<class_PhysicsServer2D_method_area_attach_canvas_instance_id>`\ (\ area\: :ref:`RID<class_RID>`, id\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`area_attach_object_instance_id<class_PhysicsServer2D_method_area_attach_object_instance_id>`\ (\ area\: :ref:`RID<class_RID>`, id\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`area_clear_shapes<class_PhysicsServer2D_method_area_clear_shapes>`\ (\ area\: :ref:`RID<class_RID>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`area_create<class_PhysicsServer2D_method_area_create>`\ (\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`area_get_canvas_instance_id<class_PhysicsServer2D_method_area_get_canvas_instance_id>`\ (\ area\: :ref:`RID<class_RID>`\ ) |const| |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`area_get_collision_layer<class_PhysicsServer2D_method_area_get_collision_layer>`\ (\ area\: :ref:`RID<class_RID>`\ ) |const| |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`area_get_collision_mask<class_PhysicsServer2D_method_area_get_collision_mask>`\ (\ area\: :ref:`RID<class_RID>`\ ) |const| |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`area_get_object_instance_id<class_PhysicsServer2D_method_area_get_object_instance_id>`\ (\ area\: :ref:`RID<class_RID>`\ ) |const| |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Variant<class_Variant>` | :ref:`area_get_param<class_PhysicsServer2D_method_area_get_param>`\ (\ area\: :ref:`RID<class_RID>`, param\: :ref:`AreaParameter<enum_PhysicsServer2D_AreaParameter>`\ ) |const| |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`area_get_shape<class_PhysicsServer2D_method_area_get_shape>`\ (\ area\: :ref:`RID<class_RID>`, shape_idx\: :ref:`int<class_int>`\ ) |const| |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`area_get_shape_count<class_PhysicsServer2D_method_area_get_shape_count>`\ (\ area\: :ref:`RID<class_RID>`\ ) |const| |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Transform2D<class_Transform2D>` | :ref:`area_get_shape_transform<class_PhysicsServer2D_method_area_get_shape_transform>`\ (\ area\: :ref:`RID<class_RID>`, shape_idx\: :ref:`int<class_int>`\ ) |const| |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`area_get_space<class_PhysicsServer2D_method_area_get_space>`\ (\ area\: :ref:`RID<class_RID>`\ ) |const| |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Transform2D<class_Transform2D>` | :ref:`area_get_transform<class_PhysicsServer2D_method_area_get_transform>`\ (\ area\: :ref:`RID<class_RID>`\ ) |const| |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`area_remove_shape<class_PhysicsServer2D_method_area_remove_shape>`\ (\ area\: :ref:`RID<class_RID>`, shape_idx\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`area_set_area_monitor_callback<class_PhysicsServer2D_method_area_set_area_monitor_callback>`\ (\ area\: :ref:`RID<class_RID>`, callback\: :ref:`Callable<class_Callable>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`area_set_collision_layer<class_PhysicsServer2D_method_area_set_collision_layer>`\ (\ area\: :ref:`RID<class_RID>`, layer\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`area_set_collision_mask<class_PhysicsServer2D_method_area_set_collision_mask>`\ (\ area\: :ref:`RID<class_RID>`, mask\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`area_set_monitor_callback<class_PhysicsServer2D_method_area_set_monitor_callback>`\ (\ area\: :ref:`RID<class_RID>`, callback\: :ref:`Callable<class_Callable>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`area_set_monitorable<class_PhysicsServer2D_method_area_set_monitorable>`\ (\ area\: :ref:`RID<class_RID>`, monitorable\: :ref:`bool<class_bool>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`area_set_param<class_PhysicsServer2D_method_area_set_param>`\ (\ area\: :ref:`RID<class_RID>`, param\: :ref:`AreaParameter<enum_PhysicsServer2D_AreaParameter>`, value\: :ref:`Variant<class_Variant>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`area_set_shape<class_PhysicsServer2D_method_area_set_shape>`\ (\ area\: :ref:`RID<class_RID>`, shape_idx\: :ref:`int<class_int>`, shape\: :ref:`RID<class_RID>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`area_set_shape_disabled<class_PhysicsServer2D_method_area_set_shape_disabled>`\ (\ area\: :ref:`RID<class_RID>`, shape_idx\: :ref:`int<class_int>`, disabled\: :ref:`bool<class_bool>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`area_set_shape_transform<class_PhysicsServer2D_method_area_set_shape_transform>`\ (\ area\: :ref:`RID<class_RID>`, shape_idx\: :ref:`int<class_int>`, transform\: :ref:`Transform2D<class_Transform2D>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`area_set_space<class_PhysicsServer2D_method_area_set_space>`\ (\ area\: :ref:`RID<class_RID>`, space\: :ref:`RID<class_RID>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`area_set_transform<class_PhysicsServer2D_method_area_set_transform>`\ (\ area\: :ref:`RID<class_RID>`, transform\: :ref:`Transform2D<class_Transform2D>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`body_add_collision_exception<class_PhysicsServer2D_method_body_add_collision_exception>`\ (\ body\: :ref:`RID<class_RID>`, excepted_body\: :ref:`RID<class_RID>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`body_add_constant_central_force<class_PhysicsServer2D_method_body_add_constant_central_force>`\ (\ body\: :ref:`RID<class_RID>`, force\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`body_add_constant_force<class_PhysicsServer2D_method_body_add_constant_force>`\ (\ body\: :ref:`RID<class_RID>`, force\: :ref:`Vector2<class_Vector2>`, position\: :ref:`Vector2<class_Vector2>` = Vector2(0, 0)\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`body_add_constant_torque<class_PhysicsServer2D_method_body_add_constant_torque>`\ (\ body\: :ref:`RID<class_RID>`, torque\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`body_add_shape<class_PhysicsServer2D_method_body_add_shape>`\ (\ body\: :ref:`RID<class_RID>`, shape\: :ref:`RID<class_RID>`, transform\: :ref:`Transform2D<class_Transform2D>` = Transform2D(1, 0, 0, 1, 0, 0), disabled\: :ref:`bool<class_bool>` = false\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`body_apply_central_force<class_PhysicsServer2D_method_body_apply_central_force>`\ (\ body\: :ref:`RID<class_RID>`, force\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`body_apply_central_impulse<class_PhysicsServer2D_method_body_apply_central_impulse>`\ (\ body\: :ref:`RID<class_RID>`, impulse\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`body_apply_force<class_PhysicsServer2D_method_body_apply_force>`\ (\ body\: :ref:`RID<class_RID>`, force\: :ref:`Vector2<class_Vector2>`, position\: :ref:`Vector2<class_Vector2>` = Vector2(0, 0)\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`body_apply_impulse<class_PhysicsServer2D_method_body_apply_impulse>`\ (\ body\: :ref:`RID<class_RID>`, impulse\: :ref:`Vector2<class_Vector2>`, position\: :ref:`Vector2<class_Vector2>` = Vector2(0, 0)\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`body_apply_torque<class_PhysicsServer2D_method_body_apply_torque>`\ (\ body\: :ref:`RID<class_RID>`, torque\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`body_apply_torque_impulse<class_PhysicsServer2D_method_body_apply_torque_impulse>`\ (\ body\: :ref:`RID<class_RID>`, impulse\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`body_attach_canvas_instance_id<class_PhysicsServer2D_method_body_attach_canvas_instance_id>`\ (\ body\: :ref:`RID<class_RID>`, id\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`body_attach_object_instance_id<class_PhysicsServer2D_method_body_attach_object_instance_id>`\ (\ body\: :ref:`RID<class_RID>`, id\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`body_clear_shapes<class_PhysicsServer2D_method_body_clear_shapes>`\ (\ body\: :ref:`RID<class_RID>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`body_create<class_PhysicsServer2D_method_body_create>`\ (\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`body_get_canvas_instance_id<class_PhysicsServer2D_method_body_get_canvas_instance_id>`\ (\ body\: :ref:`RID<class_RID>`\ ) |const| |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`body_get_collision_layer<class_PhysicsServer2D_method_body_get_collision_layer>`\ (\ body\: :ref:`RID<class_RID>`\ ) |const| |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`body_get_collision_mask<class_PhysicsServer2D_method_body_get_collision_mask>`\ (\ body\: :ref:`RID<class_RID>`\ ) |const| |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`body_get_collision_priority<class_PhysicsServer2D_method_body_get_collision_priority>`\ (\ body\: :ref:`RID<class_RID>`\ ) |const| |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`body_get_constant_force<class_PhysicsServer2D_method_body_get_constant_force>`\ (\ body\: :ref:`RID<class_RID>`\ ) |const| |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`body_get_constant_torque<class_PhysicsServer2D_method_body_get_constant_torque>`\ (\ body\: :ref:`RID<class_RID>`\ ) |const| |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`CCDMode<enum_PhysicsServer2D_CCDMode>` | :ref:`body_get_continuous_collision_detection_mode<class_PhysicsServer2D_method_body_get_continuous_collision_detection_mode>`\ (\ body\: :ref:`RID<class_RID>`\ ) |const| |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PhysicsDirectBodyState2D<class_PhysicsDirectBodyState2D>` | :ref:`body_get_direct_state<class_PhysicsServer2D_method_body_get_direct_state>`\ (\ body\: :ref:`RID<class_RID>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`body_get_max_contacts_reported<class_PhysicsServer2D_method_body_get_max_contacts_reported>`\ (\ body\: :ref:`RID<class_RID>`\ ) |const| |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`BodyMode<enum_PhysicsServer2D_BodyMode>` | :ref:`body_get_mode<class_PhysicsServer2D_method_body_get_mode>`\ (\ body\: :ref:`RID<class_RID>`\ ) |const| |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`body_get_object_instance_id<class_PhysicsServer2D_method_body_get_object_instance_id>`\ (\ body\: :ref:`RID<class_RID>`\ ) |const| |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Variant<class_Variant>` | :ref:`body_get_param<class_PhysicsServer2D_method_body_get_param>`\ (\ body\: :ref:`RID<class_RID>`, param\: :ref:`BodyParameter<enum_PhysicsServer2D_BodyParameter>`\ ) |const| |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`body_get_shape<class_PhysicsServer2D_method_body_get_shape>`\ (\ body\: :ref:`RID<class_RID>`, shape_idx\: :ref:`int<class_int>`\ ) |const| |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`body_get_shape_count<class_PhysicsServer2D_method_body_get_shape_count>`\ (\ body\: :ref:`RID<class_RID>`\ ) |const| |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Transform2D<class_Transform2D>` | :ref:`body_get_shape_transform<class_PhysicsServer2D_method_body_get_shape_transform>`\ (\ body\: :ref:`RID<class_RID>`, shape_idx\: :ref:`int<class_int>`\ ) |const| |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`body_get_space<class_PhysicsServer2D_method_body_get_space>`\ (\ body\: :ref:`RID<class_RID>`\ ) |const| |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Variant<class_Variant>` | :ref:`body_get_state<class_PhysicsServer2D_method_body_get_state>`\ (\ body\: :ref:`RID<class_RID>`, state\: :ref:`BodyState<enum_PhysicsServer2D_BodyState>`\ ) |const| |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`body_is_omitting_force_integration<class_PhysicsServer2D_method_body_is_omitting_force_integration>`\ (\ body\: :ref:`RID<class_RID>`\ ) |const| |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`body_remove_collision_exception<class_PhysicsServer2D_method_body_remove_collision_exception>`\ (\ body\: :ref:`RID<class_RID>`, excepted_body\: :ref:`RID<class_RID>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`body_remove_shape<class_PhysicsServer2D_method_body_remove_shape>`\ (\ body\: :ref:`RID<class_RID>`, shape_idx\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`body_reset_mass_properties<class_PhysicsServer2D_method_body_reset_mass_properties>`\ (\ body\: :ref:`RID<class_RID>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`body_set_axis_velocity<class_PhysicsServer2D_method_body_set_axis_velocity>`\ (\ body\: :ref:`RID<class_RID>`, axis_velocity\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`body_set_collision_layer<class_PhysicsServer2D_method_body_set_collision_layer>`\ (\ body\: :ref:`RID<class_RID>`, layer\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`body_set_collision_mask<class_PhysicsServer2D_method_body_set_collision_mask>`\ (\ body\: :ref:`RID<class_RID>`, mask\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`body_set_collision_priority<class_PhysicsServer2D_method_body_set_collision_priority>`\ (\ body\: :ref:`RID<class_RID>`, priority\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`body_set_constant_force<class_PhysicsServer2D_method_body_set_constant_force>`\ (\ body\: :ref:`RID<class_RID>`, force\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`body_set_constant_torque<class_PhysicsServer2D_method_body_set_constant_torque>`\ (\ body\: :ref:`RID<class_RID>`, torque\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`body_set_continuous_collision_detection_mode<class_PhysicsServer2D_method_body_set_continuous_collision_detection_mode>`\ (\ body\: :ref:`RID<class_RID>`, mode\: :ref:`CCDMode<enum_PhysicsServer2D_CCDMode>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`body_set_force_integration_callback<class_PhysicsServer2D_method_body_set_force_integration_callback>`\ (\ body\: :ref:`RID<class_RID>`, callable\: :ref:`Callable<class_Callable>`, userdata\: :ref:`Variant<class_Variant>` = null\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`body_set_max_contacts_reported<class_PhysicsServer2D_method_body_set_max_contacts_reported>`\ (\ body\: :ref:`RID<class_RID>`, amount\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`body_set_mode<class_PhysicsServer2D_method_body_set_mode>`\ (\ body\: :ref:`RID<class_RID>`, mode\: :ref:`BodyMode<enum_PhysicsServer2D_BodyMode>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`body_set_omit_force_integration<class_PhysicsServer2D_method_body_set_omit_force_integration>`\ (\ body\: :ref:`RID<class_RID>`, enable\: :ref:`bool<class_bool>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`body_set_param<class_PhysicsServer2D_method_body_set_param>`\ (\ body\: :ref:`RID<class_RID>`, param\: :ref:`BodyParameter<enum_PhysicsServer2D_BodyParameter>`, value\: :ref:`Variant<class_Variant>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`body_set_shape<class_PhysicsServer2D_method_body_set_shape>`\ (\ body\: :ref:`RID<class_RID>`, shape_idx\: :ref:`int<class_int>`, shape\: :ref:`RID<class_RID>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`body_set_shape_as_one_way_collision<class_PhysicsServer2D_method_body_set_shape_as_one_way_collision>`\ (\ body\: :ref:`RID<class_RID>`, shape_idx\: :ref:`int<class_int>`, enable\: :ref:`bool<class_bool>`, margin\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`body_set_shape_disabled<class_PhysicsServer2D_method_body_set_shape_disabled>`\ (\ body\: :ref:`RID<class_RID>`, shape_idx\: :ref:`int<class_int>`, disabled\: :ref:`bool<class_bool>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`body_set_shape_transform<class_PhysicsServer2D_method_body_set_shape_transform>`\ (\ body\: :ref:`RID<class_RID>`, shape_idx\: :ref:`int<class_int>`, transform\: :ref:`Transform2D<class_Transform2D>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`body_set_space<class_PhysicsServer2D_method_body_set_space>`\ (\ body\: :ref:`RID<class_RID>`, space\: :ref:`RID<class_RID>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`body_set_state<class_PhysicsServer2D_method_body_set_state>`\ (\ body\: :ref:`RID<class_RID>`, state\: :ref:`BodyState<enum_PhysicsServer2D_BodyState>`, value\: :ref:`Variant<class_Variant>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`body_set_state_sync_callback<class_PhysicsServer2D_method_body_set_state_sync_callback>`\ (\ body\: :ref:`RID<class_RID>`, callable\: :ref:`Callable<class_Callable>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`body_test_motion<class_PhysicsServer2D_method_body_test_motion>`\ (\ body\: :ref:`RID<class_RID>`, parameters\: :ref:`PhysicsTestMotionParameters2D<class_PhysicsTestMotionParameters2D>`, result\: :ref:`PhysicsTestMotionResult2D<class_PhysicsTestMotionResult2D>` = null\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`capsule_shape_create<class_PhysicsServer2D_method_capsule_shape_create>`\ (\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`circle_shape_create<class_PhysicsServer2D_method_circle_shape_create>`\ (\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`concave_polygon_shape_create<class_PhysicsServer2D_method_concave_polygon_shape_create>`\ (\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`convex_polygon_shape_create<class_PhysicsServer2D_method_convex_polygon_shape_create>`\ (\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`damped_spring_joint_get_param<class_PhysicsServer2D_method_damped_spring_joint_get_param>`\ (\ joint\: :ref:`RID<class_RID>`, param\: :ref:`DampedSpringParam<enum_PhysicsServer2D_DampedSpringParam>`\ ) |const| |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`damped_spring_joint_set_param<class_PhysicsServer2D_method_damped_spring_joint_set_param>`\ (\ joint\: :ref:`RID<class_RID>`, param\: :ref:`DampedSpringParam<enum_PhysicsServer2D_DampedSpringParam>`, value\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`free_rid<class_PhysicsServer2D_method_free_rid>`\ (\ rid\: :ref:`RID<class_RID>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_process_info<class_PhysicsServer2D_method_get_process_info>`\ (\ process_info\: :ref:`ProcessInfo<enum_PhysicsServer2D_ProcessInfo>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`joint_clear<class_PhysicsServer2D_method_joint_clear>`\ (\ joint\: :ref:`RID<class_RID>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`joint_create<class_PhysicsServer2D_method_joint_create>`\ (\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`joint_disable_collisions_between_bodies<class_PhysicsServer2D_method_joint_disable_collisions_between_bodies>`\ (\ joint\: :ref:`RID<class_RID>`, disable\: :ref:`bool<class_bool>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`joint_get_param<class_PhysicsServer2D_method_joint_get_param>`\ (\ joint\: :ref:`RID<class_RID>`, param\: :ref:`JointParam<enum_PhysicsServer2D_JointParam>`\ ) |const| |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`JointType<enum_PhysicsServer2D_JointType>` | :ref:`joint_get_type<class_PhysicsServer2D_method_joint_get_type>`\ (\ joint\: :ref:`RID<class_RID>`\ ) |const| |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`joint_is_disabled_collisions_between_bodies<class_PhysicsServer2D_method_joint_is_disabled_collisions_between_bodies>`\ (\ joint\: :ref:`RID<class_RID>`\ ) |const| |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`joint_make_damped_spring<class_PhysicsServer2D_method_joint_make_damped_spring>`\ (\ joint\: :ref:`RID<class_RID>`, anchor_a\: :ref:`Vector2<class_Vector2>`, anchor_b\: :ref:`Vector2<class_Vector2>`, body_a\: :ref:`RID<class_RID>`, body_b\: :ref:`RID<class_RID>` = RID()\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`joint_make_groove<class_PhysicsServer2D_method_joint_make_groove>`\ (\ joint\: :ref:`RID<class_RID>`, groove1_a\: :ref:`Vector2<class_Vector2>`, groove2_a\: :ref:`Vector2<class_Vector2>`, anchor_b\: :ref:`Vector2<class_Vector2>`, body_a\: :ref:`RID<class_RID>` = RID(), body_b\: :ref:`RID<class_RID>` = RID()\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`joint_make_pin<class_PhysicsServer2D_method_joint_make_pin>`\ (\ joint\: :ref:`RID<class_RID>`, anchor\: :ref:`Vector2<class_Vector2>`, body_a\: :ref:`RID<class_RID>`, body_b\: :ref:`RID<class_RID>` = RID()\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`joint_set_param<class_PhysicsServer2D_method_joint_set_param>`\ (\ joint\: :ref:`RID<class_RID>`, param\: :ref:`JointParam<enum_PhysicsServer2D_JointParam>`, value\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`pin_joint_get_flag<class_PhysicsServer2D_method_pin_joint_get_flag>`\ (\ joint\: :ref:`RID<class_RID>`, flag\: :ref:`PinJointFlag<enum_PhysicsServer2D_PinJointFlag>`\ ) |const| |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`pin_joint_get_param<class_PhysicsServer2D_method_pin_joint_get_param>`\ (\ joint\: :ref:`RID<class_RID>`, param\: :ref:`PinJointParam<enum_PhysicsServer2D_PinJointParam>`\ ) |const| |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`pin_joint_set_flag<class_PhysicsServer2D_method_pin_joint_set_flag>`\ (\ joint\: :ref:`RID<class_RID>`, flag\: :ref:`PinJointFlag<enum_PhysicsServer2D_PinJointFlag>`, enabled\: :ref:`bool<class_bool>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`pin_joint_set_param<class_PhysicsServer2D_method_pin_joint_set_param>`\ (\ joint\: :ref:`RID<class_RID>`, param\: :ref:`PinJointParam<enum_PhysicsServer2D_PinJointParam>`, value\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`rectangle_shape_create<class_PhysicsServer2D_method_rectangle_shape_create>`\ (\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`segment_shape_create<class_PhysicsServer2D_method_segment_shape_create>`\ (\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`separation_ray_shape_create<class_PhysicsServer2D_method_separation_ray_shape_create>`\ (\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_active<class_PhysicsServer2D_method_set_active>`\ (\ active\: :ref:`bool<class_bool>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Variant<class_Variant>` | :ref:`shape_get_data<class_PhysicsServer2D_method_shape_get_data>`\ (\ shape\: :ref:`RID<class_RID>`\ ) |const| |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`ShapeType<enum_PhysicsServer2D_ShapeType>` | :ref:`shape_get_type<class_PhysicsServer2D_method_shape_get_type>`\ (\ shape\: :ref:`RID<class_RID>`\ ) |const| |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`shape_set_data<class_PhysicsServer2D_method_shape_set_data>`\ (\ shape\: :ref:`RID<class_RID>`, data\: :ref:`Variant<class_Variant>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`space_create<class_PhysicsServer2D_method_space_create>`\ (\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PhysicsDirectSpaceState2D<class_PhysicsDirectSpaceState2D>` | :ref:`space_get_direct_state<class_PhysicsServer2D_method_space_get_direct_state>`\ (\ space\: :ref:`RID<class_RID>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`space_get_param<class_PhysicsServer2D_method_space_get_param>`\ (\ space\: :ref:`RID<class_RID>`, param\: :ref:`SpaceParameter<enum_PhysicsServer2D_SpaceParameter>`\ ) |const| |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`space_is_active<class_PhysicsServer2D_method_space_is_active>`\ (\ space\: :ref:`RID<class_RID>`\ ) |const| |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`space_set_active<class_PhysicsServer2D_method_space_set_active>`\ (\ space\: :ref:`RID<class_RID>`, active\: :ref:`bool<class_bool>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`space_set_param<class_PhysicsServer2D_method_space_set_param>`\ (\ space\: :ref:`RID<class_RID>`, param\: :ref:`SpaceParameter<enum_PhysicsServer2D_SpaceParameter>`, value\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`world_boundary_shape_create<class_PhysicsServer2D_method_world_boundary_shape_create>`\ (\ ) |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Enumerazioni
------------------------
.. _enum_PhysicsServer2D_SpaceParameter:
.. rst-class:: classref-enumeration
enum **SpaceParameter**: :ref:`🔗<enum_PhysicsServer2D_SpaceParameter>`
.. _class_PhysicsServer2D_constant_SPACE_PARAM_CONTACT_RECYCLE_RADIUS:
.. rst-class:: classref-enumeration-constant
:ref:`SpaceParameter<enum_PhysicsServer2D_SpaceParameter>` **SPACE_PARAM_CONTACT_RECYCLE_RADIUS** = ``0``
Costante per impostare/ottenere la distanza massima che una coppia di corpi deve percorrere prima che il loro stato di collisione debba essere ricalcolato. Il valore predefinito di questo parametro è :ref:`ProjectSettings.physics/2d/solver/contact_recycle_radius<class_ProjectSettings_property_physics/2d/solver/contact_recycle_radius>`.
.. _class_PhysicsServer2D_constant_SPACE_PARAM_CONTACT_MAX_SEPARATION:
.. rst-class:: classref-enumeration-constant
:ref:`SpaceParameter<enum_PhysicsServer2D_SpaceParameter>` **SPACE_PARAM_CONTACT_MAX_SEPARATION** = ``1``
Costante per impostare/ottenere la distanza massima che una forma può avere da un'altra prima che siano considerate separate e il contatto sia scartato. Il valore predefinito di questo parametro è :ref:`ProjectSettings.physics/2d/solver/contact_max_separation<class_ProjectSettings_property_physics/2d/solver/contact_max_separation>`.
.. _class_PhysicsServer2D_constant_SPACE_PARAM_CONTACT_MAX_ALLOWED_PENETRATION:
.. rst-class:: classref-enumeration-constant
:ref:`SpaceParameter<enum_PhysicsServer2D_SpaceParameter>` **SPACE_PARAM_CONTACT_MAX_ALLOWED_PENETRATION** = ``2``
Costante per impostare/ottenere la distanza massima entro cui una forma può penetrare un'altra forma prima che sia considerata una collisione. Il valore predefinito di questo parametro è :ref:`ProjectSettings.physics/2d/solver/contact_max_allowed_penetration<class_ProjectSettings_property_physics/2d/solver/contact_max_allowed_penetration>`.
.. _class_PhysicsServer2D_constant_SPACE_PARAM_CONTACT_DEFAULT_BIAS:
.. rst-class:: classref-enumeration-constant
:ref:`SpaceParameter<enum_PhysicsServer2D_SpaceParameter>` **SPACE_PARAM_CONTACT_DEFAULT_BIAS** = ``3``
Costante per impostare/ottenere il bias predefinito del risolutore per tutti i contatti fisici. Un bias del risolutore è un fattore che controlla quanto due oggetti "rimbalzano", dopo essersi sovrapposti, per evitare di lasciarli in quella situazione a causa di un'imprecisione numerica. Il valore predefinito di questo parametro è :ref:`ProjectSettings.physics/2d/solver/default_contact_bias<class_ProjectSettings_property_physics/2d/solver/default_contact_bias>`.
.. _class_PhysicsServer2D_constant_SPACE_PARAM_BODY_LINEAR_VELOCITY_SLEEP_THRESHOLD:
.. rst-class:: classref-enumeration-constant
:ref:`SpaceParameter<enum_PhysicsServer2D_SpaceParameter>` **SPACE_PARAM_BODY_LINEAR_VELOCITY_SLEEP_THRESHOLD** = ``4``
Costante per impostare/ottenere la soglia della velocità lineare di attività. Un corpo contrassegnato come potenzialmente inattivo sia per la velocità lineare sia per quella angolare sarà messo in modalità riposo dopo il tempo specificato. Il valore predefinito di questo parametro è :ref:`ProjectSettings.physics/2d/sleep_threshold_linear<class_ProjectSettings_property_physics/2d/sleep_threshold_linear>`.
.. _class_PhysicsServer2D_constant_SPACE_PARAM_BODY_ANGULAR_VELOCITY_SLEEP_THRESHOLD:
.. rst-class:: classref-enumeration-constant
:ref:`SpaceParameter<enum_PhysicsServer2D_SpaceParameter>` **SPACE_PARAM_BODY_ANGULAR_VELOCITY_SLEEP_THRESHOLD** = ``5``
Costante per impostare/ottenere la soglia della velocità angolare di attività. Un corpo contrassegnato come potenzialmente inattivo sia per la velocità lineare sia per quella angolare sarà messo in modalità riposo dopo il tempo specificato. Il valore predefinito di questo parametro è :ref:`ProjectSettings.physics/2d/sleep_threshold_angular<class_ProjectSettings_property_physics/2d/sleep_threshold_angular>`.
.. _class_PhysicsServer2D_constant_SPACE_PARAM_BODY_TIME_TO_SLEEP:
.. rst-class:: classref-enumeration-constant
:ref:`SpaceParameter<enum_PhysicsServer2D_SpaceParameter>` **SPACE_PARAM_BODY_TIME_TO_SLEEP** = ``6``
Costante per impostare/ottenere il tempo massimo di attività. Un corpo contrassegnato come potenzialmente inattivo sia per la velocità lineare sia per quella angolare sarà messo in modalità riposo dopo questo tempo. Il valore predefinito di questo parametro è :ref:`ProjectSettings.physics/2d/time_before_sleep<class_ProjectSettings_property_physics/2d/time_before_sleep>`.
.. _class_PhysicsServer2D_constant_SPACE_PARAM_CONSTRAINT_DEFAULT_BIAS:
.. rst-class:: classref-enumeration-constant
:ref:`SpaceParameter<enum_PhysicsServer2D_SpaceParameter>` **SPACE_PARAM_CONSTRAINT_DEFAULT_BIAS** = ``7``
Costante per impostare/ottenere il bias predefinito del risolutore per tutti i vincoli fisici. Un bias del risolutore è un fattore che controlla quanto due oggetti "rimbalzano", dopo aver violato un vincolo, per evitare di lasciarli in quella situazione a causa di un'imprecisione numerica. Il valore predefinito di questo parametro è :ref:`ProjectSettings.physics/2d/solver/default_constraint_bias<class_ProjectSettings_property_physics/2d/solver/default_constraint_bias>`.
.. _class_PhysicsServer2D_constant_SPACE_PARAM_SOLVER_ITERATIONS:
.. rst-class:: classref-enumeration-constant
:ref:`SpaceParameter<enum_PhysicsServer2D_SpaceParameter>` **SPACE_PARAM_SOLVER_ITERATIONS** = ``8``
Costante per impostare/ottenere il numero di iterazioni del risolutore per tutti i contatti e i vincoli. Maggiore è il numero di iterazioni, più accurate saranno le collisioni. Tuttavia, un numero maggiore di iterazioni richiede una maggiore potenza della CPU, il che può ridurre le prestazioni. Il valore predefinito di questo parametro è :ref:`ProjectSettings.physics/2d/solver/solver_iterations<class_ProjectSettings_property_physics/2d/solver/solver_iterations>`.
.. rst-class:: classref-item-separator
----
.. _enum_PhysicsServer2D_ShapeType:
.. rst-class:: classref-enumeration
enum **ShapeType**: :ref:`🔗<enum_PhysicsServer2D_ShapeType>`
.. _class_PhysicsServer2D_constant_SHAPE_WORLD_BOUNDARY:
.. rst-class:: classref-enumeration-constant
:ref:`ShapeType<enum_PhysicsServer2D_ShapeType>` **SHAPE_WORLD_BOUNDARY** = ``0``
Questa è la costante per creare forme di confine del mondo. Una forma di confine del mondo è una linea *infinita* con un punto di origine e una normale. Quindi, può essere usata per verifiche di fronte e retro.
.. _class_PhysicsServer2D_constant_SHAPE_SEPARATION_RAY:
.. rst-class:: classref-enumeration-constant
:ref:`ShapeType<enum_PhysicsServer2D_ShapeType>` **SHAPE_SEPARATION_RAY** = ``1``
Questa è la costante per creare forme di raggio di separazione. Un raggio di separazione è definito da una lunghezza e si separa da ciò che tocca la sua estremità lontana. Utile per i controller di personaggi.
.. _class_PhysicsServer2D_constant_SHAPE_SEGMENT:
.. rst-class:: classref-enumeration-constant
:ref:`ShapeType<enum_PhysicsServer2D_ShapeType>` **SHAPE_SEGMENT** = ``2``
Questa è la costante per creare forme di segmento. Una forma di segmento è una linea *finita* da un punto A a un punto B. Può essere verificata per intersezioni.
.. _class_PhysicsServer2D_constant_SHAPE_CIRCLE:
.. rst-class:: classref-enumeration-constant
:ref:`ShapeType<enum_PhysicsServer2D_ShapeType>` **SHAPE_CIRCLE** = ``3``
Questa è la costante per creare forme di cerchio. Una forma di cerchio ha solo un raggio. Può essere utilizzata per verifiche di intersezioni e di interni/esterni.
.. _class_PhysicsServer2D_constant_SHAPE_RECTANGLE:
.. rst-class:: classref-enumeration-constant
:ref:`ShapeType<enum_PhysicsServer2D_ShapeType>` **SHAPE_RECTANGLE** = ``4``
Questa è la costante per creare forme di rettangolo. Una forma di rettangolo è definita da una larghezza e un'altezza. Può essere utilizzata per verifiche di intersezioni e di interni/esterni.
.. _class_PhysicsServer2D_constant_SHAPE_CAPSULE:
.. rst-class:: classref-enumeration-constant
:ref:`ShapeType<enum_PhysicsServer2D_ShapeType>` **SHAPE_CAPSULE** = ``5``
Questa è la costante per creare forme di capsula. Una forma di capsula è definita da un raggio e una lunghezza. Può essere utilizzata per verifiche di intersezioni e di interni/esterni.
.. _class_PhysicsServer2D_constant_SHAPE_CONVEX_POLYGON:
.. rst-class:: classref-enumeration-constant
:ref:`ShapeType<enum_PhysicsServer2D_ShapeType>` **SHAPE_CONVEX_POLYGON** = ``6``
Questa è la costante per creare forme di poligoni convessi. Un poligono è definito da una lista di punti. Può essere utilizzato per verifiche di intersezioni e di interni/esterni.
.. _class_PhysicsServer2D_constant_SHAPE_CONCAVE_POLYGON:
.. rst-class:: classref-enumeration-constant
:ref:`ShapeType<enum_PhysicsServer2D_ShapeType>` **SHAPE_CONCAVE_POLYGON** = ``7``
Questa è la costante per creare forme di poligoni concavi. Un poligono è definito da una lista di punti. Può essere utilizzato per verifiche di intersezioni, ma non per verifiche di interni/esterni.
.. _class_PhysicsServer2D_constant_SHAPE_CUSTOM:
.. rst-class:: classref-enumeration-constant
:ref:`ShapeType<enum_PhysicsServer2D_ShapeType>` **SHAPE_CUSTOM** = ``8``
Questa costante è usata internamente dal motore. Ogni tentativo di creare questo tipo di forma risulta in un errore.
.. rst-class:: classref-item-separator
----
.. _enum_PhysicsServer2D_AreaParameter:
.. rst-class:: classref-enumeration
enum **AreaParameter**: :ref:`🔗<enum_PhysicsServer2D_AreaParameter>`
.. _class_PhysicsServer2D_constant_AREA_PARAM_GRAVITY_OVERRIDE_MODE:
.. rst-class:: classref-enumeration-constant
:ref:`AreaParameter<enum_PhysicsServer2D_AreaParameter>` **AREA_PARAM_GRAVITY_OVERRIDE_MODE** = ``0``
Costante per impostare/ottenere la modalità di sostituzione della gravità in un'area. Vedi :ref:`AreaSpaceOverrideMode<enum_PhysicsServer2D_AreaSpaceOverrideMode>` per i valori possibili. Il valore predefinito di questo parametro è :ref:`AREA_SPACE_OVERRIDE_DISABLED<class_PhysicsServer2D_constant_AREA_SPACE_OVERRIDE_DISABLED>`.
.. _class_PhysicsServer2D_constant_AREA_PARAM_GRAVITY:
.. rst-class:: classref-enumeration-constant
:ref:`AreaParameter<enum_PhysicsServer2D_AreaParameter>` **AREA_PARAM_GRAVITY** = ``1``
Costante per impostare/ottenere la forza di gravità in un'area. Il valore predefinito di questo parametro è ``9.80665``.
.. _class_PhysicsServer2D_constant_AREA_PARAM_GRAVITY_VECTOR:
.. rst-class:: classref-enumeration-constant
:ref:`AreaParameter<enum_PhysicsServer2D_AreaParameter>` **AREA_PARAM_GRAVITY_VECTOR** = ``2``
Costante per impostare/ottenere il vettore/centro di gravità in un'area. Il valore predefinito di questo parametro è ``Vector2(0, -1)``.
.. _class_PhysicsServer2D_constant_AREA_PARAM_GRAVITY_IS_POINT:
.. rst-class:: classref-enumeration-constant
:ref:`AreaParameter<enum_PhysicsServer2D_AreaParameter>` **AREA_PARAM_GRAVITY_IS_POINT** = ``3``
Costante per impostare/ottenere se il vettore di gravità di un'area è una direzione oppure un punto centrale. Il valore predefinito di questo parametro è ``false``.
.. _class_PhysicsServer2D_constant_AREA_PARAM_GRAVITY_POINT_UNIT_DISTANCE:
.. rst-class:: classref-enumeration-constant
:ref:`AreaParameter<enum_PhysicsServer2D_AreaParameter>` **AREA_PARAM_GRAVITY_POINT_UNIT_DISTANCE** = ``4``
Costante per impostare/ottenere la distanza alla quale la forza di gravità è uguale alla gravità controllata da :ref:`AREA_PARAM_GRAVITY<class_PhysicsServer2D_constant_AREA_PARAM_GRAVITY>`. Ad esempio, su un pianeta con un raggio di 100 pixel, con una gravità superficiale di 4,0 px/s², imposta la gravità su 4,0 e la distanza unitaria su 100,0. La gravità avrà un calo secondo la legge dell'inverso del quadrato, quindi nell'esempio, a 200 pixel dal centro la gravità sarà 1,0 px/s² (il doppio della distanza, 1/4 della gravità), a 50 pixel sarà 16,0 px/s² (la metà della distanza, 4 volte la gravità) e così via.
Quanto sopra è vero solo quando la distanza unitaria è un numero positivo. Quando la distanza unitaria è impostata su 0,0, la gravità sarà costante a prescindere dalla distanza. Il valore predefinito di questo parametro è ``0,0``.
.. _class_PhysicsServer2D_constant_AREA_PARAM_LINEAR_DAMP_OVERRIDE_MODE:
.. rst-class:: classref-enumeration-constant
:ref:`AreaParameter<enum_PhysicsServer2D_AreaParameter>` **AREA_PARAM_LINEAR_DAMP_OVERRIDE_MODE** = ``5``
Costante per impostare/ottenere la modalità di sostituzione dello smorzamento lineare in un'area. Vedi :ref:`AreaSpaceOverrideMode<enum_PhysicsServer2D_AreaSpaceOverrideMode>` per i valori possibili. Il valore predefinito di questo parametro è :ref:`AREA_SPACE_OVERRIDE_DISABLED<class_PhysicsServer2D_constant_AREA_SPACE_OVERRIDE_DISABLED>`.
.. _class_PhysicsServer2D_constant_AREA_PARAM_LINEAR_DAMP:
.. rst-class:: classref-enumeration-constant
:ref:`AreaParameter<enum_PhysicsServer2D_AreaParameter>` **AREA_PARAM_LINEAR_DAMP** = ``6``
Costante per impostare/ottenere il fattore di smorzamento lineare di un'area. Il valore predefinito di questo parametro è ``0.1``.
.. _class_PhysicsServer2D_constant_AREA_PARAM_ANGULAR_DAMP_OVERRIDE_MODE:
.. rst-class:: classref-enumeration-constant
:ref:`AreaParameter<enum_PhysicsServer2D_AreaParameter>` **AREA_PARAM_ANGULAR_DAMP_OVERRIDE_MODE** = ``7``
Costante per impostare/ottenere la modalità di sostituzione dello smorzamento angolare in un'area. Vedi :ref:`AreaSpaceOverrideMode<enum_PhysicsServer2D_AreaSpaceOverrideMode>` per i valori possibili. Il valore predefinito di questo parametro è :ref:`AREA_SPACE_OVERRIDE_DISABLED<class_PhysicsServer2D_constant_AREA_SPACE_OVERRIDE_DISABLED>`.
.. _class_PhysicsServer2D_constant_AREA_PARAM_ANGULAR_DAMP:
.. rst-class:: classref-enumeration-constant
:ref:`AreaParameter<enum_PhysicsServer2D_AreaParameter>` **AREA_PARAM_ANGULAR_DAMP** = ``8``
Costante per impostare/ottenere il fattore di smorzamento angolare di un'area. Il valore predefinito di questo parametro è ``1.0``.
.. _class_PhysicsServer2D_constant_AREA_PARAM_PRIORITY:
.. rst-class:: classref-enumeration-constant
:ref:`AreaParameter<enum_PhysicsServer2D_AreaParameter>` **AREA_PARAM_PRIORITY** = ``9``
Costante per impostare/ottenere la priorità (l'ordine di elaborazione) di un'area. Il valore predefinito di questo parametro è ``0``.
.. rst-class:: classref-item-separator
----
.. _enum_PhysicsServer2D_AreaSpaceOverrideMode:
.. rst-class:: classref-enumeration
enum **AreaSpaceOverrideMode**: :ref:`🔗<enum_PhysicsServer2D_AreaSpaceOverrideMode>`
.. _class_PhysicsServer2D_constant_AREA_SPACE_OVERRIDE_DISABLED:
.. rst-class:: classref-enumeration-constant
:ref:`AreaSpaceOverrideMode<enum_PhysicsServer2D_AreaSpaceOverrideMode>` **AREA_SPACE_OVERRIDE_DISABLED** = ``0``
Questa area non influenza la gravità o lo smorzamento. Queste sono generalmente aree che esistono solo per rilevare collisioni e oggetti che entrano o escono da essa.
.. _class_PhysicsServer2D_constant_AREA_SPACE_OVERRIDE_COMBINE:
.. rst-class:: classref-enumeration-constant
:ref:`AreaSpaceOverrideMode<enum_PhysicsServer2D_AreaSpaceOverrideMode>` **AREA_SPACE_OVERRIDE_COMBINE** = ``1``
Questa area aggiunge i suoi valori di gravità e smorzamento a tutto ciò che è stato calcolato finora. In questo modo, molte aree sovrapposte possono combinare la loro fisica per creare effetti interessanti.
.. _class_PhysicsServer2D_constant_AREA_SPACE_OVERRIDE_COMBINE_REPLACE:
.. rst-class:: classref-enumeration-constant
:ref:`AreaSpaceOverrideMode<enum_PhysicsServer2D_AreaSpaceOverrideMode>` **AREA_SPACE_OVERRIDE_COMBINE_REPLACE** = ``2``
Questa area aggiunge i suoi valori di gravità e smorzamento a tutto ciò che è stato calcolato finora. Infine smette di tenere conto del resto delle aree, anche quella predefinita.
.. _class_PhysicsServer2D_constant_AREA_SPACE_OVERRIDE_REPLACE:
.. rst-class:: classref-enumeration-constant
:ref:`AreaSpaceOverrideMode<enum_PhysicsServer2D_AreaSpaceOverrideMode>` **AREA_SPACE_OVERRIDE_REPLACE** = ``3``
Quest'area sostituisce qualsiasi valore di gravità e smorzamento, anche quelli predefiniti, e smette di tenere conto delle altre aree.
.. _class_PhysicsServer2D_constant_AREA_SPACE_OVERRIDE_REPLACE_COMBINE:
.. rst-class:: classref-enumeration-constant
:ref:`AreaSpaceOverrideMode<enum_PhysicsServer2D_AreaSpaceOverrideMode>` **AREA_SPACE_OVERRIDE_REPLACE_COMBINE** = ``4``
Quest'area sostituisce qualsiasi valore di gravità e smorzamento calcolato finora, ma continua a calcolare le altre aree, fino a quella predefinita.
.. rst-class:: classref-item-separator
----
.. _enum_PhysicsServer2D_BodyMode:
.. rst-class:: classref-enumeration
enum **BodyMode**: :ref:`🔗<enum_PhysicsServer2D_BodyMode>`
.. _class_PhysicsServer2D_constant_BODY_MODE_STATIC:
.. rst-class:: classref-enumeration-constant
:ref:`BodyMode<enum_PhysicsServer2D_BodyMode>` **BODY_MODE_STATIC** = ``0``
Costante per i corpi statici. In questa modalità, un corpo può essere spostato solo dal codice utente e non entra in collisione con altri corpi lungo il suo percorso quando viene spostato.
.. _class_PhysicsServer2D_constant_BODY_MODE_KINEMATIC:
.. rst-class:: classref-enumeration-constant
:ref:`BodyMode<enum_PhysicsServer2D_BodyMode>` **BODY_MODE_KINEMATIC** = ``1``
Costante per i corpi cinematici. In questa modalità, un corpo può essere spostato solo dal codice utente ed entra in collisione con altri corpi lungo il suo percorso.
.. _class_PhysicsServer2D_constant_BODY_MODE_RIGID:
.. rst-class:: classref-enumeration-constant
:ref:`BodyMode<enum_PhysicsServer2D_BodyMode>` **BODY_MODE_RIGID** = ``2``
Costante per i corpi rigidi. In questa modalità, un corpo può essere spinto da altri corpi e avere forze applicate.
.. _class_PhysicsServer2D_constant_BODY_MODE_RIGID_LINEAR:
.. rst-class:: classref-enumeration-constant
:ref:`BodyMode<enum_PhysicsServer2D_BodyMode>` **BODY_MODE_RIGID_LINEAR** = ``3``
Costante per i corpi rigidi lineari. In questa modalità, un corpo non può ruotare e solo la sua velocità lineare è influenzata dalle forze esterne.
.. rst-class:: classref-item-separator
----
.. _enum_PhysicsServer2D_BodyParameter:
.. rst-class:: classref-enumeration
enum **BodyParameter**: :ref:`🔗<enum_PhysicsServer2D_BodyParameter>`
.. _class_PhysicsServer2D_constant_BODY_PARAM_BOUNCE:
.. rst-class:: classref-enumeration-constant
:ref:`BodyParameter<enum_PhysicsServer2D_BodyParameter>` **BODY_PARAM_BOUNCE** = ``0``
Costante per impostare/ottenere il fattore di rimbalzo di un corpo. Il valore predefinito di questo parametro è ``0.0``.
.. _class_PhysicsServer2D_constant_BODY_PARAM_FRICTION:
.. rst-class:: classref-enumeration-constant
:ref:`BodyParameter<enum_PhysicsServer2D_BodyParameter>` **BODY_PARAM_FRICTION** = ``1``
Costante per impostare/ottenere l'attrito di un corpo. Il valore predefinito di questo parametro è ``0.0``.
.. _class_PhysicsServer2D_constant_BODY_PARAM_MASS:
.. rst-class:: classref-enumeration-constant
:ref:`BodyParameter<enum_PhysicsServer2D_BodyParameter>` **BODY_PARAM_MASS** = ``2``
Costante per impostare/ottenere la massa di un corpo. Il valore predefinito di questo parametro è ``1.0``. Se la modalità del corpo è impostata su :ref:`BODY_MODE_RIGID<class_PhysicsServer2D_constant_BODY_MODE_RIGID>`, l'impostazione di questo parametro avrà i seguenti effetti aggiuntivi:
- Se il parametro :ref:`BODY_PARAM_CENTER_OF_MASS<class_PhysicsServer2D_constant_BODY_PARAM_CENTER_OF_MASS>` non è mai stato impostato esplicitamente, il valore di tale parametro verrà ricalcolato in base alle forme del corpo.
- Se il parametro :ref:`BODY_PARAM_INERTIA<class_PhysicsServer2D_constant_BODY_PARAM_INERTIA>` è impostato su un valore ``<= 0.0``, il valore di tale parametro verrà ricalcolato in base alle forme, alla massa e al centro di massa del corpo.
.. _class_PhysicsServer2D_constant_BODY_PARAM_INERTIA:
.. rst-class:: classref-enumeration-constant
:ref:`BodyParameter<enum_PhysicsServer2D_BodyParameter>` **BODY_PARAM_INERTIA** = ``3``
Costante per impostare/ottenere l'inerzia di un corpo. Il valore predefinito di questo parametro è ``0.0``. Se l'inerzia del corpo è impostata su un valore ``<= 0,0``, l'inerzia verrà ricalcolata in base alle forme del corpo, alla massa e al centro di massa.
.. _class_PhysicsServer2D_constant_BODY_PARAM_CENTER_OF_MASS:
.. rst-class:: classref-enumeration-constant
:ref:`BodyParameter<enum_PhysicsServer2D_BodyParameter>` **BODY_PARAM_CENTER_OF_MASS** = ``4``
Costante per impostare/ottenere la posizione del centro di massa di un corpo nel sistema di coordinate locale del corpo. Il valore predefinito di questo parametro è ``Vector2(0,0)``. Se questo parametro non viene mai impostato esplicitamente, viene ricalcolato in base alle forme del corpo quando si imposta il parametro :ref:`BODY_PARAM_MASS<class_PhysicsServer2D_constant_BODY_PARAM_MASS>` o quando viene chiamato :ref:`body_set_space()<class_PhysicsServer2D_method_body_set_space>`.
.. _class_PhysicsServer2D_constant_BODY_PARAM_GRAVITY_SCALE:
.. rst-class:: classref-enumeration-constant
:ref:`BodyParameter<enum_PhysicsServer2D_BodyParameter>` **BODY_PARAM_GRAVITY_SCALE** = ``5``
Costante per impostare/ottenere il moltiplicatore della gravità di un corpo. Il valore predefinito di questo parametro è ``1.0``.
.. _class_PhysicsServer2D_constant_BODY_PARAM_LINEAR_DAMP_MODE:
.. rst-class:: classref-enumeration-constant
:ref:`BodyParameter<enum_PhysicsServer2D_BodyParameter>` **BODY_PARAM_LINEAR_DAMP_MODE** = ``6``
Costante per impostare/ottenere la modalità di smorzamento lineare di un corpo. Vedi :ref:`BodyDampMode<enum_PhysicsServer2D_BodyDampMode>` per i valori possibili. Il valore predefinito di questo parametro è :ref:`BODY_DAMP_MODE_COMBINE<class_PhysicsServer2D_constant_BODY_DAMP_MODE_COMBINE>`.
.. _class_PhysicsServer2D_constant_BODY_PARAM_ANGULAR_DAMP_MODE:
.. rst-class:: classref-enumeration-constant
:ref:`BodyParameter<enum_PhysicsServer2D_BodyParameter>` **BODY_PARAM_ANGULAR_DAMP_MODE** = ``7``
Costante per impostare/ottenere la modalità di smorzamento angolare di un corpo. Vedi :ref:`BodyDampMode<enum_PhysicsServer2D_BodyDampMode>` per i valori possibili. Il valore predefinito di questo parametro è :ref:`BODY_DAMP_MODE_COMBINE<class_PhysicsServer2D_constant_BODY_DAMP_MODE_COMBINE>`.
.. _class_PhysicsServer2D_constant_BODY_PARAM_LINEAR_DAMP:
.. rst-class:: classref-enumeration-constant
:ref:`BodyParameter<enum_PhysicsServer2D_BodyParameter>` **BODY_PARAM_LINEAR_DAMP** = ``8``
Costante per impostare/ottenere il fattore di smorzamento lineare di un corpo. Il valore predefinito di questo parametro è ``0.0``.
.. _class_PhysicsServer2D_constant_BODY_PARAM_ANGULAR_DAMP:
.. rst-class:: classref-enumeration-constant
:ref:`BodyParameter<enum_PhysicsServer2D_BodyParameter>` **BODY_PARAM_ANGULAR_DAMP** = ``9``
Costante per impostare/ottenere il fattore di smorzamento angolare di un corpo. Il valore predefinito di questo parametro è ``0.0``.
.. _class_PhysicsServer2D_constant_BODY_PARAM_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`BodyParameter<enum_PhysicsServer2D_BodyParameter>` **BODY_PARAM_MAX** = ``10``
Rappresenta la dimensione dell'enumerazione :ref:`BodyParameter<enum_PhysicsServer2D_BodyParameter>`.
.. rst-class:: classref-item-separator
----
.. _enum_PhysicsServer2D_BodyDampMode:
.. rst-class:: classref-enumeration
enum **BodyDampMode**: :ref:`🔗<enum_PhysicsServer2D_BodyDampMode>`
.. _class_PhysicsServer2D_constant_BODY_DAMP_MODE_COMBINE:
.. rst-class:: classref-enumeration-constant
:ref:`BodyDampMode<enum_PhysicsServer2D_BodyDampMode>` **BODY_DAMP_MODE_COMBINE** = ``0``
Il valore di smorzamento del corpo è aggiunto a qualsiasi valore impostato nelle aree o al valore predefinito.
.. _class_PhysicsServer2D_constant_BODY_DAMP_MODE_REPLACE:
.. rst-class:: classref-enumeration-constant
:ref:`BodyDampMode<enum_PhysicsServer2D_BodyDampMode>` **BODY_DAMP_MODE_REPLACE** = ``1``
Il valore di smorzamento del corpo sostituisce qualsiasi valore impostato nelle aree o il valore predefinito.
.. rst-class:: classref-item-separator
----
.. _enum_PhysicsServer2D_BodyState:
.. rst-class:: classref-enumeration
enum **BodyState**: :ref:`🔗<enum_PhysicsServer2D_BodyState>`
.. _class_PhysicsServer2D_constant_BODY_STATE_TRANSFORM:
.. rst-class:: classref-enumeration-constant
:ref:`BodyState<enum_PhysicsServer2D_BodyState>` **BODY_STATE_TRANSFORM** = ``0``
Costante per impostare/ottenere la matrice di trasformazione attuale di un corpo.
.. _class_PhysicsServer2D_constant_BODY_STATE_LINEAR_VELOCITY:
.. rst-class:: classref-enumeration-constant
:ref:`BodyState<enum_PhysicsServer2D_BodyState>` **BODY_STATE_LINEAR_VELOCITY** = ``1``
Costante per impostare/ottenere la velocità lineare attuale di un corpo.
.. _class_PhysicsServer2D_constant_BODY_STATE_ANGULAR_VELOCITY:
.. rst-class:: classref-enumeration-constant
:ref:`BodyState<enum_PhysicsServer2D_BodyState>` **BODY_STATE_ANGULAR_VELOCITY** = ``2``
Costante per impostare/ottenere la velocità angolare attuale di un corpo.
.. _class_PhysicsServer2D_constant_BODY_STATE_SLEEPING:
.. rst-class:: classref-enumeration-constant
:ref:`BodyState<enum_PhysicsServer2D_BodyState>` **BODY_STATE_SLEEPING** = ``3``
Costante per cambiare lo stato di riposo di un corpo, oppure per ottenere se è in riposo.
.. _class_PhysicsServer2D_constant_BODY_STATE_CAN_SLEEP:
.. rst-class:: classref-enumeration-constant
:ref:`BodyState<enum_PhysicsServer2D_BodyState>` **BODY_STATE_CAN_SLEEP** = ``4``
Costante per impostare/ottenere se il corpo può essere in riposo.
.. rst-class:: classref-item-separator
----
.. _enum_PhysicsServer2D_JointType:
.. rst-class:: classref-enumeration
enum **JointType**: :ref:`🔗<enum_PhysicsServer2D_JointType>`
.. _class_PhysicsServer2D_constant_JOINT_TYPE_PIN:
.. rst-class:: classref-enumeration-constant
:ref:`JointType<enum_PhysicsServer2D_JointType>` **JOINT_TYPE_PIN** = ``0``
Costante per creare giunti a perno.
.. _class_PhysicsServer2D_constant_JOINT_TYPE_GROOVE:
.. rst-class:: classref-enumeration-constant
:ref:`JointType<enum_PhysicsServer2D_JointType>` **JOINT_TYPE_GROOVE** = ``1``
Costante per creare giunti scanalati.
.. _class_PhysicsServer2D_constant_JOINT_TYPE_DAMPED_SPRING:
.. rst-class:: classref-enumeration-constant
:ref:`JointType<enum_PhysicsServer2D_JointType>` **JOINT_TYPE_DAMPED_SPRING** = ``2``
Costante per creare giunti a molla smorzati.
.. _class_PhysicsServer2D_constant_JOINT_TYPE_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`JointType<enum_PhysicsServer2D_JointType>` **JOINT_TYPE_MAX** = ``3``
Rappresenta la dimensione dell'enumerazione :ref:`JointType<enum_PhysicsServer2D_JointType>`.
.. rst-class:: classref-item-separator
----
.. _enum_PhysicsServer2D_JointParam:
.. rst-class:: classref-enumeration
enum **JointParam**: :ref:`🔗<enum_PhysicsServer2D_JointParam>`
.. _class_PhysicsServer2D_constant_JOINT_PARAM_BIAS:
.. rst-class:: classref-enumeration-constant
:ref:`JointParam<enum_PhysicsServer2D_JointParam>` **JOINT_PARAM_BIAS** = ``0``
Costante per impostare/ottenere la velocità con cui il giunto tira indietro i corpi per soddisfare il vincolo del giunto. Più basso è il valore, più i due corpi possono tirare sul giunto. Il valore predefinito di questo parametro è ``0.0``.
\ **Nota:** In Godot Physics, questo parametro è utilizzato solo per giunti a perno e giunti scanalati.
.. _class_PhysicsServer2D_constant_JOINT_PARAM_MAX_BIAS:
.. rst-class:: classref-enumeration-constant
:ref:`JointParam<enum_PhysicsServer2D_JointParam>` **JOINT_PARAM_MAX_BIAS** = ``1``
Costante per impostare/ottenere la velocità massima con cui il giunto può applicare correzioni. Il valore predefinito di questo parametro è ``3.40282e+38``.
\ **Nota:** In Godot Physics, questo parametro è utilizzato solo per i giunti scanalati.
.. _class_PhysicsServer2D_constant_JOINT_PARAM_MAX_FORCE:
.. rst-class:: classref-enumeration-constant
:ref:`JointParam<enum_PhysicsServer2D_JointParam>` **JOINT_PARAM_MAX_FORCE** = ``2``
Costante per impostare/ottenere la forza massima che il giunto può usare per agire sui due corpi. Il valore predefinito di questo parametro è ``3.40282e+38``.
\ **Nota:** In Godot Physics, questo parametro è usato solo per i giunti scanalati.
.. rst-class:: classref-item-separator
----
.. _enum_PhysicsServer2D_PinJointParam:
.. rst-class:: classref-enumeration
enum **PinJointParam**: :ref:`🔗<enum_PhysicsServer2D_PinJointParam>`
.. _class_PhysicsServer2D_constant_PIN_JOINT_SOFTNESS:
.. rst-class:: classref-enumeration-constant
:ref:`PinJointParam<enum_PhysicsServer2D_PinJointParam>` **PIN_JOINT_SOFTNESS** = ``0``
Costante per impostare/ottenere quanto è flessibile il legame del giunto a perno. Il valore predefinito di questo parametro è ``0.0``.
.. _class_PhysicsServer2D_constant_PIN_JOINT_LIMIT_UPPER:
.. rst-class:: classref-enumeration-constant
:ref:`PinJointParam<enum_PhysicsServer2D_PinJointParam>` **PIN_JOINT_LIMIT_UPPER** = ``1``
La rotazione massima intorno al perno.
.. _class_PhysicsServer2D_constant_PIN_JOINT_LIMIT_LOWER:
.. rst-class:: classref-enumeration-constant
:ref:`PinJointParam<enum_PhysicsServer2D_PinJointParam>` **PIN_JOINT_LIMIT_LOWER** = ``2``
La rotazione minima intorno al perno.
.. _class_PhysicsServer2D_constant_PIN_JOINT_MOTOR_TARGET_VELOCITY:
.. rst-class:: classref-enumeration-constant
:ref:`PinJointParam<enum_PhysicsServer2D_PinJointParam>` **PIN_JOINT_MOTOR_TARGET_VELOCITY** = ``3``
Velocità di destinazione per il motore. In radianti al secondo.
.. rst-class:: classref-item-separator
----
.. _enum_PhysicsServer2D_PinJointFlag:
.. rst-class:: classref-enumeration
enum **PinJointFlag**: :ref:`🔗<enum_PhysicsServer2D_PinJointFlag>`
.. _class_PhysicsServer2D_constant_PIN_JOINT_FLAG_ANGULAR_LIMIT_ENABLED:
.. rst-class:: classref-enumeration-constant
:ref:`PinJointFlag<enum_PhysicsServer2D_PinJointFlag>` **PIN_JOINT_FLAG_ANGULAR_LIMIT_ENABLED** = ``0``
Se ``true``, il perno ha una rotazione massima e minima.
.. _class_PhysicsServer2D_constant_PIN_JOINT_FLAG_MOTOR_ENABLED:
.. rst-class:: classref-enumeration-constant
:ref:`PinJointFlag<enum_PhysicsServer2D_PinJointFlag>` **PIN_JOINT_FLAG_MOTOR_ENABLED** = ``1``
Se ``true``, un motore gira il perno.
.. rst-class:: classref-item-separator
----
.. _enum_PhysicsServer2D_DampedSpringParam:
.. rst-class:: classref-enumeration
enum **DampedSpringParam**: :ref:`🔗<enum_PhysicsServer2D_DampedSpringParam>`
.. _class_PhysicsServer2D_constant_DAMPED_SPRING_REST_LENGTH:
.. rst-class:: classref-enumeration-constant
:ref:`DampedSpringParam<enum_PhysicsServer2D_DampedSpringParam>` **DAMPED_SPRING_REST_LENGTH** = ``0``
Imposta la lunghezza di riposo del giunto a molla. Il giunto cercherà sempre di ritornare a questa lunghezza quando viene separato. Il valore predefinito di questo parametro è la distanza tra i punti di ancoraggio del giunto.
.. _class_PhysicsServer2D_constant_DAMPED_SPRING_STIFFNESS:
.. rst-class:: classref-enumeration-constant
:ref:`DampedSpringParam<enum_PhysicsServer2D_DampedSpringParam>` **DAMPED_SPRING_STIFFNESS** = ``1``
Imposta la rigidità del giunto a molla. Il giunto applica una forza pari alla rigidità moltiplicata per la distanza dalla sua lunghezza di riposo. Il valore predefinito di questo parametro è ``20.0``.
.. _class_PhysicsServer2D_constant_DAMPED_SPRING_DAMPING:
.. rst-class:: classref-enumeration-constant
:ref:`DampedSpringParam<enum_PhysicsServer2D_DampedSpringParam>` **DAMPED_SPRING_DAMPING** = ``2``
Imposta il rapporto di smorzamento del giunto a molla. Un valore pari a 0 indica una molla non smorzata, mentre 1 fa in modo che il sistema raggiunga l'equilibrio il più velocemente possibile (smorzamento critico). Il valore predefinito di questo parametro è ``1.5``.
.. rst-class:: classref-item-separator
----
.. _enum_PhysicsServer2D_CCDMode:
.. rst-class:: classref-enumeration
enum **CCDMode**: :ref:`🔗<enum_PhysicsServer2D_CCDMode>`
.. _class_PhysicsServer2D_constant_CCD_MODE_DISABLED:
.. rst-class:: classref-enumeration-constant
:ref:`CCDMode<enum_PhysicsServer2D_CCDMode>` **CCD_MODE_DISABLED** = ``0``
Disattiva il rilevamento continuo delle collisioni. Questo è il modo più veloce per rilevare le collisioni tra i corpi, ma può non rilevare gli oggetti piccoli e/o in rapido movimento.
.. _class_PhysicsServer2D_constant_CCD_MODE_CAST_RAY:
.. rst-class:: classref-enumeration-constant
:ref:`CCDMode<enum_PhysicsServer2D_CCDMode>` **CCD_MODE_CAST_RAY** = ``1``
Abilita il rilevamento continuo delle collisioni tramite la proiezione di raggi. È più veloce della proiezione di forme, ma meno preciso.
.. _class_PhysicsServer2D_constant_CCD_MODE_CAST_SHAPE:
.. rst-class:: classref-enumeration-constant
:ref:`CCDMode<enum_PhysicsServer2D_CCDMode>` **CCD_MODE_CAST_SHAPE** = ``2``
Abilita il rilevamento continuo delle collisioni tramite la proiezione di forme. È il metodo di rilevamento continuo più lento, e il più preciso.
.. rst-class:: classref-item-separator
----
.. _enum_PhysicsServer2D_AreaBodyStatus:
.. rst-class:: classref-enumeration
enum **AreaBodyStatus**: :ref:`🔗<enum_PhysicsServer2D_AreaBodyStatus>`
.. _class_PhysicsServer2D_constant_AREA_BODY_ADDED:
.. rst-class:: classref-enumeration-constant
:ref:`AreaBodyStatus<enum_PhysicsServer2D_AreaBodyStatus>` **AREA_BODY_ADDED** = ``0``
Il valore del primo parametro e la funzione di callback dell'area ricevuti, quando un oggetto entra in una delle sue forme.
.. _class_PhysicsServer2D_constant_AREA_BODY_REMOVED:
.. rst-class:: classref-enumeration-constant
:ref:`AreaBodyStatus<enum_PhysicsServer2D_AreaBodyStatus>` **AREA_BODY_REMOVED** = ``1``
Il valore del primo parametro e la funzione di callback dell'area ricevuti, quando un oggetto esce da una delle sue forme.
.. rst-class:: classref-item-separator
----
.. _enum_PhysicsServer2D_ProcessInfo:
.. rst-class:: classref-enumeration
enum **ProcessInfo**: :ref:`🔗<enum_PhysicsServer2D_ProcessInfo>`
.. _class_PhysicsServer2D_constant_INFO_ACTIVE_OBJECTS:
.. rst-class:: classref-enumeration-constant
:ref:`ProcessInfo<enum_PhysicsServer2D_ProcessInfo>` **INFO_ACTIVE_OBJECTS** = ``0``
Costante per ottenere il numero di oggetti che non sono in riposo.
.. _class_PhysicsServer2D_constant_INFO_COLLISION_PAIRS:
.. rst-class:: classref-enumeration-constant
:ref:`ProcessInfo<enum_PhysicsServer2D_ProcessInfo>` **INFO_COLLISION_PAIRS** = ``1``
Costante per ottenere il numero di possibili collisioni.
.. _class_PhysicsServer2D_constant_INFO_ISLAND_COUNT:
.. rst-class:: classref-enumeration-constant
:ref:`ProcessInfo<enum_PhysicsServer2D_ProcessInfo>` **INFO_ISLAND_COUNT** = ``2``
Costante per ottenere il numero di regioni nello spazio in cui si potrebbe verificare una collisione.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descrizioni dei metodi
--------------------------------------------
.. _class_PhysicsServer2D_method_area_add_shape:
.. rst-class:: classref-method
|void| **area_add_shape**\ (\ area\: :ref:`RID<class_RID>`, shape\: :ref:`RID<class_RID>`, transform\: :ref:`Transform2D<class_Transform2D>` = Transform2D(1, 0, 0, 1, 0, 0), disabled\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_PhysicsServer2D_method_area_add_shape>`
Aggiunge una forma all'area, con la trasformazione locale specificata. La forma (insieme alle sue proprietà ``transform`` e ``disabled``) è aggiunta a un array di forme e le forme di un'area sono solitamente referenziate dal loro indice in questo array.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_area_attach_canvas_instance_id:
.. rst-class:: classref-method
|void| **area_attach_canvas_instance_id**\ (\ area\: :ref:`RID<class_RID>`, id\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PhysicsServer2D_method_area_attach_canvas_instance_id>`
Collega l'``ObjectID`` di un canvas all'area. Usa :ref:`Object.get_instance_id()<class_Object_method_get_instance_id>` per ottenere l'``ObjectID`` di un :ref:`CanvasLayer<class_CanvasLayer>`.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_area_attach_object_instance_id:
.. rst-class:: classref-method
|void| **area_attach_object_instance_id**\ (\ area\: :ref:`RID<class_RID>`, id\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PhysicsServer2D_method_area_attach_object_instance_id>`
Collega l'``ObjectID`` di un :ref:`Object<class_Object>` all'area. Usa :ref:`Object.get_instance_id()<class_Object_method_get_instance_id>` per ottenere l'``ObjectID`` di un :ref:`CollisionObject2D<class_CollisionObject2D>`.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_area_clear_shapes:
.. rst-class:: classref-method
|void| **area_clear_shapes**\ (\ area\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_PhysicsServer2D_method_area_clear_shapes>`
Rimuove tutte le forme dall'area. Ciò non elimina le forme stesse, quindi è possibile utilizzarle altrove o aggiungerle nuovamente in seguito.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_area_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **area_create**\ (\ ) :ref:`🔗<class_PhysicsServer2D_method_area_create>`
Crea un oggetto area 2D nel server di fisica e restituisce il :ref:`RID<class_RID>` che lo identifica. Le impostazioni predefinite per l'area creata includono gli strati e la maschera di collisione impostati su ``1`` e ``monitorable`` impostato su ``false``.
Usa :ref:`area_add_shape()<class_PhysicsServer2D_method_area_add_shape>` per aggiungervi forme, usa :ref:`area_set_transform()<class_PhysicsServer2D_method_area_set_transform>` per impostarne la trasformazione e usa :ref:`area_set_space()<class_PhysicsServer2D_method_area_set_space>` per aggiungere l'area a uno spazio. Se desideri che l'area sia rilevabile, usa :ref:`area_set_monitorable()<class_PhysicsServer2D_method_area_set_monitorable>`.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_area_get_canvas_instance_id:
.. rst-class:: classref-method
:ref:`int<class_int>` **area_get_canvas_instance_id**\ (\ area\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_PhysicsServer2D_method_area_get_canvas_instance_id>`
Restituisce l'``ObjectID`` del canvas collegato all'area. Usa :ref:`@GlobalScope.instance_from_id()<class_@GlobalScope_method_instance_from_id>` per recuperare un :ref:`CanvasLayer<class_CanvasLayer>` da un ``ObjectID`` diverso da zero.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_area_get_collision_layer:
.. rst-class:: classref-method
:ref:`int<class_int>` **area_get_collision_layer**\ (\ area\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_PhysicsServer2D_method_area_get_collision_layer>`
Restituisce gli strati di fisica a cui l'area appartiene, come una bitmask.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_area_get_collision_mask:
.. rst-class:: classref-method
:ref:`int<class_int>` **area_get_collision_mask**\ (\ area\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_PhysicsServer2D_method_area_get_collision_mask>`
Restituisce lo strato o gli strati di fisica con cui l'area può entrare in contatto, come maschera di bit.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_area_get_object_instance_id:
.. rst-class:: classref-method
:ref:`int<class_int>` **area_get_object_instance_id**\ (\ area\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_PhysicsServer2D_method_area_get_object_instance_id>`
Restituisce l'``ObjectID`` collegato all'area. Usa :ref:`@GlobalScope.instance_from_id()<class_@GlobalScope_method_instance_from_id>` per recuperare un :ref:`Object<class_Object>` da un ``ObjectID`` diverso da zero.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_area_get_param:
.. rst-class:: classref-method
:ref:`Variant<class_Variant>` **area_get_param**\ (\ area\: :ref:`RID<class_RID>`, param\: :ref:`AreaParameter<enum_PhysicsServer2D_AreaParameter>`\ ) |const| :ref:`🔗<class_PhysicsServer2D_method_area_get_param>`
Restituisce il valore del parametro specificato di area.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_area_get_shape:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **area_get_shape**\ (\ area\: :ref:`RID<class_RID>`, shape_idx\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_PhysicsServer2D_method_area_get_shape>`
Restituisce il :ref:`RID<class_RID>` della forma con l'indice fornito nell'array di forme dell'area.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_area_get_shape_count:
.. rst-class:: classref-method
:ref:`int<class_int>` **area_get_shape_count**\ (\ area\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_PhysicsServer2D_method_area_get_shape_count>`
Restituisce il numero di forme aggiunte all'area.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_area_get_shape_transform:
.. rst-class:: classref-method
:ref:`Transform2D<class_Transform2D>` **area_get_shape_transform**\ (\ area\: :ref:`RID<class_RID>`, shape_idx\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_PhysicsServer2D_method_area_get_shape_transform>`
Restituisce la matrice di trasformazione locale della forma con l'indice fornito nell'array di forme dell'area.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_area_get_space:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **area_get_space**\ (\ area\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_PhysicsServer2D_method_area_get_space>`
Restituisce il :ref:`RID<class_RID>` dello spazio assegnato all'area. Restituisce un :ref:`RID<class_RID>` vuoto se non è stato assegnato uno spazio.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_area_get_transform:
.. rst-class:: classref-method
:ref:`Transform2D<class_Transform2D>` **area_get_transform**\ (\ area\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_PhysicsServer2D_method_area_get_transform>`
Restituisce la matrice di trasformazione dell'area.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_area_remove_shape:
.. rst-class:: classref-method
|void| **area_remove_shape**\ (\ area\: :ref:`RID<class_RID>`, shape_idx\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PhysicsServer2D_method_area_remove_shape>`
Rimuove la forma con l'indice specificato dall'array di forme dell'area. La forma stessa non viene eliminata, quindi può continuare a essere utilizzata altrove o aggiunta nuovamente in seguito. Come conseguenza di questa operazione, le forme dell'area che avevano gli indici superiori all'indice ``shape_idx`` avranno il loro indice diminuito di uno.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_area_set_area_monitor_callback:
.. rst-class:: classref-method
|void| **area_set_area_monitor_callback**\ (\ area\: :ref:`RID<class_RID>`, callback\: :ref:`Callable<class_Callable>`\ ) :ref:`🔗<class_PhysicsServer2D_method_area_set_area_monitor_callback>`
Imposta il callback di monitoraggio aree dell'area. Questa callback sarà chiamata quando qualsiasi altra (forma di un') area entra o esce (da una forma di) l'area fornita, e deve prendere i seguenti cinque parametri:
1. un intero ``status``: o :ref:`AREA_BODY_ADDED<class_PhysicsServer2D_constant_AREA_BODY_ADDED>` o :ref:`AREA_BODY_REMOVED<class_PhysicsServer2D_constant_AREA_BODY_REMOVED>` a seconda che la forma dell'altra area sia entrata o uscita dall'area,
2. un :ref:`RID<class_RID>` ``area_rid``: il :ref:`RID<class_RID>` dell'altra area che è entrata o uscita dall'area,
3. un intero ``instance_id``: l'``ObjectID`` associato all'altra area,
4. un intero ``area_shape_idx``: l'indice della forma dell'altra area che è entrata o uscita dall'area,
5. un intero ``self_shape_idx``: l'indice della forma dell'area in cui l'altra area è entrata o uscita dall'area.
Contando (o tenendo traccia) delle forme che entrano ed escono, è possibile determinare se un'area (con tutte le sue forme) sta entrando per la prima volta o sta uscendo per l'ultima volta.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_area_set_collision_layer:
.. rst-class:: classref-method
|void| **area_set_collision_layer**\ (\ area\: :ref:`RID<class_RID>`, layer\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PhysicsServer2D_method_area_set_collision_layer>`
Assegna l'area a uno o più strati di fisica, tramite una maschera di bit.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_area_set_collision_mask:
.. rst-class:: classref-method
|void| **area_set_collision_mask**\ (\ area\: :ref:`RID<class_RID>`, mask\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PhysicsServer2D_method_area_set_collision_mask>`
Imposta quali strati di fisica saranno monitorati dall'area, tramite una maschera di bit.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_area_set_monitor_callback:
.. rst-class:: classref-method
|void| **area_set_monitor_callback**\ (\ area\: :ref:`RID<class_RID>`, callback\: :ref:`Callable<class_Callable>`\ ) :ref:`🔗<class_PhysicsServer2D_method_area_set_monitor_callback>`
Imposta il callback di monitoraggio corpi dell'area. Questa callback sarà chiamata quando qualsiasi altra (forma di un) corpo entra o esce (da una forma di) il corpo fornito, e deve prendere i seguenti cinque parametri:
1. un intero ``status``: o :ref:`AREA_BODY_ADDED<class_PhysicsServer2D_constant_AREA_BODY_ADDED>` o :ref:`AREA_BODY_REMOVED<class_PhysicsServer2D_constant_AREA_BODY_REMOVED>` a seconda che la forma dell'altro corpo sia entrata o uscita dall'area,
2. un :ref:`RID<class_RID>` ``body_rid``: il :ref:`RID<class_RID>` del corpo che è entrato o uscito dall'area,
3. un intero ``instance_id``: l'``ObjectID`` associato al corpo,
4. un intero ``body_shape_idx``: l'indice della forma dell'altra area che è entrata o uscita dall'area,
5. un intero ``self_shape_idx``: l'indice della forma dell'area in cui il corpo è entrato o uscito.
Contando (o tenendo traccia) delle forme che entrano ed escono, è possibile determinare se un corpo (con tutte le sue forme) sta entrando per la prima volta o sta uscendo per l'ultima volta.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_area_set_monitorable:
.. rst-class:: classref-method
|void| **area_set_monitorable**\ (\ area\: :ref:`RID<class_RID>`, monitorable\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_PhysicsServer2D_method_area_set_monitorable>`
Imposta se l'area è monitorabile o meno. Se ``monitorable`` è ``true``, il callback di monitoraggio aree di altre aree sarà chiamato quando questa area entra o esce da esse.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_area_set_param:
.. rst-class:: classref-method
|void| **area_set_param**\ (\ area\: :ref:`RID<class_RID>`, param\: :ref:`AreaParameter<enum_PhysicsServer2D_AreaParameter>`, value\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_PhysicsServer2D_method_area_set_param>`
Imposta il valore del parametro specificato di area.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_area_set_shape:
.. rst-class:: classref-method
|void| **area_set_shape**\ (\ area\: :ref:`RID<class_RID>`, shape_idx\: :ref:`int<class_int>`, shape\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_PhysicsServer2D_method_area_set_shape>`
Sostituisce la forma dell'area all'indice specificato con un'altra forma, senza influenzare le proprietà ``transform`` e ``disabled`` allo stesso indice.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_area_set_shape_disabled:
.. rst-class:: classref-method
|void| **area_set_shape_disabled**\ (\ area\: :ref:`RID<class_RID>`, shape_idx\: :ref:`int<class_int>`, disabled\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_PhysicsServer2D_method_area_set_shape_disabled>`
Imposta la proprietà per disabilitare la forma dell'area con l'indice specificato. Se ``disabled`` è ``true``, la forma non rileverà altre forme che entrano o escono da essa.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_area_set_shape_transform:
.. rst-class:: classref-method
|void| **area_set_shape_transform**\ (\ area\: :ref:`RID<class_RID>`, shape_idx\: :ref:`int<class_int>`, transform\: :ref:`Transform2D<class_Transform2D>`\ ) :ref:`🔗<class_PhysicsServer2D_method_area_set_shape_transform>`
Imposta la matrice di trasformazione locale della forma dell'area con l'indice fornito.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_area_set_space:
.. rst-class:: classref-method
|void| **area_set_space**\ (\ area\: :ref:`RID<class_RID>`, space\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_PhysicsServer2D_method_area_set_space>`
Aggiunge l'area allo spazio specificato, dopo aver rimosso l'area dallo spazio assegnato in precedenza (se presente).
\ **Nota:** Per rimuovere un'area da uno spazio senza aggiungerla immediatamente altrove, utilizza ``PhysicsServer2D.area_set_space(area, RID())``.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_area_set_transform:
.. rst-class:: classref-method
|void| **area_set_transform**\ (\ area\: :ref:`RID<class_RID>`, transform\: :ref:`Transform2D<class_Transform2D>`\ ) :ref:`🔗<class_PhysicsServer2D_method_area_set_transform>`
Imposta la matrice di trasformazione dell'area.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_add_collision_exception:
.. rst-class:: classref-method
|void| **body_add_collision_exception**\ (\ body\: :ref:`RID<class_RID>`, excepted_body\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_PhysicsServer2D_method_body_add_collision_exception>`
Aggiunge ``excepted_body`` alla lista delle eccezioni di collisione del corpo, in modo che le collisioni con esso siano ignorate.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_add_constant_central_force:
.. rst-class:: classref-method
|void| **body_add_constant_central_force**\ (\ body\: :ref:`RID<class_RID>`, force\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_PhysicsServer2D_method_body_add_constant_central_force>`
Aggiunge una forza direzionale costante al corpo. La forza non influisce sulla rotazione. La forza rimane applicata nel tempo finché non viene cancellata con ``PhysicsServer2D.body_set_constant_force(body, Vector2(0, 0))``.
Ciò equivale a usare :ref:`body_add_constant_force()<class_PhysicsServer2D_method_body_add_constant_force>` al centro di massa del corpo.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_add_constant_force:
.. rst-class:: classref-method
|void| **body_add_constant_force**\ (\ body\: :ref:`RID<class_RID>`, force\: :ref:`Vector2<class_Vector2>`, position\: :ref:`Vector2<class_Vector2>` = Vector2(0, 0)\ ) :ref:`🔗<class_PhysicsServer2D_method_body_add_constant_force>`
Aggiunge una forza posizionata costante al corpo. La forza può influenzare la rotazione se ``position`` è diverso dal centro di massa del corpo. La forza rimane applicata nel tempo finché non viene cancellata con ``PhysicsServer2D.body_set_constant_force(body, Vector2(0, 0))``.
\ ``position`` è lo scostamento dall'origine del corpo in coordinate globali.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_add_constant_torque:
.. rst-class:: classref-method
|void| **body_add_constant_torque**\ (\ body\: :ref:`RID<class_RID>`, torque\: :ref:`float<class_float>`\ ) :ref:`🔗<class_PhysicsServer2D_method_body_add_constant_torque>`
Aggiunge una forza rotazionale costante al corpo. La forza non influenza la posizione. La forza rimane applicata nel tempo finché non viene cancellata con ``PhysicsServer2D.body_set_constant_torque(body, 0)``.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_add_shape:
.. rst-class:: classref-method
|void| **body_add_shape**\ (\ body\: :ref:`RID<class_RID>`, shape\: :ref:`RID<class_RID>`, transform\: :ref:`Transform2D<class_Transform2D>` = Transform2D(1, 0, 0, 1, 0, 0), disabled\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_PhysicsServer2D_method_body_add_shape>`
Aggiunge una forma all'area, con la trasformazione locale specificata. La forma (insieme alle sue proprietà ``transform`` e ``disabled``) è aggiunta a un array di forme, e le forme di un corpo sono solitamente referenziate dal loro indice in questo array.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_apply_central_force:
.. rst-class:: classref-method
|void| **body_apply_central_force**\ (\ body\: :ref:`RID<class_RID>`, force\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_PhysicsServer2D_method_body_apply_central_force>`
Applica una forza direzionale al corpo, al centro di massa del corpo. La forza non influenza la rotazione. Una forza è dipendente dal tempo e pensata per essere applicata a ogni aggiornamento della fisica.
Ciò equivale a usare :ref:`body_apply_force()<class_PhysicsServer2D_method_body_apply_force>` al centro di massa del corpo.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_apply_central_impulse:
.. rst-class:: classref-method
|void| **body_apply_central_impulse**\ (\ body\: :ref:`RID<class_RID>`, impulse\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_PhysicsServer2D_method_body_apply_central_impulse>`
Applica un impulso direzionale al corpo, al centro di massa del corpo. L'impulso non influisce sulla 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 :ref:`body_apply_impulse()<class_PhysicsServer2D_method_body_apply_impulse>` al centro di massa del corpo.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_apply_force:
.. rst-class:: classref-method
|void| **body_apply_force**\ (\ body\: :ref:`RID<class_RID>`, force\: :ref:`Vector2<class_Vector2>`, position\: :ref:`Vector2<class_Vector2>` = Vector2(0, 0)\ ) :ref:`🔗<class_PhysicsServer2D_method_body_apply_force>`
Applica una forza posizionata al corpo. La forza può influenzare la rotazione se ``position`` è diverso dal centro di massa del 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.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_apply_impulse:
.. rst-class:: classref-method
|void| **body_apply_impulse**\ (\ body\: :ref:`RID<class_RID>`, impulse\: :ref:`Vector2<class_Vector2>`, position\: :ref:`Vector2<class_Vector2>` = Vector2(0, 0)\ ) :ref:`🔗<class_PhysicsServer2D_method_body_apply_impulse>`
Applica un impulso posizionato al corpo. L'impulso può influenzare la rotazione se ``position`` è diverso dal centro di massa del 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.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_apply_torque:
.. rst-class:: classref-method
|void| **body_apply_torque**\ (\ body\: :ref:`RID<class_RID>`, torque\: :ref:`float<class_float>`\ ) :ref:`🔗<class_PhysicsServer2D_method_body_apply_torque>`
Applica una forza rotazionale al corpo. La forza non influenza la posizione. Una forza è dipendente dal tempo e pensata per essere applicata a ogni aggiornamento della fisica.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_apply_torque_impulse:
.. rst-class:: classref-method
|void| **body_apply_torque_impulse**\ (\ body\: :ref:`RID<class_RID>`, impulse\: :ref:`float<class_float>`\ ) :ref:`🔗<class_PhysicsServer2D_method_body_apply_torque_impulse>`
Applica un impulso rotazionale al corpo. L'impulso non influenza la posizione.
Un impulso è indipendente dal tempo! Applicare un impulso a ogni frame risulterebbe in a una forza dipendente dal frame rate. Per questo motivo, dovrebbe essere utilizzato solo quando si simulano impatti singoli (altrimenti, utilizza le funzioni "_force").
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_attach_canvas_instance_id:
.. rst-class:: classref-method
|void| **body_attach_canvas_instance_id**\ (\ body\: :ref:`RID<class_RID>`, id\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PhysicsServer2D_method_body_attach_canvas_instance_id>`
Collega l'``ObjectID`` di un canvas al corpo. Usa :ref:`Object.get_instance_id()<class_Object_method_get_instance_id>` per ottenere l'``ObjectID`` di un :ref:`CanvasLayer<class_CanvasLayer>`.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_attach_object_instance_id:
.. rst-class:: classref-method
|void| **body_attach_object_instance_id**\ (\ body\: :ref:`RID<class_RID>`, id\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PhysicsServer2D_method_body_attach_object_instance_id>`
Collega l'``ObjectID`` di un :ref:`Object<class_Object>` al corpo. Usa :ref:`Object.get_instance_id()<class_Object_method_get_instance_id>` per ottenere l'``ObjectID`` di un :ref:`CollisionObject2D<class_CollisionObject2D>`.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_clear_shapes:
.. rst-class:: classref-method
|void| **body_clear_shapes**\ (\ body\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_PhysicsServer2D_method_body_clear_shapes>`
Rimuove tutte le forme dal corpo. Ciò non elimina le forme stesse, quindi è possibile utilizzarle altrove o aggiungerle nuovamente in seguito.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **body_create**\ (\ ) :ref:`🔗<class_PhysicsServer2D_method_body_create>`
Crea un oggetto corpo 2D nel server di fisica e restituisce il :ref:`RID<class_RID>` che lo identifica. Le impostazioni predefinite per l'area creata includono gli strati e la maschera di collisione impostati su ``1`` e la modalità del corpo impostata su :ref:`BODY_MODE_RIGID<class_PhysicsServer2D_constant_BODY_MODE_RIGID>`.
Usa :ref:`body_add_shape()<class_PhysicsServer2D_method_body_add_shape>` per aggiungervi forme, usa :ref:`body_set_state()<class_PhysicsServer2D_method_body_set_state>` per impostarne la trasformazione e usa :ref:`body_set_space()<class_PhysicsServer2D_method_body_set_space>` per aggiungere il corpo a uno spazio.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_get_canvas_instance_id:
.. rst-class:: classref-method
:ref:`int<class_int>` **body_get_canvas_instance_id**\ (\ body\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_PhysicsServer2D_method_body_get_canvas_instance_id>`
Restituisce l'``ObjectID`` del canvas collegato al corpo. Usa :ref:`@GlobalScope.instance_from_id()<class_@GlobalScope_method_instance_from_id>` per recuperare un :ref:`CanvasLayer<class_CanvasLayer>` da un ``ObjectID`` diverso da zero.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_get_collision_layer:
.. rst-class:: classref-method
:ref:`int<class_int>` **body_get_collision_layer**\ (\ body\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_PhysicsServer2D_method_body_get_collision_layer>`
Restituisce gli strati di fisica a cui il corpo appartiene, come una bitmask.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_get_collision_mask:
.. rst-class:: classref-method
:ref:`int<class_int>` **body_get_collision_mask**\ (\ body\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_PhysicsServer2D_method_body_get_collision_mask>`
Restituisce lo strato o gli strati di fisica con cui il corpo può entrare in collisione, come maschera di bit.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_get_collision_priority:
.. rst-class:: classref-method
:ref:`float<class_float>` **body_get_collision_priority**\ (\ body\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_PhysicsServer2D_method_body_get_collision_priority>`
Restituisce la priorità di collisione del corpo. È utilizzata nella fase di penetrazione di :ref:`body_test_motion()<class_PhysicsServer2D_method_body_test_motion>`. Maggiore è la priorità, minore sarà la penetrazione nel corpo.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_get_constant_force:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **body_get_constant_force**\ (\ body\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_PhysicsServer2D_method_body_get_constant_force>`
Restituisce la forza posizionale costante totale del corpo applicata durante ogni aggiornamento della fisica.
Vedi :ref:`body_add_constant_force()<class_PhysicsServer2D_method_body_add_constant_force>` e :ref:`body_add_constant_central_force()<class_PhysicsServer2D_method_body_add_constant_central_force>`.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_get_constant_torque:
.. rst-class:: classref-method
:ref:`float<class_float>` **body_get_constant_torque**\ (\ body\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_PhysicsServer2D_method_body_get_constant_torque>`
Restituisce la forza rotazionale costante totale del corpo applicata durante ogni aggiornamento della fisica.
Vedi :ref:`body_add_constant_torque()<class_PhysicsServer2D_method_body_add_constant_torque>`.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_get_continuous_collision_detection_mode:
.. rst-class:: classref-method
:ref:`CCDMode<enum_PhysicsServer2D_CCDMode>` **body_get_continuous_collision_detection_mode**\ (\ body\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_PhysicsServer2D_method_body_get_continuous_collision_detection_mode>`
Restituisce la modalità di rilevamento continuo delle collisioni del corpo.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_get_direct_state:
.. rst-class:: classref-method
:ref:`PhysicsDirectBodyState2D<class_PhysicsDirectBodyState2D>` **body_get_direct_state**\ (\ body\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_PhysicsServer2D_method_body_get_direct_state>`
Restituisce il :ref:`PhysicsDirectBodyState2D<class_PhysicsDirectBodyState2D>` del corpo. Restituisce ``null`` se il corpo è distrutto o non assegnato a uno spazio.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_get_max_contacts_reported:
.. rst-class:: classref-method
:ref:`int<class_int>` **body_get_max_contacts_reported**\ (\ body\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_PhysicsServer2D_method_body_get_max_contacts_reported>`
Restituisce il numero massimo di contatti che il corpo può riportare. Vedi :ref:`body_set_max_contacts_reported()<class_PhysicsServer2D_method_body_set_max_contacts_reported>`.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_get_mode:
.. rst-class:: classref-method
:ref:`BodyMode<enum_PhysicsServer2D_BodyMode>` **body_get_mode**\ (\ body\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_PhysicsServer2D_method_body_get_mode>`
Restituisce la modalità del corpo.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_get_object_instance_id:
.. rst-class:: classref-method
:ref:`int<class_int>` **body_get_object_instance_id**\ (\ body\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_PhysicsServer2D_method_body_get_object_instance_id>`
Restituisce l'``ObjectID`` collegato al corpo. Usa :ref:`@GlobalScope.instance_from_id()<class_@GlobalScope_method_instance_from_id>` per recuperare un :ref:`Object<class_Object>` da un ``ObjectID`` diverso da zero.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_get_param:
.. rst-class:: classref-method
:ref:`Variant<class_Variant>` **body_get_param**\ (\ body\: :ref:`RID<class_RID>`, param\: :ref:`BodyParameter<enum_PhysicsServer2D_BodyParameter>`\ ) |const| :ref:`🔗<class_PhysicsServer2D_method_body_get_param>`
Restituisce il valore del parametro specificato di corpo.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_get_shape:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **body_get_shape**\ (\ body\: :ref:`RID<class_RID>`, shape_idx\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_PhysicsServer2D_method_body_get_shape>`
Restituisce il :ref:`RID<class_RID>` della forma con l'indice fornito nell'array di forme del corpo.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_get_shape_count:
.. rst-class:: classref-method
:ref:`int<class_int>` **body_get_shape_count**\ (\ body\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_PhysicsServer2D_method_body_get_shape_count>`
Restituisce il numero di forme aggiunte al corpo.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_get_shape_transform:
.. rst-class:: classref-method
:ref:`Transform2D<class_Transform2D>` **body_get_shape_transform**\ (\ body\: :ref:`RID<class_RID>`, shape_idx\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_PhysicsServer2D_method_body_get_shape_transform>`
Restituisce la matrice di trasformazione locale della forma con l'indice fornito nell'array di forme dell'area.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_get_space:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **body_get_space**\ (\ body\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_PhysicsServer2D_method_body_get_space>`
Restituisce il :ref:`RID<class_RID>` dello spazio assegnato al corpo. Restituisce un :ref:`RID<class_RID>` vuoto se non è stato assegnato uno spazio.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_get_state:
.. rst-class:: classref-method
:ref:`Variant<class_Variant>` **body_get_state**\ (\ body\: :ref:`RID<class_RID>`, state\: :ref:`BodyState<enum_PhysicsServer2D_BodyState>`\ ) |const| :ref:`🔗<class_PhysicsServer2D_method_body_get_state>`
Restituisce il valore dello stato specificato del corpo.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_is_omitting_force_integration:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **body_is_omitting_force_integration**\ (\ body\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_PhysicsServer2D_method_body_is_omitting_force_integration>`
Restituisce ``true`` se il corpo omette l'integrazione predefinita delle forze. Vedi :ref:`body_set_omit_force_integration()<class_PhysicsServer2D_method_body_set_omit_force_integration>`.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_remove_collision_exception:
.. rst-class:: classref-method
|void| **body_remove_collision_exception**\ (\ body\: :ref:`RID<class_RID>`, excepted_body\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_PhysicsServer2D_method_body_remove_collision_exception>`
Rimuove ``excepted_body`` dalla lista delle eccezioni di collisione del corpo, in modo che le collisioni con esso non siano più ignorate.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_remove_shape:
.. rst-class:: classref-method
|void| **body_remove_shape**\ (\ body\: :ref:`RID<class_RID>`, shape_idx\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PhysicsServer2D_method_body_remove_shape>`
Rimuove la forma con l'indice specificato dall'array di forme del corpo. La forma stessa non viene eliminata, quindi può continuare a essere utilizzata altrove o aggiunta nuovamente in seguito. Come conseguenza di questa operazione, le forme del corpo che avevano gli indici superiori all'indice ``shape_idx`` avranno il loro indice diminuito di uno.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_reset_mass_properties:
.. rst-class:: classref-method
|void| **body_reset_mass_properties**\ (\ body\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_PhysicsServer2D_method_body_reset_mass_properties>`
Ripristina l'inerzia e il centro di massa predefiniti del corpo in base alle sue forme. Ciò annulla tutti i valori personalizzati impostati in precedenza tramite :ref:`body_set_param()<class_PhysicsServer2D_method_body_set_param>`.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_set_axis_velocity:
.. rst-class:: classref-method
|void| **body_set_axis_velocity**\ (\ body\: :ref:`RID<class_RID>`, axis_velocity\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_PhysicsServer2D_method_body_set_axis_velocity>`
Modifica la velocità lineare del corpo in modo che la sua proiezione sull'asse ``axis_velocity.normalized()`` sia esattamente ``axis_velocity.length()``. Ciò è utile per un comportamento di salto.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_set_collision_layer:
.. rst-class:: classref-method
|void| **body_set_collision_layer**\ (\ body\: :ref:`RID<class_RID>`, layer\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PhysicsServer2D_method_body_set_collision_layer>`
Imposta lo strato o gli strati di fisica a cui appartiene il corpo, tramite una maschera di bit.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_set_collision_mask:
.. rst-class:: classref-method
|void| **body_set_collision_mask**\ (\ body\: :ref:`RID<class_RID>`, mask\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PhysicsServer2D_method_body_set_collision_mask>`
Imposta lo strato o gli strati di fisica con cui il corpo può entrare in collisione, tramite una maschera di bit.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_set_collision_priority:
.. rst-class:: classref-method
|void| **body_set_collision_priority**\ (\ body\: :ref:`RID<class_RID>`, priority\: :ref:`float<class_float>`\ ) :ref:`🔗<class_PhysicsServer2D_method_body_set_collision_priority>`
Imposta la priorità di collisione del corpo. Questa è utilizzata nella fase di depenetrazione in :ref:`body_test_motion()<class_PhysicsServer2D_method_body_test_motion>`. Maggiore è la priorità, minore sarà la penetrazione dentro il corpo.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_set_constant_force:
.. rst-class:: classref-method
|void| **body_set_constant_force**\ (\ body\: :ref:`RID<class_RID>`, force\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_PhysicsServer2D_method_body_set_constant_force>`
Imposta la forza posizionale costante totale del corpo, applicata durante ogni aggiornamento della fisica.
Vedi :ref:`body_add_constant_force()<class_PhysicsServer2D_method_body_add_constant_force>` e :ref:`body_add_constant_central_force()<class_PhysicsServer2D_method_body_add_constant_central_force>`.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_set_constant_torque:
.. rst-class:: classref-method
|void| **body_set_constant_torque**\ (\ body\: :ref:`RID<class_RID>`, torque\: :ref:`float<class_float>`\ ) :ref:`🔗<class_PhysicsServer2D_method_body_set_constant_torque>`
Imposta la forza rotazione costante totale del corpo, applicata durante ogni aggiornamento della fisica.
Vedi :ref:`body_add_constant_torque()<class_PhysicsServer2D_method_body_add_constant_torque>`.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_set_continuous_collision_detection_mode:
.. rst-class:: classref-method
|void| **body_set_continuous_collision_detection_mode**\ (\ body\: :ref:`RID<class_RID>`, mode\: :ref:`CCDMode<enum_PhysicsServer2D_CCDMode>`\ ) :ref:`🔗<class_PhysicsServer2D_method_body_set_continuous_collision_detection_mode>`
Imposta la modalità di rilevamento continuo delle collisioni.
Il rilevamento continuo delle collisioni cerca di prevedere dove un corpo in movimento entrerebbe in collisione tra gli aggiornamenti della fisica, invece di spostarlo e correggerne il movimento in caso di collisione.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_set_force_integration_callback:
.. rst-class:: classref-method
|void| **body_set_force_integration_callback**\ (\ body\: :ref:`RID<class_RID>`, callable\: :ref:`Callable<class_Callable>`, userdata\: :ref:`Variant<class_Variant>` = null\ ) :ref:`🔗<class_PhysicsServer2D_method_body_set_force_integration_callback>`
Imposta la funzione di callback per l'integrazione personalizzata della forza del corpo su ``callable``. Utilizza un :ref:`Callable<class_Callable>` vuoto (``Callable()``) per cancellare il callback personalizzato.
La funzione ``callable`` sarà chiamata a ogni tick di fisica, prima dell'integrazione standard della forza (vedi :ref:`body_set_omit_force_integration()<class_PhysicsServer2D_method_body_set_omit_force_integration>`). Può essere utilizzata, ad esempio, per aggiornare la velocità lineare e angolare del corpo in base al contatto con altri corpi.
Se ``userdata`` non è ``null``, la funzione ``callable`` deve accettare i due parametri seguenti:
1. ``state``: un :ref:`PhysicsDirectBodyState2D<class_PhysicsDirectBodyState2D>` utilizzato per recuperare e modificare lo stato del corpo,
2. ``userdata``: un :ref:`Variant<class_Variant>`; il suo valore sarà l'``userdata`` passato in questo metodo.
Se ``userdata`` è ``null``, allora ``callable`` deve accettare solo il parametro ``state``.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_set_max_contacts_reported:
.. rst-class:: classref-method
|void| **body_set_max_contacts_reported**\ (\ body\: :ref:`RID<class_RID>`, amount\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PhysicsServer2D_method_body_set_max_contacts_reported>`
Imposta il numero massimo di contatti che il corpo può riportare. Se ``amount`` è maggiore di zero, il corpo terrà traccia al massimo questo numero di contatti con altri corpi.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_set_mode:
.. rst-class:: classref-method
|void| **body_set_mode**\ (\ body\: :ref:`RID<class_RID>`, mode\: :ref:`BodyMode<enum_PhysicsServer2D_BodyMode>`\ ) :ref:`🔗<class_PhysicsServer2D_method_body_set_mode>`
Imposta la modalità del corpo.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_set_omit_force_integration:
.. rst-class:: classref-method
|void| **body_set_omit_force_integration**\ (\ body\: :ref:`RID<class_RID>`, enable\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_PhysicsServer2D_method_body_set_omit_force_integration>`
Imposta se il corpo omette l'integrazione standard della forza. Se ``enable`` è ``true``, il corpo non utilizzerà automaticamente le forze, le coppie e lo smorzamento applicati per aggiornare la velocità lineare e angolare del corpo. In questo caso, è possibile utilizzare :ref:`body_set_force_integration_callback()<class_PhysicsServer2D_method_body_set_force_integration_callback>` per aggiornare manualmente la velocità lineare e angolare.
Questo metodo viene chiamato quando la proprietà :ref:`RigidBody2D.custom_integrator<class_RigidBody2D_property_custom_integrator>` viene impostata.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_set_param:
.. rst-class:: classref-method
|void| **body_set_param**\ (\ body\: :ref:`RID<class_RID>`, param\: :ref:`BodyParameter<enum_PhysicsServer2D_BodyParameter>`, value\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_PhysicsServer2D_method_body_set_param>`
Imposta il valore del parametro specificato di corpo.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_set_shape:
.. rst-class:: classref-method
|void| **body_set_shape**\ (\ body\: :ref:`RID<class_RID>`, shape_idx\: :ref:`int<class_int>`, shape\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_PhysicsServer2D_method_body_set_shape>`
Sostituisce la forma del corpo all'indice specificato con un'altra forma, senza influenzare le proprietà ``transform``, ``disabled`` e one-way collision allo stesso indice.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_set_shape_as_one_way_collision:
.. rst-class:: classref-method
|void| **body_set_shape_as_one_way_collision**\ (\ body\: :ref:`RID<class_RID>`, shape_idx\: :ref:`int<class_int>`, enable\: :ref:`bool<class_bool>`, margin\: :ref:`float<class_float>`\ ) :ref:`🔗<class_PhysicsServer2D_method_body_set_shape_as_one_way_collision>`
Imposta le proprietà di collisione unidirezionale della forma con l'indice specificato del corpo. Se ``enable`` è ``true``, la direzione di collisione unidirezionale fornita dall'asse locale verso l'alto della forma ``body_get_shape_transform(body, shape_idx).y`` sarà utilizzata per ignorare le collisioni con la forma nella direzione opposta, e per garantire che la penetrazione dei corpi cinematici avvenga in questa direzione.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_set_shape_disabled:
.. rst-class:: classref-method
|void| **body_set_shape_disabled**\ (\ body\: :ref:`RID<class_RID>`, shape_idx\: :ref:`int<class_int>`, disabled\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_PhysicsServer2D_method_body_set_shape_disabled>`
Imposta la proprietà per disabilitare la forma con l'indice specificato del corpo. Se ``disabled`` è ``true``, la forma sarà ignorata in tutti i rilevamenti di collisione.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_set_shape_transform:
.. rst-class:: classref-method
|void| **body_set_shape_transform**\ (\ body\: :ref:`RID<class_RID>`, shape_idx\: :ref:`int<class_int>`, transform\: :ref:`Transform2D<class_Transform2D>`\ ) :ref:`🔗<class_PhysicsServer2D_method_body_set_shape_transform>`
Imposta la matrice di trasformazione locale della forma con l'indice fornito del corpo.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_set_space:
.. rst-class:: classref-method
|void| **body_set_space**\ (\ body\: :ref:`RID<class_RID>`, space\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_PhysicsServer2D_method_body_set_space>`
Aggiunge il corpo allo spazio fornito, dopo averlo rimosso dallo spazio assegnato in precedenza (se presente). Se la modalità del corpo è impostata su :ref:`BODY_MODE_RIGID<class_PhysicsServer2D_constant_BODY_MODE_RIGID>`, l'aggiunta del corpo a uno spazio avrà i seguenti effetti aggiuntivi:
- Se il parametro :ref:`BODY_PARAM_CENTER_OF_MASS<class_PhysicsServer2D_constant_BODY_PARAM_CENTER_OF_MASS>` non è mai stato impostato esplicitamente, il valore di tale parametro verrà ricalcolato in base alle forme del corpo.
- Se il parametro :ref:`BODY_PARAM_INERTIA<class_PhysicsServer2D_constant_BODY_PARAM_INERTIA>` è impostato su un valore ``<= 0.0``, il valore di tale parametro verrà ricalcolato in base alle forme, alla massa e al centro di massa del corpo.
\ **Nota:** Per rimuovere un corpo da uno spazio senza aggiungerlo immediatamente altrove, utilizza ``PhysicsServer2D.body_set_space(body, RID())``.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_set_state:
.. rst-class:: classref-method
|void| **body_set_state**\ (\ body\: :ref:`RID<class_RID>`, state\: :ref:`BodyState<enum_PhysicsServer2D_BodyState>`, value\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_PhysicsServer2D_method_body_set_state>`
Imposta il valore dello stato di un corpo.
\ **Nota:** Il cambio di stato non ha un effetto immediato. Lo stato cambierà nel prossimo frame di fisica.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_set_state_sync_callback:
.. rst-class:: classref-method
|void| **body_set_state_sync_callback**\ (\ body\: :ref:`RID<class_RID>`, callable\: :ref:`Callable<class_Callable>`\ ) :ref:`🔗<class_PhysicsServer2D_method_body_set_state_sync_callback>`
Imposta la funzione di callback per la sincronizzazione dello stato del corpo su ``callable``. Utilizza un :ref:`Callable<class_Callable>` vuoto (``Callable()``) per cancellare il callback.
La funzione ``callable`` verrà chiamata a ogni frame di fisica, supponendo che il corpo fosse attivo durante il tick di fisica precedente, e può essere utilizzata per recuperare lo stato più recente dal server di fisica.
La funzione ``callable`` deve accettare i seguenti parametri:
1. ``state``: un :ref:`PhysicsDirectBodyState2D<class_PhysicsDirectBodyState2D>`, utilizzato per recuperare lo stato del corpo.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_test_motion:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **body_test_motion**\ (\ body\: :ref:`RID<class_RID>`, parameters\: :ref:`PhysicsTestMotionParameters2D<class_PhysicsTestMotionParameters2D>`, result\: :ref:`PhysicsTestMotionResult2D<class_PhysicsTestMotionResult2D>` = null\ ) :ref:`🔗<class_PhysicsServer2D_method_body_test_motion>`
Restituisce ``true`` se si verificherebbe una collisione spostando il corpo lungo un vettore di movimento da un punto specificato nello spazio. Vedi :ref:`PhysicsTestMotionParameters2D<class_PhysicsTestMotionParameters2D>` per i parametri di movimento disponibili. Facoltativamente, è possibile passare un oggetto :ref:`PhysicsTestMotionResult2D<class_PhysicsTestMotionResult2D>`, che verrà usato per memorizzare le informazioni sulla collisione risultante.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_capsule_shape_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **capsule_shape_create**\ (\ ) :ref:`🔗<class_PhysicsServer2D_method_capsule_shape_create>`
Crea una forma di capsula 2D nel server di fisica e restituisce il :ref:`RID<class_RID>` che la identifica. Usa :ref:`shape_set_data()<class_PhysicsServer2D_method_shape_set_data>` per impostare l'altezza e il raggio della capsula.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_circle_shape_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **circle_shape_create**\ (\ ) :ref:`🔗<class_PhysicsServer2D_method_circle_shape_create>`
Crea una forma di cerchio 2D nel server di fisica e restituisce il :ref:`RID<class_RID>` che la identifica. Usa :ref:`shape_set_data()<class_PhysicsServer2D_method_shape_set_data>` per impostare il raggio del cerchio.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_concave_polygon_shape_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **concave_polygon_shape_create**\ (\ ) :ref:`🔗<class_PhysicsServer2D_method_concave_polygon_shape_create>`
Crea una forma di poligono concavo 2D nel server di fisica e restituisce il :ref:`RID<class_RID>` che la identifica. Usa :ref:`shape_set_data()<class_PhysicsServer2D_method_shape_set_data>` per impostare il segmenti del poligono concavo.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_convex_polygon_shape_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **convex_polygon_shape_create**\ (\ ) :ref:`🔗<class_PhysicsServer2D_method_convex_polygon_shape_create>`
Crea una forma di poligono convesso 2D nel server di fisica e restituisce il :ref:`RID<class_RID>` che la identifica. Usa :ref:`shape_set_data()<class_PhysicsServer2D_method_shape_set_data>` per impostare i punti del poligono convesso.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_damped_spring_joint_get_param:
.. rst-class:: classref-method
:ref:`float<class_float>` **damped_spring_joint_get_param**\ (\ joint\: :ref:`RID<class_RID>`, param\: :ref:`DampedSpringParam<enum_PhysicsServer2D_DampedSpringParam>`\ ) |const| :ref:`🔗<class_PhysicsServer2D_method_damped_spring_joint_get_param>`
Restituisce il valore del parametro specificato di giunto a molla smorzata.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_damped_spring_joint_set_param:
.. rst-class:: classref-method
|void| **damped_spring_joint_set_param**\ (\ joint\: :ref:`RID<class_RID>`, param\: :ref:`DampedSpringParam<enum_PhysicsServer2D_DampedSpringParam>`, value\: :ref:`float<class_float>`\ ) :ref:`🔗<class_PhysicsServer2D_method_damped_spring_joint_set_param>`
Imposta il valore del parametro specificato di giunto a molla smorzata.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_free_rid:
.. rst-class:: classref-method
|void| **free_rid**\ (\ rid\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_PhysicsServer2D_method_free_rid>`
Distrugge uno qualsiasi degli oggetti creati dal PhysicsServer2D. Se il :ref:`RID<class_RID>` passato non è uno degli oggetti che possono essere creati dal PhysicsServer2D, un errore verrà stampato sulla console.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_get_process_info:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_process_info**\ (\ process_info\: :ref:`ProcessInfo<enum_PhysicsServer2D_ProcessInfo>`\ ) :ref:`🔗<class_PhysicsServer2D_method_get_process_info>`
Restituisce il valore di uno stato del motore di fisica specificato da ``process_info``.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_joint_clear:
.. rst-class:: classref-method
|void| **joint_clear**\ (\ joint\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_PhysicsServer2D_method_joint_clear>`
Distrugge il giunto con il :ref:`RID<class_RID>` specificato, crea un nuovo giunto non inizializzato e fa in modo che il :ref:`RID<class_RID>` si riferisca a questo nuovo giunto.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_joint_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **joint_create**\ (\ ) :ref:`🔗<class_PhysicsServer2D_method_joint_create>`
Crea un giunto 2D nel server di fisica e restituisce il :ref:`RID<class_RID>` che lo identifica. Per impostare il tipo di giunto, usa :ref:`joint_make_damped_spring()<class_PhysicsServer2D_method_joint_make_damped_spring>`, :ref:`joint_make_groove()<class_PhysicsServer2D_method_joint_make_groove>` o :ref:`joint_make_pin()<class_PhysicsServer2D_method_joint_make_pin>`. Usa :ref:`joint_set_param()<class_PhysicsServer2D_method_joint_set_param>` per impostare i parametri generici del giunto.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_joint_disable_collisions_between_bodies:
.. rst-class:: classref-method
|void| **joint_disable_collisions_between_bodies**\ (\ joint\: :ref:`RID<class_RID>`, disable\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_PhysicsServer2D_method_joint_disable_collisions_between_bodies>`
Imposta se i corpi attaccati al :ref:`Joint2D<class_Joint2D>` entreranno in collisione tra loro.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_joint_get_param:
.. rst-class:: classref-method
:ref:`float<class_float>` **joint_get_param**\ (\ joint\: :ref:`RID<class_RID>`, param\: :ref:`JointParam<enum_PhysicsServer2D_JointParam>`\ ) |const| :ref:`🔗<class_PhysicsServer2D_method_joint_get_param>`
Restituisce il valore del parametro specificato di giunto.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_joint_get_type:
.. rst-class:: classref-method
:ref:`JointType<enum_PhysicsServer2D_JointType>` **joint_get_type**\ (\ joint\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_PhysicsServer2D_method_joint_get_type>`
Restituisce il tipo del giunto.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_joint_is_disabled_collisions_between_bodies:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **joint_is_disabled_collisions_between_bodies**\ (\ joint\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_PhysicsServer2D_method_joint_is_disabled_collisions_between_bodies>`
Restituisce se i corpi attaccati al :ref:`Joint2D<class_Joint2D>` entreranno in collisione tra loro.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_joint_make_damped_spring:
.. rst-class:: classref-method
|void| **joint_make_damped_spring**\ (\ joint\: :ref:`RID<class_RID>`, anchor_a\: :ref:`Vector2<class_Vector2>`, anchor_b\: :ref:`Vector2<class_Vector2>`, body_a\: :ref:`RID<class_RID>`, body_b\: :ref:`RID<class_RID>` = RID()\ ) :ref:`🔗<class_PhysicsServer2D_method_joint_make_damped_spring>`
Rende il giunto un giunto a molla smorzata, fissato al punto ``anchor_a`` (indicato in coordinate globali) sul corpo ``body_a`` e al punto ``anchor_b`` (indicato in coordinate globali) sul corpo ``body_b``. Per impostare i parametri specifici della molla smorzata, vedi :ref:`damped_spring_joint_set_param()<class_PhysicsServer2D_method_damped_spring_joint_set_param>`.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_joint_make_groove:
.. rst-class:: classref-method
|void| **joint_make_groove**\ (\ joint\: :ref:`RID<class_RID>`, groove1_a\: :ref:`Vector2<class_Vector2>`, groove2_a\: :ref:`Vector2<class_Vector2>`, anchor_b\: :ref:`Vector2<class_Vector2>`, body_a\: :ref:`RID<class_RID>` = RID(), body_b\: :ref:`RID<class_RID>` = RID()\ ) :ref:`🔗<class_PhysicsServer2D_method_joint_make_groove>`
Rende il giunto un giunto scanalato.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_joint_make_pin:
.. rst-class:: classref-method
|void| **joint_make_pin**\ (\ joint\: :ref:`RID<class_RID>`, anchor\: :ref:`Vector2<class_Vector2>`, body_a\: :ref:`RID<class_RID>`, body_b\: :ref:`RID<class_RID>` = RID()\ ) :ref:`🔗<class_PhysicsServer2D_method_joint_make_pin>`
Rende il giunto un giunto a perno. Se ``body_b`` è un :ref:`RID<class_RID>` vuoto, allora ``body_a`` è bloccato al punto ``anchor`` (specificato in coordinate globali); altrimenti, ``body_a`` è bloccato a ``body_b`` nel punto ``anchor`` (specificato in coordinate globali). Per impostare i parametri specifici del giunto a perno, vedi :ref:`pin_joint_set_param()<class_PhysicsServer2D_method_pin_joint_set_param>`.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_joint_set_param:
.. rst-class:: classref-method
|void| **joint_set_param**\ (\ joint\: :ref:`RID<class_RID>`, param\: :ref:`JointParam<enum_PhysicsServer2D_JointParam>`, value\: :ref:`float<class_float>`\ ) :ref:`🔗<class_PhysicsServer2D_method_joint_set_param>`
Imposta il valore del parametro specificato di giunto.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_pin_joint_get_flag:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **pin_joint_get_flag**\ (\ joint\: :ref:`RID<class_RID>`, flag\: :ref:`PinJointFlag<enum_PhysicsServer2D_PinJointFlag>`\ ) |const| :ref:`🔗<class_PhysicsServer2D_method_pin_joint_get_flag>`
Ottiene un flag di un giunto a perno.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_pin_joint_get_param:
.. rst-class:: classref-method
:ref:`float<class_float>` **pin_joint_get_param**\ (\ joint\: :ref:`RID<class_RID>`, param\: :ref:`PinJointParam<enum_PhysicsServer2D_PinJointParam>`\ ) |const| :ref:`🔗<class_PhysicsServer2D_method_pin_joint_get_param>`
Restituisce il valore di un parametro di un giunto a perno.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_pin_joint_set_flag:
.. rst-class:: classref-method
|void| **pin_joint_set_flag**\ (\ joint\: :ref:`RID<class_RID>`, flag\: :ref:`PinJointFlag<enum_PhysicsServer2D_PinJointFlag>`, enabled\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_PhysicsServer2D_method_pin_joint_set_flag>`
Imposta un flag di un giunto a perno.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_pin_joint_set_param:
.. rst-class:: classref-method
|void| **pin_joint_set_param**\ (\ joint\: :ref:`RID<class_RID>`, param\: :ref:`PinJointParam<enum_PhysicsServer2D_PinJointParam>`, value\: :ref:`float<class_float>`\ ) :ref:`🔗<class_PhysicsServer2D_method_pin_joint_set_param>`
Imposta un parametro di un giunto a perno.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_rectangle_shape_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **rectangle_shape_create**\ (\ ) :ref:`🔗<class_PhysicsServer2D_method_rectangle_shape_create>`
Crea una forma di rettangolo 2D nel server di fisica e restituisce il :ref:`RID<class_RID>` che la identifica. Usa :ref:`shape_set_data()<class_PhysicsServer2D_method_shape_set_data>` per impostare le mezze estensioni del rettangolo.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_segment_shape_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **segment_shape_create**\ (\ ) :ref:`🔗<class_PhysicsServer2D_method_segment_shape_create>`
Crea una forma di segmento 2D nel server di fisica e restituisce il :ref:`RID<class_RID>` che la identifica. Usa :ref:`shape_set_data()<class_PhysicsServer2D_method_shape_set_data>` per impostare i punti di inizio e fine del segmento.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_separation_ray_shape_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **separation_ray_shape_create**\ (\ ) :ref:`🔗<class_PhysicsServer2D_method_separation_ray_shape_create>`
Crea una forma di raggio di separazione 2D nel server di fisica e restituisce il :ref:`RID<class_RID>` che la identifica. Usa :ref:`shape_set_data()<class_PhysicsServer2D_method_shape_set_data>` per impostare le proprietà ``length`` e ``slide_on_slope`` della forma.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_set_active:
.. rst-class:: classref-method
|void| **set_active**\ (\ active\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_PhysicsServer2D_method_set_active>`
Attiva o disattiva il server di fisica 2D. Se ``active`` è ``false``, il server di fisica non farà nulla nel suo passaggio di fisica.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_shape_get_data:
.. rst-class:: classref-method
:ref:`Variant<class_Variant>` **shape_get_data**\ (\ shape\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_PhysicsServer2D_method_shape_get_data>`
Restituisce i dati di forma che definiscono la configurazione della forma, come le mezze estensioni di un rettangolo o i segmenti di una forma concava. Vedi :ref:`shape_set_data()<class_PhysicsServer2D_method_shape_set_data>` per il formato preciso di questi dati in ogni caso.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_shape_get_type:
.. rst-class:: classref-method
:ref:`ShapeType<enum_PhysicsServer2D_ShapeType>` **shape_get_type**\ (\ shape\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_PhysicsServer2D_method_shape_get_type>`
Restituisce il tipo della forma.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_shape_set_data:
.. rst-class:: classref-method
|void| **shape_set_data**\ (\ shape\: :ref:`RID<class_RID>`, data\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_PhysicsServer2D_method_shape_set_data>`
Imposta i dati della forma che definiscono la configurazione della forma. I ``data`` da passare dipendono dal tipo di forma (vedere :ref:`shape_get_type()<class_PhysicsServer2D_method_shape_get_type>`):
- :ref:`SHAPE_WORLD_BOUNDARY<class_PhysicsServer2D_constant_SHAPE_WORLD_BOUNDARY>`: un array di lunghezza due contenente una direzione :ref:`Vector2<class_Vector2>` ``normal`` e una distanza :ref:`float<class_float>` ``d``,
- :ref:`SHAPE_SEPARATION_RAY<class_PhysicsServer2D_constant_SHAPE_SEPARATION_RAY>`: un dizionario contenente la chiave ``length`` con un valore :ref:`float<class_float>` e la chiave ``slide_on_slope`` con un valore :ref:`bool<class_bool>`,
- :ref:`SHAPE_SEGMENT<class_PhysicsServer2D_constant_SHAPE_SEGMENT>`: un :ref:`Rect2<class_Rect2>` ``rect`` contenente il primo punto del segmento in ``rect.position`` e il secondo punto del segmento in ``rect.size``,
- :ref:`SHAPE_CIRCLE<class_PhysicsServer2D_constant_SHAPE_CIRCLE>`: un :ref:`float<class_float>` ``radius``,
- :ref:`SHAPE_RECTANGLE<class_PhysicsServer2D_constant_SHAPE_RECTANGLE>`: un :ref:`Vector2<class_Vector2>` ``half_extents``,
- :ref:`SHAPE_CAPSULE<class_PhysicsServer2D_constant_SHAPE_CAPSULE>`: un array di lunghezza due (o un :ref:`Vector2<class_Vector2>`) contenente un :ref:`float<class_float>` ``height`` e un :ref:`float<class_float>` ``radius``,
- :ref:`SHAPE_CONVEX_POLYGON<class_PhysicsServer2D_constant_SHAPE_CONVEX_POLYGON>`: un :ref:`PackedVector2Array<class_PackedVector2Array>` di punti che definiscono un poligono convesso in ordine antiorario (la normale esterna in senso orario di ogni segmento formato da punti consecutivi è calcolata internamente), oppure un :ref:`PackedFloat32Array<class_PackedFloat32Array>` di lunghezza divisibile per quattro in modo che ogni 4-tupla di :ref:`float<class_float>` contenga le coordinate di un punto, seguite dalle coordinate del vettore normale esterno in senso orario al segmento tra il punto attuale e il punto successivo,
- :ref:`SHAPE_CONCAVE_POLYGON<class_PhysicsServer2D_constant_SHAPE_CONCAVE_POLYGON>`: un :ref:`PackedVector2Array<class_PackedVector2Array>` di lunghezza divisibile per due (ciascuno coppia di punti forma un segmento).
\ **Attenzione:** Nel caso di :ref:`SHAPE_CONVEX_POLYGON<class_PhysicsServer2D_constant_SHAPE_CONVEX_POLYGON>`, questo metodo non verifica se i punti forniti formano effettivamente un poligono convesso (a differenza della proprietà :ref:`CollisionPolygon2D.polygon<class_CollisionPolygon2D_property_polygon>`).
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_space_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **space_create**\ (\ ) :ref:`🔗<class_PhysicsServer2D_method_space_create>`
Crea uno spazio 2D nel server di fisica e restituisce il :ref:`RID<class_RID>` che lo identifica. Uno spazio contiene corpi e aree e controlla l'avanzamento della simulazione fisica degli oggetti contenuti in esso.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_space_get_direct_state:
.. rst-class:: classref-method
:ref:`PhysicsDirectSpaceState2D<class_PhysicsDirectSpaceState2D>` **space_get_direct_state**\ (\ space\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_PhysicsServer2D_method_space_get_direct_state>`
Restituisce lo stato di uno spazio, un :ref:`PhysicsDirectSpaceState2D<class_PhysicsDirectSpaceState2D>`. Questo oggetto può essere utilizzato per richieste di collisione o intersezione.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_space_get_param:
.. rst-class:: classref-method
:ref:`float<class_float>` **space_get_param**\ (\ space\: :ref:`RID<class_RID>`, param\: :ref:`SpaceParameter<enum_PhysicsServer2D_SpaceParameter>`\ ) |const| :ref:`🔗<class_PhysicsServer2D_method_space_get_param>`
Restituisce il valore del parametro specificato di spazio.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_space_is_active:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **space_is_active**\ (\ space\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_PhysicsServer2D_method_space_is_active>`
Restituisce ``true`` se lo spazio è attivo.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_space_set_active:
.. rst-class:: classref-method
|void| **space_set_active**\ (\ space\: :ref:`RID<class_RID>`, active\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_PhysicsServer2D_method_space_set_active>`
Attiva o disattiva lo spazio. Se ``active`` è ``false``, il server di fisica non farà nulla con questo spazio nel suo passaggio di fisica.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_space_set_param:
.. rst-class:: classref-method
|void| **space_set_param**\ (\ space\: :ref:`RID<class_RID>`, param\: :ref:`SpaceParameter<enum_PhysicsServer2D_SpaceParameter>`, value\: :ref:`float<class_float>`\ ) :ref:`🔗<class_PhysicsServer2D_method_space_set_param>`
Imposta il valore del parametro specificato di spazio.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_world_boundary_shape_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **world_boundary_shape_create**\ (\ ) :ref:`🔗<class_PhysicsServer2D_method_world_boundary_shape_create>`
Crea una forma di confine del mondo 2D nel server di fisica e restituisce il :ref:`RID<class_RID>` che la identifica. Usa :ref:`shape_set_data()<class_PhysicsServer2D_method_shape_set_data>` per impostare le proprietà di direzione normale e distanza della forma.
.. |virtual| replace:: :abbr:`virtual (Questo metodo dovrebbe solitamente essere sovrascritto dall'utente per aver un effetto.)`
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
.. |const| replace:: :abbr:`const (Questo metodo non ha effetti collaterali. Non modifica alcuna variabile appartenente all'istanza.)`
.. |vararg| replace:: :abbr:`vararg (Questo metodo accetta qualsiasi numero di argomenti oltre a quelli descritti qui.)`
.. |constructor| replace:: :abbr:`constructor (Questo metodo è utilizzato per creare un tipo.)`
.. |static| replace:: :abbr:`static (Questo metodo non necessita di alcun'istanza per essere chiamato, quindi può essere chiamato direttamente usando il nome della classe.)`
.. |operator| replace:: :abbr:`operator (Questo metodo descrive un operatore valido da usare con questo tipo come operando di sinistra.)`
.. |bitfield| replace:: :abbr:`BitField (Questo valore è un intero composto da una maschera di bit dei seguenti flag.)`
.. |void| replace:: :abbr:`void (Nessun valore restituito.)`
Reference in New Issue View Git Blame Copy Permalink