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/es/class_physicsserver2d.rst
Rémi Verschelde 369fd84a4f Sync classref with 4.5 branch
2025-12-19 14:34:07 +01:00

2636 lines
194 KiB
ReStructuredText
Raw Permalink Blame History

:github_url: hide
.. _class_PhysicsServer2D:
PhysicsServer2D
===============
**Hereda:** :ref:`Object<class_Object>`
**Heredado por:** :ref:`PhysicsServer2DExtension<class_PhysicsServer2DExtension>`
Una interfaz de servidor para el acceso de bajo nivel a la física 2D.
.. rst-class:: classref-introduction-group
Descripción
----------------------
PhysicsServer2D is the server responsible for all 2D physics. It can directly create and manipulate all physics objects:
- A *space* is a self-contained world for a physics simulation. It contains bodies, areas, and joints. Its state can be queried for collision and intersection information, and several parameters of the simulation can be modified.
- A *shape* is a geometric shape such as a circle, a rectangle, a capsule, or a polygon. It can be used for collision detection by adding it to a body/area, possibly with an extra transformation relative to the body/area's origin. Bodies/areas can have multiple (transformed) shapes added to them, and a single shape can be added to bodies/areas multiple times with different local transformations.
- A *body* is a physical object which can be in static, kinematic, or rigid mode. Its state (such as position and velocity) can be queried and updated. A force integration callback can be set to customize the body's physics.
- An *area* is a region in space which can be used to detect bodies and areas entering and exiting it. A body monitoring callback can be set to report entering/exiting body shapes, and similarly an area monitoring callback can be set. Gravity and damping can be overridden within the area by setting area parameters.
- A *joint* is a constraint, either between two bodies or on one body relative to a point. Parameters such as the joint bias and the rest length of a spring joint can be adjusted.
Physics objects in **PhysicsServer2D** may be created and manipulated independently; they do not have to be tied to nodes in the scene tree.
\ **Note:** All the 2D physics nodes use the physics server internally. Adding a physics node to the scene tree will cause a corresponding physics object to be created in the physics server. A rigid body node registers a callback that updates the node's transform with the transform of the respective body object in the physics server (every physics update). An area node registers a callback to inform the area node about overlaps with the respective area object in the physics server. The raycast node queries the direct state of the relevant space in the physics server.
.. rst-class:: classref-reftable-group
Métodos
--------------
.. 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
Enumeraciones
--------------------------
.. _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``
Constant to set/get the maximum distance a pair of bodies has to move before their collision status has to be recalculated. The default value of this parameter is :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``
Constant to set/get the maximum distance a shape can be from another before they are considered separated and the contact is discarded. The default value of this parameter is :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``
Constant to set/get the maximum distance a shape can penetrate another shape before it is considered a collision. The default value of this parameter is :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``
Constant to set/get the default solver bias for all physics contacts. A solver bias is a factor controlling how much two objects "rebound", after overlapping, to avoid leaving them in that state because of numerical imprecision. The default value of this parameter is :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``
Constante para establecer/obtener el umbral de velocidad lineal de actividad. Un cuerpo marcado como potencialmente inactivo tanto para la velocidad lineal como para la angular se pondrá a dormir después del tiempo dado. El valor predeterminado de este parámetro es :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``
Constante para establecer/obtener el umbral de velocidad angular de actividad. Un cuerpo marcado como potencialmente inactivo tanto para la velocidad lineal como para la angular se pondrá a dormir después del tiempo dado. El valor predeterminado de este parámetro es :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``
Constante para establecer/obtener el tiempo máximo de actividad. Un cuerpo marcado como potencialmente inactivo tanto para la velocidad lineal como para la angular se pondrá a dormir después de este tiempo. El valor predeterminado de este parámetro es :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``
Constante para establecer/obtener el sesgo del solucionador por defecto para todas las restricciones de la física. Un sesgo del solucionador es un factor que controla cuánto "rebotan" dos objetos, después de violar una restricción, para evitar dejarlos en ese estado debido a la imprecisión numérica.
.. _class_PhysicsServer2D_constant_SPACE_PARAM_SOLVER_ITERATIONS:
.. rst-class:: classref-enumeration-constant
:ref:`SpaceParameter<enum_PhysicsServer2D_SpaceParameter>` **SPACE_PARAM_SOLVER_ITERATIONS** = ``8``
Constant to set/get the number of solver iterations for all contacts and constraints. The greater the number of iterations, the more accurate the collisions will be. However, a greater number of iterations requires more CPU power, which can decrease performance. The default value of this parameter is :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``
Esta es la constante para crear formas de límites del mundo. Una forma de límite del mundo es una línea *infinita* con un punto de origen y una normal. Por lo tanto, se puede utilizar para comprobaciones de delante/detrás.
.. _class_PhysicsServer2D_constant_SHAPE_SEPARATION_RAY:
.. rst-class:: classref-enumeration-constant
:ref:`ShapeType<enum_PhysicsServer2D_ShapeType>` **SHAPE_SEPARATION_RAY** = ``1``
Esta es la constante para crear formas de rayo de separación. Un rayo de separación se define por una longitud y se separa de lo que está tocando su punto final lejano. Útil para los controladores de personajes.
.. _class_PhysicsServer2D_constant_SHAPE_SEGMENT:
.. rst-class:: classref-enumeration-constant
:ref:`ShapeType<enum_PhysicsServer2D_ShapeType>` **SHAPE_SEGMENT** = ``2``
Esta es la constante para crear formas de segmentos. Una forma de segmento es una línea *finita* desde un punto A hasta un punto B. Se puede comprobar si hay intersecciones.
.. _class_PhysicsServer2D_constant_SHAPE_CIRCLE:
.. rst-class:: classref-enumeration-constant
:ref:`ShapeType<enum_PhysicsServer2D_ShapeType>` **SHAPE_CIRCLE** = ``3``
Esta es la constante para crear formas de círculos. Una forma de círculo sólo tiene un radio. Puede ser usado para intersecciones y controles internos y externos.
.. _class_PhysicsServer2D_constant_SHAPE_RECTANGLE:
.. rst-class:: classref-enumeration-constant
:ref:`ShapeType<enum_PhysicsServer2D_ShapeType>` **SHAPE_RECTANGLE** = ``4``
Esta es la constante para crear formas de rectángulo. Una forma de rectángulo se define por un ancho y una altura. Se puede usar para intersecciones y controles internos y externos.
.. _class_PhysicsServer2D_constant_SHAPE_CAPSULE:
.. rst-class:: classref-enumeration-constant
:ref:`ShapeType<enum_PhysicsServer2D_ShapeType>` **SHAPE_CAPSULE** = ``5``
Esta es la constante para crear formas de cápsulas. La forma de una cápsula se define por un radio y una longitud. Se puede usar para intersecciones y controles internos y externos.
.. _class_PhysicsServer2D_constant_SHAPE_CONVEX_POLYGON:
.. rst-class:: classref-enumeration-constant
:ref:`ShapeType<enum_PhysicsServer2D_ShapeType>` **SHAPE_CONVEX_POLYGON** = ``6``
Esta es la constante para crear formas de polígonos convexos. Un polígono se define por una lista de puntos. Se puede utilizar para intersecciones y comprobaciones de dentro/fuera.
.. _class_PhysicsServer2D_constant_SHAPE_CONCAVE_POLYGON:
.. rst-class:: classref-enumeration-constant
:ref:`ShapeType<enum_PhysicsServer2D_ShapeType>` **SHAPE_CONCAVE_POLYGON** = ``7``
Esta es la constante para crear formas poligonales cóncavas. Un polígono se define por una lista de puntos. Puede ser usado para comprobar las intersecciones, pero no para comprobar el interior/exterior.
.. _class_PhysicsServer2D_constant_SHAPE_CUSTOM:
.. rst-class:: classref-enumeration-constant
:ref:`ShapeType<enum_PhysicsServer2D_ShapeType>` **SHAPE_CUSTOM** = ``8``
Esta constante es utilizada internamente por el motor. Cualquier intento de crear este tipo de forma resulta en un error.
.. 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``
Constante para establecer/obtener el modo de sobrescritura de gravedad en un área. Véase :ref:`AreaSpaceOverrideMode<enum_PhysicsServer2D_AreaSpaceOverrideMode>` para ver los valores posibles. El valor por defecto de este parámetro es :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``
Constante para establecer/obtener la fuerza de gravedad en un área. El valor por defecto de este parámetro es ``9.80665``.
.. _class_PhysicsServer2D_constant_AREA_PARAM_GRAVITY_VECTOR:
.. rst-class:: classref-enumeration-constant
:ref:`AreaParameter<enum_PhysicsServer2D_AreaParameter>` **AREA_PARAM_GRAVITY_VECTOR** = ``2``
Constante para establecer/obtener el vector/centro de gravedad en un área. El valor por defecto de este parámetro es ``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``
Constante para establecer/obtener si el vector de gravedad de un área es una dirección, o un punto central. El valor por defecto de este parámetro es ``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``
Constante para establecer/obtener la distancia a la que la fuerza de la gravedad es igual a la gravedad controlada por :ref:`AREA_PARAM_GRAVITY<class_PhysicsServer2D_constant_AREA_PARAM_GRAVITY>`. Por ejemplo, en un planeta de 100 píxeles de radio con una gravedad superficial de 4.0 px/s², establece la gravedad a 4.0 y la distancia de unidad a 100.0. La gravedad tendrá una caída de acuerdo con la ley del inverso del cuadrado, por lo que en el ejemplo, a 200 píxeles del centro la gravedad será de 1.0 px/s² (el doble de la distancia, 1/4 de la gravedad), a 50 píxeles será de 16.0 px/s² (la mitad de la distancia, 4 veces la gravedad), y así sucesivamente.
Lo anterior solo es cierto cuando la distancia de unidad es un número positivo. Cuando la distancia de unidad se establece en 0.0, la gravedad será constante independientemente de la distancia. El valor por defecto de este parámetro es ``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``
Constante para establecer/obtener el modo de sobrescritura de la amortiguación lineal en un área. Véase :ref:`AreaSpaceOverrideMode<enum_PhysicsServer2D_AreaSpaceOverrideMode>` para ver los valores posibles. El valor por defecto de este parámetro es :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``
Constante para establecer/obtener el factor de amortiguación lineal de un área. El valor por defecto de este parámetro es ``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``
Constante para establecer/obtener el modo de sobrescritura de amortiguación angular en un área. Véase :ref:`AreaSpaceOverrideMode<enum_PhysicsServer2D_AreaSpaceOverrideMode>` para ver los valores posibles. El valor por defecto de este parámetro es :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``
Constante para establecer/obtener el factor de amortiguación angular de un área. El valor por defecto de este parámetro es ``1.0``.
.. _class_PhysicsServer2D_constant_AREA_PARAM_PRIORITY:
.. rst-class:: classref-enumeration-constant
:ref:`AreaParameter<enum_PhysicsServer2D_AreaParameter>` **AREA_PARAM_PRIORITY** = ``9``
Constante para establecer/obtener la prioridad (orden de procesamiento) de un área. El valor por defecto de este parámetro es ``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``
Esta zona no afecta a la gravedad/humedad. Estas son generalmente áreas que existen sólo para detectar colisiones, y objetos que entran o salen de ellas.
.. _class_PhysicsServer2D_constant_AREA_SPACE_OVERRIDE_COMBINE:
.. rst-class:: classref-enumeration-constant
:ref:`AreaSpaceOverrideMode<enum_PhysicsServer2D_AreaSpaceOverrideMode>` **AREA_SPACE_OVERRIDE_COMBINE** = ``1``
Esta área añade sus valores de gravedad/humedad a lo que se ha calculado hasta ahora. De esta manera, muchas áreas superpuestas pueden combinar su física para hacer efectos interesantes.
.. _class_PhysicsServer2D_constant_AREA_SPACE_OVERRIDE_COMBINE_REPLACE:
.. rst-class:: classref-enumeration-constant
:ref:`AreaSpaceOverrideMode<enum_PhysicsServer2D_AreaSpaceOverrideMode>` **AREA_SPACE_OVERRIDE_COMBINE_REPLACE** = ``2``
Esta área añade sus valores de gravedad/amortiguación a lo que se ha calculado hasta ahora. Luego deja de tener en cuenta el resto de las áreas, incluso la predeterminada.
.. _class_PhysicsServer2D_constant_AREA_SPACE_OVERRIDE_REPLACE:
.. rst-class:: classref-enumeration-constant
:ref:`AreaSpaceOverrideMode<enum_PhysicsServer2D_AreaSpaceOverrideMode>` **AREA_SPACE_OVERRIDE_REPLACE** = ``3``
Esta área reemplaza cualquier gravedad/amortiguación, incluso la predeterminada, y deja de tener en cuenta el resto de las áreas.
.. _class_PhysicsServer2D_constant_AREA_SPACE_OVERRIDE_REPLACE_COMBINE:
.. rst-class:: classref-enumeration-constant
:ref:`AreaSpaceOverrideMode<enum_PhysicsServer2D_AreaSpaceOverrideMode>` **AREA_SPACE_OVERRIDE_REPLACE_COMBINE** = ``4``
Esta área reemplaza cualquier gravedad/amortiguación calculada hasta ahora, pero sigue calculando el resto de las áreas, hasta la predeterminada.
.. 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``
Constante para cuerpos estáticos. En este modo, un cuerpo solo puede ser movido por el código del usuario y no colisiona con otros cuerpos a lo largo de su trayectoria cuando se mueve.
.. _class_PhysicsServer2D_constant_BODY_MODE_KINEMATIC:
.. rst-class:: classref-enumeration-constant
:ref:`BodyMode<enum_PhysicsServer2D_BodyMode>` **BODY_MODE_KINEMATIC** = ``1``
Constante para cuerpos cinemáticos. En este modo, un cuerpo solo puede ser movido por el código del usuario y colisiona con otros cuerpos a lo largo de su trayectoria.
.. _class_PhysicsServer2D_constant_BODY_MODE_RIGID:
.. rst-class:: classref-enumeration-constant
:ref:`BodyMode<enum_PhysicsServer2D_BodyMode>` **BODY_MODE_RIGID** = ``2``
Constante para cuerpos rígidos. En este modo, un cuerpo puede ser empujado por otros cuerpos y se le aplican fuerzas.
.. _class_PhysicsServer2D_constant_BODY_MODE_RIGID_LINEAR:
.. rst-class:: classref-enumeration-constant
:ref:`BodyMode<enum_PhysicsServer2D_BodyMode>` **BODY_MODE_RIGID_LINEAR** = ``3``
Constante para cuerpos rígidos lineales. En este modo, un cuerpo no puede rotar, y solo su velocidad lineal se ve afectada por fuerzas externas.
.. 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``
Constante para establecer/obtener el factor de rebote de un cuerpo. El valor por defecto de este parámetro es ``0.0``.
.. _class_PhysicsServer2D_constant_BODY_PARAM_FRICTION:
.. rst-class:: classref-enumeration-constant
:ref:`BodyParameter<enum_PhysicsServer2D_BodyParameter>` **BODY_PARAM_FRICTION** = ``1``
Constante para establecer/obtener la fricción de un cuerpo. El valor por defecto de este parámetro es ``1.0``.
.. _class_PhysicsServer2D_constant_BODY_PARAM_MASS:
.. rst-class:: classref-enumeration-constant
:ref:`BodyParameter<enum_PhysicsServer2D_BodyParameter>` **BODY_PARAM_MASS** = ``2``
Constante para establecer/obtener la masa de un cuerpo. El valor por defecto de este parámetro es ``1.0``. Si el modo del cuerpo se establece en :ref:`BODY_MODE_RIGID<class_PhysicsServer2D_constant_BODY_MODE_RIGID>`, entonces establecer este parámetro tendrá los siguientes efectos adicionales:
- Si el parámetro :ref:`BODY_PARAM_CENTER_OF_MASS<class_PhysicsServer2D_constant_BODY_PARAM_CENTER_OF_MASS>` nunca ha sido establecido explícitamente, entonces el valor de ese parámetro será recalculado basándose en las formas del cuerpo.
- Si el parámetro :ref:`BODY_PARAM_INERTIA<class_PhysicsServer2D_constant_BODY_PARAM_INERTIA>` se establece en un valor ``<= 0.0``, entonces el valor de ese parámetro será recalculado basándose en las formas, masa y centro de masa del cuerpo.
.. _class_PhysicsServer2D_constant_BODY_PARAM_INERTIA:
.. rst-class:: classref-enumeration-constant
:ref:`BodyParameter<enum_PhysicsServer2D_BodyParameter>` **BODY_PARAM_INERTIA** = ``3``
Constante para establecer/obtener la inercia de un cuerpo. El valor por defecto de este parámetro es ``0.0``. Si la inercia del cuerpo se establece a un valor ``<= 0.0``, entonces la inercia será recalculada basándose en las formas, masa y centro de masa del cuerpo.
.. _class_PhysicsServer2D_constant_BODY_PARAM_CENTER_OF_MASS:
.. rst-class:: classref-enumeration-constant
:ref:`BodyParameter<enum_PhysicsServer2D_BodyParameter>` **BODY_PARAM_CENTER_OF_MASS** = ``4``
Constante para establecer/obtener la posición del centro de masa de un cuerpo en el sistema de coordenadas local del cuerpo. El valor por defecto de este parámetro es ``Vector2(0, 0)``. Si este parámetro nunca se establece explícitamente, se recalcula en función de las formas del cuerpo al establecer el parámetro :ref:`BODY_PARAM_MASS<class_PhysicsServer2D_constant_BODY_PARAM_MASS>` o al llamar a :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``
Constante para establecer/obtener el multiplicador de gravedad de un cuerpo. El valor por defecto de este parámetro es ``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``
Constante para establecer/obtener el modo de amortiguación lineal de un cuerpo. Véase :ref:`BodyDampMode<enum_PhysicsServer2D_BodyDampMode>` para ver los valores posibles. El valor predeterminado de este parámetro es :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``
Constante para establecer/obtener el modo de amortiguación angular de un cuerpo. Véase :ref:`BodyDampMode<enum_PhysicsServer2D_BodyDampMode>` para ver los valores posibles. El valor predeterminado de este parámetro es :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``
Constante para establecer/obtener el factor de amortiguación lineal de un cuerpo. El valor por defecto de este parámetro es ``0.0``.
.. _class_PhysicsServer2D_constant_BODY_PARAM_ANGULAR_DAMP:
.. rst-class:: classref-enumeration-constant
:ref:`BodyParameter<enum_PhysicsServer2D_BodyParameter>` **BODY_PARAM_ANGULAR_DAMP** = ``9``
Constante para establecer/obtener el factor de amortiguación angular de un cuerpo. El valor por defecto de este parámetro es ``0.0``.
.. _class_PhysicsServer2D_constant_BODY_PARAM_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`BodyParameter<enum_PhysicsServer2D_BodyParameter>` **BODY_PARAM_MAX** = ``10``
Representa el tamaño del enum :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``
El valor de amortiguación del cuerpo se suma a cualquier valor establecido en las áreas o al valor por defecto.
.. _class_PhysicsServer2D_constant_BODY_DAMP_MODE_REPLACE:
.. rst-class:: classref-enumeration-constant
:ref:`BodyDampMode<enum_PhysicsServer2D_BodyDampMode>` **BODY_DAMP_MODE_REPLACE** = ``1``
El valor de amortiguación del cuerpo reemplaza cualquier valor establecido en las áreas o al valor por defecto.
.. 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``
Constante para establecer/obtener la matriz de transformación de la corriente del cuerpo.
.. _class_PhysicsServer2D_constant_BODY_STATE_LINEAR_VELOCITY:
.. rst-class:: classref-enumeration-constant
:ref:`BodyState<enum_PhysicsServer2D_BodyState>` **BODY_STATE_LINEAR_VELOCITY** = ``1``
Constante para establecer/obtener la actual velocidad lineal del cuerpo.
.. _class_PhysicsServer2D_constant_BODY_STATE_ANGULAR_VELOCITY:
.. rst-class:: classref-enumeration-constant
:ref:`BodyState<enum_PhysicsServer2D_BodyState>` **BODY_STATE_ANGULAR_VELOCITY** = ``2``
Constante para establecer/obtener la actual velocidad angular del cuerpo.
.. _class_PhysicsServer2D_constant_BODY_STATE_SLEEPING:
.. rst-class:: classref-enumeration-constant
:ref:`BodyState<enum_PhysicsServer2D_BodyState>` **BODY_STATE_SLEEPING** = ``3``
Constante para dormir/despertar un cuerpo, o para saber si está durmiendo.
.. _class_PhysicsServer2D_constant_BODY_STATE_CAN_SLEEP:
.. rst-class:: classref-enumeration-constant
:ref:`BodyState<enum_PhysicsServer2D_BodyState>` **BODY_STATE_CAN_SLEEP** = ``4``
Constante para establecer/obtener si el cuerpo puede dormir.
.. 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``
Constante para crear articulaciones de alfileres.
.. _class_PhysicsServer2D_constant_JOINT_TYPE_GROOVE:
.. rst-class:: classref-enumeration-constant
:ref:`JointType<enum_PhysicsServer2D_JointType>` **JOINT_TYPE_GROOVE** = ``1``
Constantemente para crear uniones ranuradas.
.. _class_PhysicsServer2D_constant_JOINT_TYPE_DAMPED_SPRING:
.. rst-class:: classref-enumeration-constant
:ref:`JointType<enum_PhysicsServer2D_JointType>` **JOINT_TYPE_DAMPED_SPRING** = ``2``
Constante para crear juntas de resorte amortiguadas.
.. _class_PhysicsServer2D_constant_JOINT_TYPE_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`JointType<enum_PhysicsServer2D_JointType>` **JOINT_TYPE_MAX** = ``3``
Representa el tamaño del enum :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``
Constante para establecer/obtener la rapidez con la que la articulación tira de los cuerpos hacia atrás para satisfacer la restricción de la articulación. Cuanto menor sea el valor, más podrán tirar los dos cuerpos de la articulación. El valor por defecto de este parámetro es ``0.0``.
\ **Nota:** En las físicas de Godot, este parámetro solo se utiliza para las articulaciones de pasador y de ranura.
.. _class_PhysicsServer2D_constant_JOINT_PARAM_MAX_BIAS:
.. rst-class:: classref-enumeration-constant
:ref:`JointParam<enum_PhysicsServer2D_JointParam>` **JOINT_PARAM_MAX_BIAS** = ``1``
Constante para establecer/obtener la velocidad máxima con la que la articulación puede aplicar correcciones. El valor por defecto de este parámetro es ``3.40282e+38``.
\ **Nota:** En las físicas de Godot, este parámetro solo se utiliza para articulaciones de ranura.
.. _class_PhysicsServer2D_constant_JOINT_PARAM_MAX_FORCE:
.. rst-class:: classref-enumeration-constant
:ref:`JointParam<enum_PhysicsServer2D_JointParam>` **JOINT_PARAM_MAX_FORCE** = ``2``
Constante para establecer/obtener la fuerza máxima que la articulación puede usar para actuar sobre los dos cuerpos. El valor por defecto de este parámetro es ``3.40282e+38``.
\ **Nota:** En las físicas de Godot, este parámetro solo se utiliza para articulaciones de ranura.
.. 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``
Constante para establecer/obtener cuánto se puede flexionar la unión de la articulación de pasador. El valor por defecto de este parámetro es ``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 rotación máxima alrededor del pin.
.. _class_PhysicsServer2D_constant_PIN_JOINT_LIMIT_LOWER:
.. rst-class:: classref-enumeration-constant
:ref:`PinJointParam<enum_PhysicsServer2D_PinJointParam>` **PIN_JOINT_LIMIT_LOWER** = ``2``
La rotación mínima alrededor del pin.
.. _class_PhysicsServer2D_constant_PIN_JOINT_MOTOR_TARGET_VELOCITY:
.. rst-class:: classref-enumeration-constant
:ref:`PinJointParam<enum_PhysicsServer2D_PinJointParam>` **PIN_JOINT_MOTOR_TARGET_VELOCITY** = ``3``
Velocidad objetivo para el motor. En radianes por segundo.
.. 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``
Si es ``true``, el pasador tiene una rotación máxima y mínima.
.. _class_PhysicsServer2D_constant_PIN_JOINT_FLAG_MOTOR_ENABLED:
.. rst-class:: classref-enumeration-constant
:ref:`PinJointFlag<enum_PhysicsServer2D_PinJointFlag>` **PIN_JOINT_FLAG_MOTOR_ENABLED** = ``1``
Si es ``true``, un motor gira el pasador.
.. 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``
Establece la longitud de reposo de la articulación de resorte. La articulación siempre intentará volver a esta longitud cuando se separe. El valor por defecto de este parámetro es la distancia entre los puntos de anclaje de la articulación.
.. _class_PhysicsServer2D_constant_DAMPED_SPRING_STIFFNESS:
.. rst-class:: classref-enumeration-constant
:ref:`DampedSpringParam<enum_PhysicsServer2D_DampedSpringParam>` **DAMPED_SPRING_STIFFNESS** = ``1``
Establece la rigidez de la articulación de resorte. La articulación aplica una fuerza igual a la rigidez multiplicada por la distancia desde su longitud de reposo. El valor por defecto de este parámetro es ``20.0``.
.. _class_PhysicsServer2D_constant_DAMPED_SPRING_DAMPING:
.. rst-class:: classref-enumeration-constant
:ref:`DampedSpringParam<enum_PhysicsServer2D_DampedSpringParam>` **DAMPED_SPRING_DAMPING** = ``2``
Establece la relación de amortiguación de la articulación de resorte. Un valor de 0 indica un resorte sin amortiguación, mientras que 1 hace que el sistema alcance el equilibrio lo más rápido posible (amortiguación crítico). El valor por defecto de este parámetro es ``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``
Desactiva la detección de colisión continua. Es la forma más rápida de detectar colisiones corporales, pero puede pasar por alto objetos pequeños y/o que se mueven rápidamente.
.. _class_PhysicsServer2D_constant_CCD_MODE_CAST_RAY:
.. rst-class:: classref-enumeration-constant
:ref:`CCDMode<enum_PhysicsServer2D_CCDMode>` **CCD_MODE_CAST_RAY** = ``1``
Permite la detección continua de colisiones mediante la emisión de rayos. Es más rápido que el "shapecasting", pero menos preciso.
.. _class_PhysicsServer2D_constant_CCD_MODE_CAST_SHAPE:
.. rst-class:: classref-enumeration-constant
:ref:`CCDMode<enum_PhysicsServer2D_CCDMode>` **CCD_MODE_CAST_SHAPE** = ``2``
Permite la detección continua de colisiones mediante el modelado. Es el método más lento de CCD, y el más 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``
El valor del primer parámetro y la función de retrollamada de área recibe, cuando un objeto entra en una de sus formas.
.. _class_PhysicsServer2D_constant_AREA_BODY_REMOVED:
.. rst-class:: classref-enumeration-constant
:ref:`AreaBodyStatus<enum_PhysicsServer2D_AreaBodyStatus>` **AREA_BODY_REMOVED** = ``1``
El valor del primer parámetro y la función de llamada de área recibe, cuando un objeto sale de una de sus formas.
.. 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``
Constante para obtener el número de objetos que no están durmiendo.
.. _class_PhysicsServer2D_constant_INFO_COLLISION_PAIRS:
.. rst-class:: classref-enumeration-constant
:ref:`ProcessInfo<enum_PhysicsServer2D_ProcessInfo>` **INFO_COLLISION_PAIRS** = ``1``
Constante para obtener el número de posibles colisiones.
.. _class_PhysicsServer2D_constant_INFO_ISLAND_COUNT:
.. rst-class:: classref-enumeration-constant
:ref:`ProcessInfo<enum_PhysicsServer2D_ProcessInfo>` **INFO_ISLAND_COUNT** = ``2``
Constante para obtener el número de regiones espaciales donde podría ocurrir una colisión.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descripciones de Métodos
------------------------------------------------
.. _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>`
Añade una forma al área, con la transformación local dada. La forma (junto con sus propiedades ``transform`` y ``disabled``) se añade a un array de formas, y las formas de un área se referencian normalmente por su índice en este 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>`
Adjunta el ``ObjectID`` de un canvas al área. Utiliza :ref:`Object.get_instance_id()<class_Object_method_get_instance_id>` para obtener el ``ObjectID`` de 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>`
Adjunta el ``ObjectID`` de un :ref:`Object<class_Object>` al área. Utiliza :ref:`Object.get_instance_id()<class_Object_method_get_instance_id>` para obtener el ``ObjectID`` de 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>`
Elimina todas las formas del área. Esto no elimina las formas en sí mismas, por lo que pueden seguir utilizándose en otra parte o volverse a agregar más tarde.
.. 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>`
Creates a 2D area object in the physics server, and returns the :ref:`RID<class_RID>` that identifies it. The default settings for the created area include a collision layer and mask set to ``1``, and ``monitorable`` set to ``false``.
Use :ref:`area_add_shape()<class_PhysicsServer2D_method_area_add_shape>` to add shapes to it, use :ref:`area_set_transform()<class_PhysicsServer2D_method_area_set_transform>` to set its transform, and use :ref:`area_set_space()<class_PhysicsServer2D_method_area_set_space>` to add the area to a space. If you want the area to be detectable use :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>`
Devuelve el ``ObjectID`` del canvas adjunto al área. Utiliza :ref:`@GlobalScope.instance_from_id()<class_@GlobalScope_method_instance_from_id>` para recuperar un :ref:`CanvasLayer<class_CanvasLayer>` de un ``ObjectID`` distinto de cero.
.. 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>`
Devuelve la capa o capas físicas a las que pertenece el área, como una máscara de bits.
.. 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>`
Devuelve la capa o capas físicas con las que el área puede entrar en contacto, como una máscara de bits.
.. 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>`
Devuelve el ``ObjectID`` adjunto al área. Utiliza :ref:`@GlobalScope.instance_from_id()<class_@GlobalScope_method_instance_from_id>` para recuperar un :ref:`Object<class_Object>` de un ``ObjectID`` distinto de cero.
.. 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>`
Devuelve el valor del parámetro de área dado.
.. 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>`
Devuelve el :ref:`RID<class_RID>` de la forma con el índice dado en el array de formas del área.
.. 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>`
Devuelve el número de formas agregadas al área.
.. 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>`
Devuelve el array de transformación local de la forma con el índice dado en el array de formas del área.
.. 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>`
Devuelve el :ref:`RID<class_RID>` del espacio asignado al área. Devuelve un :ref:`RID<class_RID>` vacío si no se ha asignado ningún espacio.
.. 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>`
Devuelve la matriz de transformación del área.
.. 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>`
Elimina la forma con el índice dado del array de formas del área. La forma en sí no se elimina, por lo que puede seguir utilizándose en otra parte o volver a añadirse más tarde. Como resultado de esta operación, las formas del área que solían tener índices mayores que ``shape_idx`` verán su índice disminuido en 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>`
Sets the area's area monitor callback. This callback will be called when any other (shape of an) area enters or exits (a shape of) the given area, and must take the following five parameters:
1. an integer ``status``: either :ref:`AREA_BODY_ADDED<class_PhysicsServer2D_constant_AREA_BODY_ADDED>` or :ref:`AREA_BODY_REMOVED<class_PhysicsServer2D_constant_AREA_BODY_REMOVED>` depending on whether the other area's shape entered or exited the area,
2. an :ref:`RID<class_RID>` ``area_rid``: the :ref:`RID<class_RID>` of the other area that entered or exited the area,
3. an integer ``instance_id``: the ``ObjectID`` attached to the other area,
4. an integer ``area_shape_idx``: the index of the shape of the other area that entered or exited the area,
5. an integer ``self_shape_idx``: the index of the shape of the area where the other area entered or exited.
By counting (or keeping track of) the shapes that enter and exit, it can be determined if an area (with all its shapes) is entering for the first time or exiting for the last time.
.. 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>`
Asigna el área a una o varias capas físicas, mediante una máscara de bits.
.. 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>`
Establece qué capas físicas monitoreará el área, mediante una máscara de bits.
.. 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>`
Sets the area's body monitor callback. This callback will be called when any other (shape of a) body enters or exits (a shape of) the given area, and must take the following five parameters:
1. an integer ``status``: either :ref:`AREA_BODY_ADDED<class_PhysicsServer2D_constant_AREA_BODY_ADDED>` or :ref:`AREA_BODY_REMOVED<class_PhysicsServer2D_constant_AREA_BODY_REMOVED>` depending on whether the other body shape entered or exited the area,
2. an :ref:`RID<class_RID>` ``body_rid``: the :ref:`RID<class_RID>` of the body that entered or exited the area,
3. an integer ``instance_id``: the ``ObjectID`` attached to the body,
4. an integer ``body_shape_idx``: the index of the shape of the body that entered or exited the area,
5. an integer ``self_shape_idx``: the index of the shape of the area where the body entered or exited.
By counting (or keeping track of) the shapes that enter and exit, it can be determined if a body (with all its shapes) is entering for the first time or exiting for the last time.
.. 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>`
Establece si el área es monitoreable o no. Si ``monitorable`` es ``true``, se llamará al callback de monitoreo de área de otras áreas cuando esta área entre o salga de ellas.
.. 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>`
Establece el valor del parámetro de área dado.
.. 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>`
Reemplaza la forma del área en el índice dado por otra forma, sin afectar las propiedades ``transform`` y ``disabled`` en el mismo índice.
.. 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>`
Establece la propiedad disabled de la forma del área con el índice dado. Si ``disabled`` es ``true``, entonces la forma no detectará otras formas que entren o salgan de ella.
.. 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>`
Sets the local transform matrix of the area's shape with the given index.
.. 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>`
Añade el área al espacio dado, después de eliminar el área del espacio asignado previamente (si lo hay).
\ **Nota:** Para eliminar un área de un espacio sin añadirla inmediatamente de nuevo en otro lugar, utiliza ``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>`
Establece la matriz de transformación del área.
.. 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>`
Añade ``excepted_body`` a la lista de excepciones de colisión del cuerpo, para que se ignoren las colisiones con él.
.. 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>`
Adds a constant directional force to the body. The force does not affect rotation. The force remains applied over time until cleared with ``PhysicsServer2D.body_set_constant_force(body, Vector2(0, 0))``.
This is equivalent to using :ref:`body_add_constant_force()<class_PhysicsServer2D_method_body_add_constant_force>` at the body's center of mass.
.. 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>`
Adds a constant positioned force to the body. The force can affect rotation if ``position`` is different from the body's center of mass. The force remains applied over time until cleared with ``PhysicsServer2D.body_set_constant_force(body, Vector2(0, 0))``.
\ ``position`` is the offset from the body origin in global coordinates.
.. 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>`
Adds a constant rotational force to the body. The force does not affect position. The force remains applied over time until cleared with ``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>`
Adds a shape to the area, with the given local transform. The shape (together with its ``transform`` and ``disabled`` properties) is added to an array of shapes, and the shapes of a body are usually referenced by their index in this 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>`
Applies a directional force to the body, at the body's center of mass. The force does not affect rotation. A force is time dependent and meant to be applied every physics update.
This is equivalent to using :ref:`body_apply_force()<class_PhysicsServer2D_method_body_apply_force>` at the body's center of mass.
.. 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>`
Applies a directional impulse to the body, at the body's center of mass. The impulse does not affect rotation.
An impulse is time-independent! Applying an impulse every frame would result in a framerate-dependent force. For this reason, it should only be used when simulating one-time impacts (use the "_force" functions otherwise).
This is equivalent to using :ref:`body_apply_impulse()<class_PhysicsServer2D_method_body_apply_impulse>` at the body's center of mass.
.. 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>`
Applies a positioned force to the body. The force can affect rotation if ``position`` is different from the body's center of mass. A force is time dependent and meant to be applied every physics update.
\ ``position`` is the offset from the body origin in global coordinates.
.. 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>`
Applies a positioned impulse to the body. The impulse can affect rotation if ``position`` is different from the body's center of mass.
An impulse is time-independent! Applying an impulse every frame would result in a framerate-dependent force. For this reason, it should only be used when simulating one-time impacts (use the "_force" functions otherwise).
\ ``position`` is the offset from the body origin in global coordinates.
.. 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>`
Aplica una fuerza rotacional al cuerpo. La fuerza no afecta la posición. Una fuerza depende del tiempo y está pensada para ser aplicada en cada actualización de la física.
.. 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>`
Applies a rotational impulse to the body. The impulse does not affect position.
An impulse is time-independent! Applying an impulse every frame would result in a framerate-dependent force. For this reason, it should only be used when simulating one-time impacts (use the "_force" functions otherwise).
.. 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>`
Adjunta el ``ObjectID`` de un canvas al cuerpo. Utiliza :ref:`Object.get_instance_id()<class_Object_method_get_instance_id>` para obtener el ``ObjectID`` de 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>`
Adjunta el ``ObjectID`` de un :ref:`Object<class_Object>` al cuerpo. Utiliza :ref:`Object.get_instance_id()<class_Object_method_get_instance_id>` para obtener el ``ObjectID`` de 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>`
Elimina todas las formas del cuerpo. Esto no elimina las formas en sí mismas, por lo que pueden seguir utilizándose en otra parte o volver a añadirse más tarde.
.. 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 objeto de cuerpo 2D en el servidor de física, y devuelve el :ref:`RID<class_RID>` que lo identifica. La configuración predeterminada para el área creada incluye una capa de colisión y una máscara establecida en ``1``, y el modo del cuerpo establecido en :ref:`BODY_MODE_RIGID<class_PhysicsServer2D_constant_BODY_MODE_RIGID>`.
Utiliza :ref:`body_add_shape()<class_PhysicsServer2D_method_body_add_shape>` para añadirle formas, utiliza :ref:`body_set_state()<class_PhysicsServer2D_method_body_set_state>` para establecer su transformación, y utiliza :ref:`body_set_space()<class_PhysicsServer2D_method_body_set_space>` para añadir el cuerpo a un espacio.
.. 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>`
Devuelve el ``ObjectID`` del canvas adjunto al cuerpo. Utiliza :ref:`@GlobalScope.instance_from_id()<class_@GlobalScope_method_instance_from_id>` para recuperar un :ref:`CanvasLayer<class_CanvasLayer>` de un ``ObjectID`` distinto de cero.
.. 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>`
Devuelve la capa o capas físicas a las que pertenece el cuerpo, como una máscara de bits.
.. 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>`
Devuelve la capa o capas físicas con las que el cuerpo puede colisionar, como una máscara de bits.
.. 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>`
Devuelve la prioridad de colisión del cuerpo. Esto se utiliza en la fase de despenetración de :ref:`body_test_motion()<class_PhysicsServer2D_method_body_test_motion>`. Cuanto mayor sea la prioridad, menor será la penetración en el cuerpo.
.. 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>`
Devuelve la fuerza posicional constante total del cuerpo aplicada durante cada actualización de la física.
Véase :ref:`body_add_constant_force()<class_PhysicsServer2D_method_body_add_constant_force>` y :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>`
Devuelve la fuerza rotacional constante total del cuerpo aplicada durante cada actualización de la física.
Véase :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>`
Returns the body's continuous collision detection mode.
.. 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>`
Devuelve el :ref:`PhysicsDirectBodyState2D<class_PhysicsDirectBodyState2D>` del cuerpo. Devuelve ``null`` si el cuerpo es destruido o no está asignado a un espacio.
.. 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>`
Devuelve el número máximo de contactos que el cuerpo puede reportar. Véase :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>`
Devuelve el modo de cuerpo.
.. 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>`
Devuelve el ``ObjectID`` adjunto al cuerpo. Utiliza :ref:`@GlobalScope.instance_from_id()<class_@GlobalScope_method_instance_from_id>` para recuperar un :ref:`Object<class_Object>` de un ``ObjectID`` distinto de cero.
.. 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>`
Devuelve el valor del parámetro del cuerpo dado.
.. 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>`
Devuelve el :ref:`RID<class_RID>` de la forma con el índice dado en el array de formas del cuerpo.
.. 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>`
Devuelve el número de formas añadidas al cuerpo.
.. 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>`
Devuelve el array de transformación local de la forma con el índice dado en el array de formas del área.
.. 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>`
Returns the :ref:`RID<class_RID>` of the space assigned to the body. Returns an empty :ref:`RID<class_RID>` if no space is assigned.
.. 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>`
Devuelve el valor del estado dado del cuerpo.
.. 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>`
Devuelve ``true`` si el cuerpo está omitiendo la integración de fuerza estándar. Véase :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>`
Elimina ``excepted_body`` de la lista de excepciones de colisión del cuerpo, de modo que las colisiones con él ya no se ignoran.
.. 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>`
Elimina la forma con el índice dado del array de formas del cuerpo. La forma en sí no se elimina, por lo que se puede seguir utilizando en otro lugar o volver a añadirse más tarde. Como resultado de esta operación, las formas del cuerpo que solían tener índices mayores que ``shape_idx`` verán su índice disminuido en 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>`
Restaura la inercia y el centro de masa predeterminados del cuerpo en función de sus formas. Esto deshace cualquier valor personalizado establecido previamente mediante :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 velocidad lineal del cuerpo para que su proyección al eje ``axis_velocity.normalized()`` sea exactamente ``axis_velocity.length()``. Esto es útil para el comportamiento de 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>`
Establece la capa o capas físicas a las que pertenece el cuerpo, mediante una máscara de bits.
.. 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>`
Establece la capa o capas físicas con las que el cuerpo puede colisionar, mediante una máscara de bits.
.. 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>`
Establece la prioridad de colisión del cuerpo. Se utiliza en la fase de despenetración de :ref:`body_test_motion()<class_PhysicsServer2D_method_body_test_motion>`. Cuanto mayor sea la prioridad, menor será la penetración en el cuerpo.
.. 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>`
Establece la fuerza posicional constante total del cuerpo aplicada durante cada actualización de la física.
Véase :ref:`body_add_constant_force()<class_PhysicsServer2D_method_body_add_constant_force>` y :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>`
Establece la fuerza rotacional constante total del cuerpo aplicada durante cada actualización de la física.
Véase :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>`
Establece el modo de detección de colisión continua.
La detección de colisión continua intenta predecir dónde colisionaría un cuerpo en movimiento entre las actualizaciones de la física, en lugar de moverlo y corregir su movimiento si colisiona.
.. 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>`
Sets the body's custom force integration callback function to ``callable``. Use an empty :ref:`Callable<class_Callable>` (``Callable()``) to clear the custom callback.
The function ``callable`` will be called every physics tick, before the standard force integration (see :ref:`body_set_omit_force_integration()<class_PhysicsServer2D_method_body_set_omit_force_integration>`). It can be used for example to update the body's linear and angular velocity based on contact with other bodies.
If ``userdata`` is not ``null``, the function ``callable`` must take the following two parameters:
1. ``state``: a :ref:`PhysicsDirectBodyState2D<class_PhysicsDirectBodyState2D>` used to retrieve and modify the body's state,
2. ``userdata``: a :ref:`Variant<class_Variant>`; its value will be the ``userdata`` passed into this method.
If ``userdata`` is ``null``, then ``callable`` must take only the ``state`` parameter.
.. 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>`
Sets the maximum number of contacts that the body can report. If ``amount`` is greater than zero, then the body will keep track of at most this many contacts with other bodies.
.. 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>`
Establece el modo de cuerpo.
.. 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>`
Sets whether the body omits the standard force integration. If ``enable`` is ``true``, the body will not automatically use applied forces, torques, and damping to update the body's linear and angular velocity. In this case, :ref:`body_set_force_integration_callback()<class_PhysicsServer2D_method_body_set_force_integration_callback>` can be used to manually update the linear and angular velocity instead.
This method is called when the property :ref:`RigidBody2D.custom_integrator<class_RigidBody2D_property_custom_integrator>` is set.
.. 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>`
Establece el valor del parámetro del cuerpo dado.
.. 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>`
Reemplaza la forma del cuerpo en el índice dado por otra forma, sin afectar las propiedades ``transform``, ``disabled`` y de colisión unidireccional en el mismo índice.
.. 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>`
Sets the one-way collision properties of the body's shape with the given index. If ``enable`` is ``true``, the one-way collision direction given by the shape's local upward axis ``body_get_shape_transform(body, shape_idx).y`` will be used to ignore collisions with the shape in the opposite direction, and to ensure depenetration of kinematic bodies happens in this direction.
.. 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>`
Establece la propiedad disabled de la forma del cuerpo con el índice dado. Si ``disabled`` es ``true``, entonces la forma será ignorada en toda la detección de colisiones.
.. 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>`
Establece la matriz de transformación local de la forma del cuerpo con el índice dado.
.. 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>`
Adds the body to the given space, after removing the body from the previously assigned space (if any). If the body's mode is set to :ref:`BODY_MODE_RIGID<class_PhysicsServer2D_constant_BODY_MODE_RIGID>`, then adding the body to a space will have the following additional effects:
- If the parameter :ref:`BODY_PARAM_CENTER_OF_MASS<class_PhysicsServer2D_constant_BODY_PARAM_CENTER_OF_MASS>` has never been set explicitly, then the value of that parameter will be recalculated based on the body's shapes.
- If the parameter :ref:`BODY_PARAM_INERTIA<class_PhysicsServer2D_constant_BODY_PARAM_INERTIA>` is set to a value ``<= 0.0``, then the value of that parameter will be recalculated based on the body's shapes, mass, and center of mass.
\ **Note:** To remove a body from a space without immediately adding it back elsewhere, use ``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>`
Sets the value of a body's state.
\ **Note:** The state change doesn't take effect immediately. The state will change on the next physics frame.
.. 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>`
Sets the body's state synchronization callback function to ``callable``. Use an empty :ref:`Callable<class_Callable>` (``Callable()``) to clear the callback.
The function ``callable`` will be called every physics frame, assuming that the body was active during the previous physics tick, and can be used to fetch the latest state from the physics server.
The function ``callable`` must take the following parameters:
1. ``state``: a :ref:`PhysicsDirectBodyState2D<class_PhysicsDirectBodyState2D>`, used to retrieve the body's state.
.. 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>`
Returns ``true`` if a collision would result from moving the body along a motion vector from a given point in space. See :ref:`PhysicsTestMotionParameters2D<class_PhysicsTestMotionParameters2D>` for the available motion parameters. Optionally a :ref:`PhysicsTestMotionResult2D<class_PhysicsTestMotionResult2D>` object can be passed, which will be used to store the information about the resulting collision.
.. 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 de cápsula 2D en el servidor de física, y devuelve el :ref:`RID<class_RID>` que la identifica. Utiliza :ref:`shape_set_data()<class_PhysicsServer2D_method_shape_set_data>` para establecer la altura y el radio de la cápsula.
.. 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 de círculo 2D en el servidor de física, y devuelve el :ref:`RID<class_RID>` que la identifica. Utiliza :ref:`shape_set_data()<class_PhysicsServer2D_method_shape_set_data>` para establecer el radio del círculo.
.. 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 de polígono cóncavo 2D en el servidor de física, y devuelve el :ref:`RID<class_RID>` que la identifica. Utiliza :ref:`shape_set_data()<class_PhysicsServer2D_method_shape_set_data>` para establecer los segmentos del polígono cóncavo.
.. 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 de polígono convexo 2D en el servidor de física, y devuelve el :ref:`RID<class_RID>` que la identifica. Utiliza :ref:`shape_set_data()<class_PhysicsServer2D_method_shape_set_data>` para establecer los puntos del polígono convexo.
.. 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>`
Devuelve el valor del parámetro del resorte amortiguado dado.
.. 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>`
Establece el valor del parámetro del resorte amortiguado dado.
.. 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>`
Destruye cualquiera de los objetos creados por PhysicsServer2D. Si el :ref:`RID<class_RID>` pasado no es uno de los objetos que puede ser creado por PhysicsServer2D, se imprimirá un error en la consola.
.. 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>`
Devuelve el valor de un estado del motor de física especificado por ``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>`
Destroys the joint with the given :ref:`RID<class_RID>`, creates a new uninitialized joint, and makes the :ref:`RID<class_RID>` refer to this new joint.
.. 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>`
Creates a 2D joint in the physics server, and returns the :ref:`RID<class_RID>` that identifies it. To set the joint type, use :ref:`joint_make_damped_spring()<class_PhysicsServer2D_method_joint_make_damped_spring>`, :ref:`joint_make_groove()<class_PhysicsServer2D_method_joint_make_groove>` or :ref:`joint_make_pin()<class_PhysicsServer2D_method_joint_make_pin>`. Use :ref:`joint_set_param()<class_PhysicsServer2D_method_joint_set_param>` to set generic joint parameters.
.. 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>`
Sets whether the bodies attached to the :ref:`Joint2D<class_Joint2D>` will collide with each other.
.. 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>`
Returns the value of the given joint parameter.
.. 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>`
Returns the joint's type.
.. 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>`
Returns whether the bodies attached to the :ref:`Joint2D<class_Joint2D>` will collide with each other.
.. 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>`
Makes the joint a damped spring joint, attached at the point ``anchor_a`` (given in global coordinates) on the body ``body_a`` and at the point ``anchor_b`` (given in global coordinates) on the body ``body_b``. To set the parameters which are specific to the damped spring, see :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>`
Makes the joint a groove joint.
.. 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>`
Makes the joint a pin joint. If ``body_b`` is an empty :ref:`RID<class_RID>`, then ``body_a`` is pinned to the point ``anchor`` (given in global coordinates); otherwise, ``body_a`` is pinned to ``body_b`` at the point ``anchor`` (given in global coordinates). To set the parameters which are specific to the pin joint, see :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>`
Sets the value of the given joint parameter.
.. 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>`
Gets a pin joint flag.
.. 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>`
Returns the value of a pin joint parameter.
.. 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>`
Sets a pin joint flag.
.. 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>`
Sets a pin joint parameter.
.. 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 de rectángulo 2D en el servidor de física, y devuelve el :ref:`RID<class_RID>` que la identifica. Utiliza :ref:`shape_set_data()<class_PhysicsServer2D_method_shape_set_data>` para establecer las semiextensiones del rectángulo.
.. 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 de segmento 2D en el servidor de física, y devuelve el :ref:`RID<class_RID>` que la identifica. Utiliza :ref:`shape_set_data()<class_PhysicsServer2D_method_shape_set_data>` para establecer los puntos de inicio y fin 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 de rayo de separación 2D en el servidor de física, y devuelve el :ref:`RID<class_RID>` que la identifica. Utiliza :ref:`shape_set_data()<class_PhysicsServer2D_method_shape_set_data>` para establecer las propiedades ``length`` y ``slide_on_slope`` de la 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>`
Activa o desactiva el servidor de física 2D. Si ``active`` es ``false``, entonces el servidor de física no hará nada en su paso de física.
.. 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>`
Devuelve los datos de la forma que definen la configuración de la forma, como las extensiones medias de un rectángulo o los segmentos de una forma cóncava. Véase :ref:`shape_set_data()<class_PhysicsServer2D_method_shape_set_data>` para conocer el formato preciso de estos datos en cada 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>`
Devuelve el tipo de la 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>`
Sets the shape data that defines the configuration of the shape. The ``data`` to be passed depends on the shape's type (see :ref:`shape_get_type()<class_PhysicsServer2D_method_shape_get_type>`):
- :ref:`SHAPE_WORLD_BOUNDARY<class_PhysicsServer2D_constant_SHAPE_WORLD_BOUNDARY>`: an array of length two containing a :ref:`Vector2<class_Vector2>` ``normal`` direction and a :ref:`float<class_float>` distance ``d``,
- :ref:`SHAPE_SEPARATION_RAY<class_PhysicsServer2D_constant_SHAPE_SEPARATION_RAY>`: a dictionary containing the key ``length`` with a :ref:`float<class_float>` value and the key ``slide_on_slope`` with a :ref:`bool<class_bool>` value,
- :ref:`SHAPE_SEGMENT<class_PhysicsServer2D_constant_SHAPE_SEGMENT>`: a :ref:`Rect2<class_Rect2>` ``rect`` containing the first point of the segment in ``rect.position`` and the second point of the segment in ``rect.size``,
- :ref:`SHAPE_CIRCLE<class_PhysicsServer2D_constant_SHAPE_CIRCLE>`: a :ref:`float<class_float>` ``radius``,
- :ref:`SHAPE_RECTANGLE<class_PhysicsServer2D_constant_SHAPE_RECTANGLE>`: a :ref:`Vector2<class_Vector2>` ``half_extents``,
- :ref:`SHAPE_CAPSULE<class_PhysicsServer2D_constant_SHAPE_CAPSULE>`: an array of length two (or a :ref:`Vector2<class_Vector2>`) containing a :ref:`float<class_float>` ``height`` and a :ref:`float<class_float>` ``radius``,
- :ref:`SHAPE_CONVEX_POLYGON<class_PhysicsServer2D_constant_SHAPE_CONVEX_POLYGON>`: either a :ref:`PackedVector2Array<class_PackedVector2Array>` of points defining a convex polygon in counterclockwise order (the clockwise outward normal of each segment formed by consecutive points is calculated internally), or a :ref:`PackedFloat32Array<class_PackedFloat32Array>` of length divisible by four so that every 4-tuple of :ref:`float<class_float>`\ s contains the coordinates of a point followed by the coordinates of the clockwise outward normal vector to the segment between the current point and the next point,
- :ref:`SHAPE_CONCAVE_POLYGON<class_PhysicsServer2D_constant_SHAPE_CONCAVE_POLYGON>`: a :ref:`PackedVector2Array<class_PackedVector2Array>` of length divisible by two (each pair of points forms one segment).
\ **Warning:** In the case of :ref:`SHAPE_CONVEX_POLYGON<class_PhysicsServer2D_constant_SHAPE_CONVEX_POLYGON>`, this method does not check if the points supplied actually form a convex polygon (unlike the :ref:`CollisionPolygon2D.polygon<class_CollisionPolygon2D_property_polygon>` property).
.. 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>`
Creates a 2D space in the physics server, and returns the :ref:`RID<class_RID>` that identifies it. A space contains bodies and areas, and controls the stepping of the physics simulation of the objects in it.
.. 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>`
Returns the state of a space, a :ref:`PhysicsDirectSpaceState2D<class_PhysicsDirectSpaceState2D>`. This object can be used for collision/intersection queries.
.. 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>`
Devuelve el valor del parámetro de espacio dado.
.. 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>`
Returns ``true`` if the space is active.
.. 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>`
Activates or deactivates the space. If ``active`` is ``false``, then the physics server will not do anything with this space in its physics step.
.. 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>`
Sets the value of the given space parameter.
.. 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>`
Creates a 2D world boundary shape in the physics server, and returns the :ref:`RID<class_RID>` that identifies it. Use :ref:`shape_set_data()<class_PhysicsServer2D_method_shape_set_data>` to set the shape's normal direction and distance properties.
.. |virtual| replace:: :abbr:`virtual (Normalmente, este método debería ser sobreescrito por el usuario para que tenga algún efecto.)`
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
.. |const| replace:: :abbr:`const (Este método no tiene efectos secundarios. No modifica ninguna de las variables miembro de la instancia.)`
.. |vararg| replace:: :abbr:`vararg (Este método permite agregar cualquier número de argumentos después de los descritos aquí.)`
.. |constructor| replace:: :abbr:`constructor (Este método se utiliza para construir un tipo.)`
.. |static| replace:: :abbr:`static (Este método no necesita una instancia para ser llamado, por lo que puede llamarse directamente utilizando el nombre de la clase.)`
.. |operator| replace:: :abbr:`operator (Este método describe un operador válido para usar con este tipo como operando izquierdo.)`
.. |bitfield| replace:: :abbr:`BitField (Este valor es un entero compuesto como una máscara de bits de las siguientes banderas.)`
.. |void| replace:: :abbr:`void (Sin valor de retorno.)`
Reference in New Issue View Git Blame Copy Permalink