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/uk/class_physicsserver2d.rst

2636 lines
216 KiB
ReStructuredText
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

:github_url: hide
.. _class_PhysicsServer2D:
PhysicsServer2D
===============
**Успадковує:** :ref:`Object<class_Object>`
**Успадковано від:** :ref:`PhysicsServer2DExtension<class_PhysicsServer2DExtension>`
Інтерфейс сервера для низького рівня 2D фізичного доступу.
.. rst-class:: classref-introduction-group
Опис
--------
PhysicsServer2D — це сервер, який відповідає за всю 2D фізику. Він може безпосередньо створювати та керувати всіма фізичними об’єктами:
- *Простір* — це самодостатній світ для симуляції фізики. Він містить тіла, області та суглоби. Його стан можна запитувати для отримання інформації про зіткнення та перехрестя, а також можна змінити кілька параметрів моделювання.
- *Фігура* — це геометрична фігура, наприклад коло, прямокутник, капсула або багатокутник. Його можна використовувати для виявлення зіткнень, додавши його до тіла/області, можливо, з додатковим перетворенням відносно походження тіла/області. До тіл/областей можна додати кілька (трансформованих) форм, а одну форму можна додавати до тіл/областей кілька разів за допомогою різних локальних трансформацій.
- *Тіло* — це фізичний об'єкт, який може перебувати в статичному, кінематичному або твердому режимі. Його стан (наприклад, положення та швидкість) можна запитувати та оновлювати. Зворотний виклик інтеграції сили можна встановити для налаштування фізики тіла.
- *Область* — це область у просторі, яка може бути використана для виявлення тіл і областей, які входять і виходять з неї. Можна налаштувати зворотний виклик моніторингу тіла, щоб повідомляти про вхід/вихід з форм тіла, і аналогічно можна встановити зворотний виклик моніторингу області. Силу тяжіння та демпфування можна перекрити в межах області, встановивши параметри області.
- *З’єднання* — це зв’язок між двома тілами або одним тілом відносно точки. Можна регулювати такі параметри, як зміщення з’єднання та довжина спокою пружинного з’єднання.
Фізичні об’єкти в **PhysicsServer2D** можна створювати та маніпулювати ними незалежно; вони не повинні бути прив'язані до вузлів у дереві сцени.
\ **Примітка:** усі вузли 2D фізики використовують внутрішній сервер фізики. Додавання вузла фізики до дерева сцени призведе до створення відповідного об’єкта фізики на сервері фізики. Вузол твердого тіла реєструє зворотний виклик, який оновлює перетворення вузла за допомогою перетворення відповідного об’єкта тіла на сервері фізики (кожне оновлення фізики). Вузол області реєструє зворотний виклик, щоб повідомити вузол області про перекриття з відповідним об’єктом області на сервері фізики. Вузол raycast запитує прямий стан відповідного простору на сервері фізики.
.. rst-class:: classref-reftable-group
Методи
------------
.. 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
Переліки
----------------
.. _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``
Постійно встановити / вийняти максимальну відстань пари органів повинні переходити до їх статусу зіткнення. Значення за замовчуванням цього параметра :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``
Постійно встановіть / оберіть максимальну відстань, форма може бути від іншої до того, як вони вважаються відокремленими, і контакт відкидається. Значення за замовчуванням цього параметра :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``
Постійно встановити / вийняти максимальну відстань, форма може проникнути іншої форми, перш ніж вважається зіткненням. Значення за замовчуванням цього параметра :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``
Постійно налаштовувати / вийняти роз'єм за замовчуванням для всіх контактів фізики. Розчинник Bias є фактором, який контролює, як багато двох об'єктів "відновлення", після перекриття, щоб уникнути їх в цьому стані через чисельне імпросіяння. Значення за замовчуванням цього параметра :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``
Постійне встановлення/витратити порогу лінійну швидкість діяльності. Потенціал неактивний, як лінійна, так і кутова швидкість буде нести до сну після дати часу. Значення за замовчуванням цього параметра :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``
Постійно встановити / вийняти порогу кутову швидкість діяльності. Потенціал неактивний, як лінійна, так і кутова швидкість буде нести до сну після дати часу. Значення за замовчуванням цього параметра :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``
Постійне встановлення/витратити максимальний час діяльності. Після цього часу, тіло, що позначається як потенційно неактивний як для лінійної, так і кутової швидкості. Значення за замовчуванням цього параметра :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``
Постійно налаштовувати / вийняти диверсифікатор за замовчуванням для всіх обмежень фізики. Розчинник Bias є фактором, який контролює, як багато двох об'єктів "відновлення", після того, як з'єднання обмеження, щоб уникнути їх в цьому стані через чисельне значення. Значення за замовчуванням цього параметра :ref:`ProjectSettings.physics/2d/solver/default_constraint_bias<class_ProjectSettings_property_physics/2d/solver/default_constraint_bias>`.
.. _class_PhysicsServer2D_constant_SPACE_PARAM_SOLVER_ITERATIONS:
.. rst-class:: classref-enumeration-constant
:ref:`SpaceParameter<enum_PhysicsServer2D_SpaceParameter>` **SPACE_PARAM_SOLVER_ITERATIONS** = ``8``
Постійне встановлення/витратити кількість переселенців для всіх контактів та обмежень. Чим більша кількість ітерацій, тим більш точний зіткнень буде. Однак більша кількість ітерацій вимагає більшої потужності процесора, яка може зменшити продуктивність. Значення за замовчуванням цього параметра :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``
Це постійне для створення глобальних граничних форм. У світі обмежена форма є *infinite* лінії з точки зору походження і нормальним. Таким чином, він може використовуватися для передньої перевірки.
.. _class_PhysicsServer2D_constant_SHAPE_SEPARATION_RAY:
.. rst-class:: classref-enumeration-constant
:ref:`ShapeType<enum_PhysicsServer2D_ShapeType>` **SHAPE_SEPARATION_RAY** = ``1``
Це постійна для створення сепарації променевих форм. Відокремлення променя визначається довжиною і відокремлює себе від того, що доторкнеться її далекої точки. Корисно для контролерів символів.
.. _class_PhysicsServer2D_constant_SHAPE_SEGMENT:
.. rst-class:: classref-enumeration-constant
:ref:`ShapeType<enum_PhysicsServer2D_ShapeType>` **SHAPE_SEGMENT** = ``2``
Це постійна для створення форм сегмента. Форма сегмента — *фініт* лінія від точки А до точки B. Для перехрестя можна перевірити.
.. _class_PhysicsServer2D_constant_SHAPE_CIRCLE:
.. rst-class:: classref-enumeration-constant
:ref:`ShapeType<enum_PhysicsServer2D_ShapeType>` **SHAPE_CIRCLE** = ``3``
Це постійна для створення коло форм. Форма кола тільки має радіус. Ви можете використовувати для перехресних і внутрішніх перевірок.
.. _class_PhysicsServer2D_constant_SHAPE_RECTANGLE:
.. rst-class:: classref-enumeration-constant
:ref:`ShapeType<enum_PhysicsServer2D_ShapeType>` **SHAPE_RECTANGLE** = ``4``
Це постійна для створення прямокутних форм. Форма прямокутника визначається шириною і висотою. Ви можете використовувати для перехресних і внутрішніх перевірок.
.. _class_PhysicsServer2D_constant_SHAPE_CAPSULE:
.. rst-class:: classref-enumeration-constant
:ref:`ShapeType<enum_PhysicsServer2D_ShapeType>` **SHAPE_CAPSULE** = ``5``
Це постійна для створення капсулних форм. Форма капсули визначається радіусом і довжиною. Ви можете використовувати для перехресних і внутрішніх перевірок.
.. _class_PhysicsServer2D_constant_SHAPE_CONVEX_POLYGON:
.. rst-class:: classref-enumeration-constant
:ref:`ShapeType<enum_PhysicsServer2D_ShapeType>` **SHAPE_CONVEX_POLYGON** = ``6``
Це постійна для створення конвекційних полігонних форм. Полігон визначається переліком точок. Ви можете використовувати для перехресних і внутрішніх перевірок.
.. _class_PhysicsServer2D_constant_SHAPE_CONCAVE_POLYGON:
.. rst-class:: classref-enumeration-constant
:ref:`ShapeType<enum_PhysicsServer2D_ShapeType>` **SHAPE_CONCAVE_POLYGON** = ``7``
Це постійна для створення конденсованих полігонних форм. Полігон визначається переліком точок. Ви можете використовувати для перехресних перевірок, але не для внутрішніх / вихідних перевірок.
.. _class_PhysicsServer2D_constant_SHAPE_CUSTOM:
.. rst-class:: classref-enumeration-constant
:ref:`ShapeType<enum_PhysicsServer2D_ShapeType>` **SHAPE_CUSTOM** = ``8``
Ця константа використовується внутрішньо двигуном. Будь-яка спроба створити цей вид результатів форми в похибці.
.. 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``
Постійно встановити режим перевитрату ваги в зоні. Див. :ref:`AreaSpaceOverrideMode<enum_PhysicsServer2D_AreaSpaceOverrideMode>` для можливих значень. Значення за замовчуванням цього параметра :ref:`ЄА_SPACE_OVERRIDE_DISABLED<class_PhysicsServer2D_constant_ЄА_SPACE_OVERRIDE_DISABLED>`.
.. _class_PhysicsServer2D_constant_AREA_PARAM_GRAVITY:
.. rst-class:: classref-enumeration-constant
:ref:`AreaParameter<enum_PhysicsServer2D_AreaParameter>` **AREA_PARAM_GRAVITY** = ``1``
Постійно встановити / встати сили тяжіння в зоні. Значення за замовчуванням цього параметра ``9.80665``.
.. _class_PhysicsServer2D_constant_AREA_PARAM_GRAVITY_VECTOR:
.. rst-class:: classref-enumeration-constant
:ref:`AreaParameter<enum_PhysicsServer2D_AreaParameter>` **AREA_PARAM_GRAVITY_VECTOR** = ``2``
Постійний набір / вектор ваги / центр в області. Значення за замовчуванням цього параметра ``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``
Постійно встановити/забудити, чи є вектор сили тяжіння області, або центральна точка. Значення за замовчуванням цього параметра ``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``
Постійне встановлення/витратити дистанцію, на якій сила тяжіння дорівнює тяжінням, керованій :ref:`AREA_PARAM_GRAVITY<class_PhysicsServer2D_constant_AREA_PARAM_GRAVITY>`. Наприклад, на планеті 100 пікселів в радіусі з поверхневою вагою 4,0 px/s2, встановлюють тяжіння до 4.0 і відстань агрегату до 100.0. Тяжіння буде відхиляти відповідно до оберненого квадратного закону, тому в прикладі, на 200 пікселів від центру тяжіння буде 1,0 px/s2 (проти дистанції, 1/4 тяжіння), на 50 пікселів це буде 16.0 px/s2 (половина відстані, 4x тяжіння), і так далі.
Визначено лише тоді, коли відстань одиниці є позитивним числом. Коли відстань агрегату встановлена до 0.0, вага буде постійною незалежно від відстані. Значення за замовчуванням цього параметра ``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``
Постійно встановити / вийняти лінійний демпферний режим перенади в зоні. Див. :ref:`AreaSpaceOverrideMode<enum_PhysicsServer2D_AreaSpaceOverrideMode>` для можливих значень. Значення за замовчуванням цього параметра :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``
Постійне встановлення/витратити лінійний демпфуючий фактор ділянки. Значення за замовчуванням цього параметра ``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``
Постійно встановити / вийняти кутовий демпферний режим перенади в зоні. Див. :ref:`AreaSpaceOverrideMode<enum_PhysicsServer2D_AreaSpaceOverrideMode>` для можливих значень. Значення за замовчуванням цього параметра :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``
Постійно встановити / вийняти кутовий демпферний фактор ділянки. Значення за замовчуванням цього параметра ``1.0``.
.. _class_PhysicsServer2D_constant_AREA_PARAM_PRIORITY:
.. rst-class:: classref-enumeration-constant
:ref:`AreaParameter<enum_PhysicsServer2D_AreaParameter>` **AREA_PARAM_PRIORITY** = ``9``
Постійне встановлення/витратити пріоритет (замовлення обробки) ділянки. Значення за замовчуванням цього параметра ``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``
Ця область не впливає на тяжіння / пампу. Ці, як правило, райони, які існують тільки для виявлення зіткнень, а об'єкти, що надходять або випускають їх.
.. _class_PhysicsServer2D_constant_AREA_SPACE_OVERRIDE_COMBINE:
.. rst-class:: classref-enumeration-constant
:ref:`AreaSpaceOverrideMode<enum_PhysicsServer2D_AreaSpaceOverrideMode>` **AREA_SPACE_OVERRIDE_COMBINE** = ``1``
Ця область додає свої значення для тягової ваги. Таким чином, багато перекриття зон можуть поєднувати їх фізику, щоб зробити цікаві ефекти.
.. _class_PhysicsServer2D_constant_AREA_SPACE_OVERRIDE_COMBINE_REPLACE:
.. rst-class:: classref-enumeration-constant
:ref:`AreaSpaceOverrideMode<enum_PhysicsServer2D_AreaSpaceOverrideMode>` **AREA_SPACE_OVERRIDE_COMBINE_REPLACE** = ``2``
Ця область додає свої значення для тягової ваги. Після чого зупиняється з урахуванням інших зон, навіть за замовчуванням.
.. _class_PhysicsServer2D_constant_AREA_SPACE_OVERRIDE_REPLACE:
.. rst-class:: classref-enumeration-constant
:ref:`AreaSpaceOverrideMode<enum_PhysicsServer2D_AreaSpaceOverrideMode>` **AREA_SPACE_OVERRIDE_REPLACE** = ``3``
Ця область замінює будь-яку тяжіння / пампу, навіть за замовчуванням, і зупиняється з урахуванням інших зон.
.. _class_PhysicsServer2D_constant_AREA_SPACE_OVERRIDE_REPLACE_COMBINE:
.. rst-class:: classref-enumeration-constant
:ref:`AreaSpaceOverrideMode<enum_PhysicsServer2D_AreaSpaceOverrideMode>` **AREA_SPACE_OVERRIDE_REPLACE_COMBINE** = ``4``
Ця область замінює будь-яку гравію/знімку, що обчислюється так далеко, але зберігає розрахунок решти областей, вниз до за замовчуванням.
.. 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``
Постійний для статичних органів. У цьому режимі тіло можна перенести тільки за допомогою коду користувача і не співвідношенні з іншими тілами.
.. _class_PhysicsServer2D_constant_BODY_MODE_KINEMATIC:
.. rst-class:: classref-enumeration-constant
:ref:`BodyMode<enum_PhysicsServer2D_BodyMode>` **BODY_MODE_KINEMATIC** = ``1``
Постійно для кінематичних органів. У цьому режимі тіло можна перенести тільки за допомогою коду користувача і колеги з іншими тілами.
.. _class_PhysicsServer2D_constant_BODY_MODE_RIGID:
.. rst-class:: classref-enumeration-constant
:ref:`BodyMode<enum_PhysicsServer2D_BodyMode>` **BODY_MODE_RIGID** = ``2``
Постійний для жорстких тіл. У цьому режимі тіло можна відштовхувати іншими тілами і наносити сили.
.. _class_PhysicsServer2D_constant_BODY_MODE_RIGID_LINEAR:
.. rst-class:: classref-enumeration-constant
:ref:`BodyMode<enum_PhysicsServer2D_BodyMode>` **BODY_MODE_RIGID_LINEAR** = ``3``
Постійний для лінійних жорстких тіл. У цьому режимі тіло не може обертати, і тільки його лінійна швидкість впливає на зовнішні сили.
.. 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``
Постійно встановити / вийняти фактор відмов тіла. Значення за замовчуванням цього параметра ``0.0``.
.. _class_PhysicsServer2D_constant_BODY_PARAM_FRICTION:
.. rst-class:: classref-enumeration-constant
:ref:`BodyParameter<enum_PhysicsServer2D_BodyParameter>` **BODY_PARAM_FRICTION** = ``1``
Постійно встановити / приймати тертя тіла. Значення за замовчуванням цього параметра ``1.0``.
.. _class_PhysicsServer2D_constant_BODY_PARAM_MASS:
.. rst-class:: classref-enumeration-constant
:ref:`BodyParameter<enum_PhysicsServer2D_BodyParameter>` **BODY_PARAM_MASS** = ``2``
Постійно встановити / вийняти масу тіла. Значення за замовчуванням цього параметра ``1.0``. Якщо режим тіла встановлюється до :ref:`BODY_MODE_RIGID<class_PhysicsServer2D_constant_BODY_MODE_RIGID>`, то налаштування цього параметра буде мати наступні додаткові ефекти:
- Якщо параметр :ref:`BODY_PARAM_CENTER_OF_MASS<class_PhysicsServer2D_constant_BODY_PARAM_CENTER_OF_MASS>` ніколи не був встановлений явно, то значення цього параметра буде перераховано на основі форми тіла.
- Якщо параметр :ref:`BODY_PARAM_INERTIA<class_PhysicsServer2D_constant_BODY_PARAM_INERTIA>` встановлюється на значення ``<= 0.0``, то значення цього параметра буде перераховуватися на основі форм тіла, маси та центру маси.
.. _class_PhysicsServer2D_constant_BODY_PARAM_INERTIA:
.. rst-class:: classref-enumeration-constant
:ref:`BodyParameter<enum_PhysicsServer2D_BodyParameter>` **BODY_PARAM_INERTIA** = ``3``
Постійно встановити / приймати інерцію тіла. Значення за замовчуванням цього параметра ``0.0``. Якщо інерція тіла встановлена до значення ``<= 0.0``, то інерція буде перераховуватися на основі форм тіла, маси та центру маси.
.. _class_PhysicsServer2D_constant_BODY_PARAM_CENTER_OF_MASS:
.. rst-class:: classref-enumeration-constant
:ref:`BodyParameter<enum_PhysicsServer2D_BodyParameter>` **BODY_PARAM_CENTER_OF_MASS** = ``4``
Константа для встановлення/отримання положення центру мас тіла в локальній системі координат тіла. Значення цього параметра за замовчуванням — ``Vector2(0, 0)``. Якщо цей параметр ніколи не встановлюється явно, то він перераховується на основі форми тіла під час встановлення параметра :ref:`BODY_PARAM_MASS<class_PhysicsServer2D_constant_BODY_PARAM_MASS>` або під час виклику :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``
Постійно встановити / вийняти множника тіла. Значення за замовчуванням цього параметра ``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``
Постійно встановити / вийняти лінійний режим демппінгу тіла. Див. :ref:`BodyDampMode<enum_PhysicsServer2D_BodyDampMode>` для можливих значень. Значення за замовчуванням цього параметра :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``
Постійно встановити / вийняти кутовий режим видалення тіла. Див. :ref:`BodyDampMode<enum_PhysicsServer2D_BodyDampMode>` для можливих значень. Значення за замовчуванням цього параметра :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``
Постійно встановити / приймати лінійний демпфуючий фактор тіла. Значення за замовчуванням цього параметра ``0.0``.
.. _class_PhysicsServer2D_constant_BODY_PARAM_ANGULAR_DAMP:
.. rst-class:: classref-enumeration-constant
:ref:`BodyParameter<enum_PhysicsServer2D_BodyParameter>` **BODY_PARAM_ANGULAR_DAMP** = ``9``
Постійно встановити / вийняти фактор пошкодження тіла. Значення за замовчуванням цього параметра ``0.0``.
.. _class_PhysicsServer2D_constant_BODY_PARAM_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`BodyParameter<enum_PhysicsServer2D_BodyParameter>` **BODY_PARAM_MAX** = ``10``
Представляємо розмір :ref:`BodyParameter<enum_PhysicsServer2D_BodyParameter>` enum.
.. 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``
Вартість видалення тіла додається до будь-якого значення, встановленого в зонах або значенням за замовчуванням.
.. _class_PhysicsServer2D_constant_BODY_DAMP_MODE_REPLACE:
.. rst-class:: classref-enumeration-constant
:ref:`BodyDampMode<enum_PhysicsServer2D_BodyDampMode>` **BODY_DAMP_MODE_REPLACE** = ``1``
Значення розміру тіла замінює будь-яке значення, встановлене в зонах або значенням за замовчуванням.
.. 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``
Постійно встановити / вийняти поточну трансформовану матрицю тіла.
.. _class_PhysicsServer2D_constant_BODY_STATE_LINEAR_VELOCITY:
.. rst-class:: classref-enumeration-constant
:ref:`BodyState<enum_PhysicsServer2D_BodyState>` **BODY_STATE_LINEAR_VELOCITY** = ``1``
Постійно встановити / приймати поточну лінійну швидкість тіла.
.. _class_PhysicsServer2D_constant_BODY_STATE_ANGULAR_VELOCITY:
.. rst-class:: classref-enumeration-constant
:ref:`BodyState<enum_PhysicsServer2D_BodyState>` **BODY_STATE_ANGULAR_VELOCITY** = ``2``
Постійно встановити / вийняти поточну кутову швидкість тіла.
.. _class_PhysicsServer2D_constant_BODY_STATE_SLEEPING:
.. rst-class:: classref-enumeration-constant
:ref:`BodyState<enum_PhysicsServer2D_BodyState>` **BODY_STATE_SLEEPING** = ``3``
Постійно спати / випікати тіло, або отримати, чи є вона спляча.
.. _class_PhysicsServer2D_constant_BODY_STATE_CAN_SLEEP:
.. rst-class:: classref-enumeration-constant
:ref:`BodyState<enum_PhysicsServer2D_BodyState>` **BODY_STATE_CAN_SLEEP** = ``4``
Постійно встановити / вийняти, чи може тіло спати.
.. 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``
Постійно створювати контактні суглоби.
.. _class_PhysicsServer2D_constant_JOINT_TYPE_GROOVE:
.. rst-class:: classref-enumeration-constant
:ref:`JointType<enum_PhysicsServer2D_JointType>` **JOINT_TYPE_GROOVE** = ``1``
Постійно створювати канавки швів.
.. _class_PhysicsServer2D_constant_JOINT_TYPE_DAMPED_SPRING:
.. rst-class:: classref-enumeration-constant
:ref:`JointType<enum_PhysicsServer2D_JointType>` **JOINT_TYPE_DAMPED_SPRING** = ``2``
Постійне створення занурених весняних швів.
.. _class_PhysicsServer2D_constant_JOINT_TYPE_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`JointType<enum_PhysicsServer2D_JointType>` **JOINT_TYPE_MAX** = ``3``
Представляємо розмір об'єкта :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``
Постійно налаштовувати / приймати, як швидко стягуються органи назад, щоб задовольнити спільні обмеження. Чим нижче значення, тим більше два тіла можуть натягнути на суглоб. Значення за замовчуванням цього параметра ``0.0``.
\ **Note:** У фізики Godot цей параметр використовується тільки для контактних з'єднань і з'єднань пазів.
.. _class_PhysicsServer2D_constant_JOINT_PARAM_MAX_BIAS:
.. rst-class:: classref-enumeration-constant
:ref:`JointParam<enum_PhysicsServer2D_JointParam>` **JOINT_PARAM_MAX_BIAS** = ``1``
Постійно встановити / вийняти максимальну швидкість, з якою може застосовуватися корекція. Значення за замовчуванням цього параметра ``3.40282e+38``.
\ **Note:** У фізики Godot цей параметр використовується тільки для з'єднань пазів.
.. _class_PhysicsServer2D_constant_JOINT_PARAM_MAX_FORCE:
.. rst-class:: classref-enumeration-constant
:ref:`JointParam<enum_PhysicsServer2D_JointParam>` **JOINT_PARAM_MAX_FORCE** = ``2``
Постійно встановити/забудити максимальну силу, що суглоб може використовуватися для дії на двох тілах. Значення за замовчуванням цього параметра ``3.40282e+38``.
\ **Note:** У фізики Godot цей параметр використовується тільки для з'єднань пазів.
.. 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``
Постійно встановити/забудити скільки зв'язок контактного суглоба може гнучко. Значення за замовчуванням цього параметра ``0.0``.
.. _class_PhysicsServer2D_constant_PIN_JOINT_LIMIT_UPPER:
.. rst-class:: classref-enumeration-constant
:ref:`PinJointParam<enum_PhysicsServer2D_PinJointParam>` **PIN_JOINT_LIMIT_UPPER** = ``1``
Максимальне обертання навколо шпильки.
.. _class_PhysicsServer2D_constant_PIN_JOINT_LIMIT_LOWER:
.. rst-class:: classref-enumeration-constant
:ref:`PinJointParam<enum_PhysicsServer2D_PinJointParam>` **PIN_JOINT_LIMIT_LOWER** = ``2``
Мінімальне обертання навколо шпильки.
.. _class_PhysicsServer2D_constant_PIN_JOINT_MOTOR_TARGET_VELOCITY:
.. rst-class:: classref-enumeration-constant
:ref:`PinJointParam<enum_PhysicsServer2D_PinJointParam>` **PIN_JOINT_MOTOR_TARGET_VELOCITY** = ``3``
Цільова швидкість двигуна. В редьях на секунду.
.. 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``
Якщо ``true``, шпилька має максимальне і мінімальне обертання.
.. _class_PhysicsServer2D_constant_PIN_JOINT_FLAG_MOTOR_ENABLED:
.. rst-class:: classref-enumeration-constant
:ref:`PinJointFlag<enum_PhysicsServer2D_PinJointFlag>` **PIN_JOINT_FLAG_MOTOR_ENABLED** = ``1``
Якщо ``true``, мотор обертається шпилькою.
.. 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``
Встановлює решту довжини весняного суглоба. З'єднання завжди намагатиметься повернутися до цієї довжини при розтягуванні. Значення за замовчуванням цього параметра є дистанцією між точками зв'язку.
.. _class_PhysicsServer2D_constant_DAMPED_SPRING_STIFFNESS:
.. rst-class:: classref-enumeration-constant
:ref:`DampedSpringParam<enum_PhysicsServer2D_DampedSpringParam>` **DAMPED_SPRING_STIFFNESS** = ``1``
Встановлює жорсткість весняного суглоба. З'єднання діє сила, що дорівнює стиглості, час відступу від її решти довжини. Значення за замовчуванням цього параметра ``20.0``.
.. _class_PhysicsServer2D_constant_DAMPED_SPRING_DAMPING:
.. rst-class:: classref-enumeration-constant
:ref:`DampedSpringParam<enum_PhysicsServer2D_DampedSpringParam>` **DAMPED_SPRING_DAMPING** = ``2``
Встановлює демпферний співвідношення весняного суглоба. Значення 0 вказує на неприпустиму пружину, при цьому 1 викликає систему для досягнення рівноваги максимально швидко (критичне пошкодження). Значення за замовчуванням цього параметра ``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``
Вимкнено безперервне виявлення зіткнення. Це найшвидший спосіб виявлення зіткнень тіла, але він може пропустити дрібні та/або швидко знімальні предмети.
.. _class_PhysicsServer2D_constant_CCD_MODE_CAST_RAY:
.. rst-class:: classref-enumeration-constant
:ref:`CCDMode<enum_PhysicsServer2D_CCDMode>` **CCD_MODE_CAST_RAY** = ``1``
Увімкнено безперервне виявлення зіткнень. Це швидше, ніж формулювання, але менш точний.
.. _class_PhysicsServer2D_constant_CCD_MODE_CAST_SHAPE:
.. rst-class:: classref-enumeration-constant
:ref:`CCDMode<enum_PhysicsServer2D_CCDMode>` **CCD_MODE_CAST_SHAPE** = ``2``
Увімкнено безперервне виявлення зіткнень за допомогою формулювання. Це повільний метод CCD, і найбільш точний.
.. 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``
Вартість першого параметра і функції виклику області отримує, коли об'єкт входить до однієї з його форм.
.. _class_PhysicsServer2D_constant_AREA_BODY_REMOVED:
.. rst-class:: classref-enumeration-constant
:ref:`AreaBodyStatus<enum_PhysicsServer2D_AreaBodyStatus>` **AREA_BODY_REMOVED** = ``1``
Вартість першого параметра і функції виклику області отримує, коли об'єкт виходить один з його форм.
.. 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``
Постійно отримайте кількість об'єктів, які не сплять.
.. _class_PhysicsServer2D_constant_INFO_COLLISION_PAIRS:
.. rst-class:: classref-enumeration-constant
:ref:`ProcessInfo<enum_PhysicsServer2D_ProcessInfo>` **INFO_COLLISION_PAIRS** = ``1``
Постійно отримати кількість можливих зіткнень.
.. _class_PhysicsServer2D_constant_INFO_ISLAND_COUNT:
.. rst-class:: classref-enumeration-constant
:ref:`ProcessInfo<enum_PhysicsServer2D_ProcessInfo>` **INFO_ISLAND_COUNT** = ``2``
Постійно отримати кількість просторих регіонів, де може відбуватися зіткнення.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Описи методів
--------------------------
.. _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>`
Додає форму в область, з заданою локальною трансформацією. Форма (все з його ``transform`` і ``disabled`` властивості) додається до масиву форм, а форми місцевості, як правило, посилаються їх індексом в цьому масиві.
.. 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>`
Прикріплюємо ``ObjectID`` полотна до площі. Використовуйте :ref:`Object.get_instance_id()<class_Object_method_get_instance_id>`, щоб отримати ``ObjectID`` :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>`
Прикріплюємо ``ObjectID`` :ref:`Object<class_Object>` в область. Використовуйте :ref:`Object.get_instance_id()<class_Object_method_get_instance_id>`, щоб отримати ``ObjectID`` :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>`
Видаліть всі форми з області. Це не видаліть самі форми, тому вони можуть продовжувати використовуватися в іншому місці або додавати назад пізніше.
.. 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>`
Створює об'єкт площею 2D в фізичному сервері, і повертає :ref:`RID<class_RID>`, який ідентифікує його. Параметри за замовчуванням для створеної площі включають шар зіткнення і набір масок для ``1``, і ``моніторинг``, встановлений до ``false``.
Використовуйте :ref:`_add_shape()<class_PhysicsServer2D_private_method__add_shape>`, щоб додати форми до нього, скористайтеся :ref:`_set_transform()<class_PhysicsServer2D_private_method__set_transform>`, щоб встановити його трансформацію, а також використовувати :ref:`_set_space()<class_PhysicsServer2D_private_method__set_space>` для додавання площі до простору. Якщо ви хочете, щоб зона була виявлена :ref:`_set_monitorable()<class_PhysicsServer2D_private_method__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>`
Повернення ``ObjectID`` полотна, прикріпленого до площі. Використовуйте :ref:`@GlobalScope.instance_from_id()<class_@GlobalScope_method_instance_from_id>` для отримання :ref:`CanvasLayer<class_CanvasLayer>` з nonzero ``ObjectID``.
.. 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>`
Повертає фізичний шар або шари площі належить до, як трохимаска.
.. 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>`
Повертає фізичний шар або шари ділянки можна зв'язатися з, як трохимаска.
.. 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>`
Повернення ``ObjectID`` прикріплюється до площі. Використовуйте :ref:`@GlobalScope.instance_from_id()<class_@GlobalScope_method_instance_from_id>` для отримання :ref:`Object<class_Object>` з nonzero ``ObjectID``.
.. 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>`
Повертає значення заданого параметра площі.
.. 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>`
Повертаємо форму з вказаним індексом в масиві форми.
.. 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>`
Повертаємо кількість форм, доданих в область.
.. 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>`
Повертає локальну трансформовану матрицю форми з урахуванням індексу в масиві форми.
.. 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>`
Повертаємо місце, призначене для місцевості. Повертає порожній :ref:`RID<class_RID>`, якщо не призначено місця.
.. 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>`
Повертає трансформаторну матрицю ділянки.
.. 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>`
Видаліть форму з заданим індексом з масиву площі форм. Сама форма не видаляється, тому вона може продовжувати використовуватися в іншому місці або додавати назад пізніше. В результаті цієї операції форма області, яка використовується для показників вище, ніж ``shape_idx``, буде індекс знизився на одному.
.. 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>`
Налаштовує зону моніторингу зворотного зв'язку. Цей зворотний зв'язок буде викликаний, коли будь-який інший (форма) область надходить або виходи (форма) даної області, і повинні прийняти наступні п'ять параметрів:
1. ціле ``статус``: або :ref:`AREA_BODY_ADDED<class_PhysicsServer2D_constant_AREA_BODY_ADDED>` або :ref:`AREA_BODY_REMOVED<class_PhysicsServer2D_constant_AREA_BODY_REMOVED>` в залежності від того, чи вводилася форма іншої області або виходу на область,
2. :ref:`RID<class_RID>` ``area_rid``: :ref:`RID<class_RID>` іншої області, яка введена або виходила область,
3. ціле ``instance_id``: ``ObjectID`` прикріплюється до іншої області,
4. ціле ``area_shape_idx``: індекс форми іншої області, яка вводиться або виходила область,
5. ціле ``self_shape_idx``: індекс форми місцевості, де вводиться інший район або виходив.
При підрахунку (або зберіганні доріжки) форми, які надходять і виходять, можна визначити, якщо область (з усіма його формами) вступає в перший раз або вихід на останній раз.
.. 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>`
Призначає площу до одного або багатьох фізичних шарів, через трохимаску.
.. 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>`
Набори, які фізичні шари області будуть контролювати, через бітмаску.
.. 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>`
Налаштовує зону моніторингу зворотного зв'язку. Цей зворотний зв'язок буде викликаний, коли будь-який інший (форма) область надходить або виходи (форма) даної області, і повинні прийняти наступні п'ять параметрів:
1. ціле ``статус``: або :ref:`AREA_BODY_ADDED<class_PhysicsServer2D_constant_AREA_BODY_ADDED>` або :ref:`AREA_BODY_REMOVED<class_PhysicsServer2D_constant_AREA_BODY_REMOVED>` в залежності від того, чи вводилася форма іншої області або виходу на область,
2. :ref:`RID<class_RID>` ``area_rid``: :ref:`RID<class_RID>` іншої області, яка введена або виходила область,
3. ціле ``instance_id``: ``ObjectID`` прикріплюється до іншої області,
4. ціле ``area_shape_idx``: індекс форми іншої області, яка вводиться або виходила область,
5. ціле ``self_shape_idx``: індекс форми місцевості, де вводиться інший район або виходив.
При підрахунку (або зберіганні доріжки) форми, які надходять і виходять, можна визначити, якщо область (з усіма його формами) вступає в перший раз або вихід на останній раз.
.. 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>`
Налаштовує, чи працює зона. Якщо ``control`` є ``true``, моніторинг зони зворотного виклику інших зон буде викликано, коли ця область надходить або виводить їх.
.. 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>`
Встановлює значення заданого параметра площі.
.. 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>`
Замінює форму місцевості за вказаним індексом за іншою формою, при цьому не впливає на ``трансформ`` і ``діалізовані`` властивості в одному індексі.
.. 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>`
Встановлює відключений майно форми ділянки з заданим індексом. Якщо ``вимкнено`` ``true``, то форма не виявить ніяких інших форм, що надходять або випускають її.
.. 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>`
Налаштовує локальну трансформовану матрицю форми ділянки з заданим індексом.
.. 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>`
Додає площу до даної площі, після видалення площі від раніше призначеного простору (якщо це).
\ **Примітка:** Для видалення площі з простору без негайного додавання його в іншому місці, використання ``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>`
Встановлює трансформовану матрицю площі.
.. 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>`
Додає ``excepted_body`` до списку винятків колізій тіла, щоб колізії з ним ігнорувалися.
.. 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>`
Додає постійну спрямовану силу організму. Потужність не впливає на обертання. На силі наноситься час до очищення `` PhysicsServer2D.body_set_constant_force(body, Vector2(0, 0)``.
Це еквівалентно використання :ref:`_add_constant_force()<class_PhysicsServer2D_private_method__add_constant_force>` в центрі маси тіла.
.. 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>`
Додає постійно діючу силу організму. сила може впливати на обертання, якщо ``position`` відрізняється від центру маси тіла. На силі наноситься час до очищення `` PhysicsServer2D.body_set_constant_force(body, Vector2(0, 0)``.
\ ``position`` – це зміщення з організму в глобальних координатах.
.. 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>`
Додавання постійної обертальної сили до тіла. сила не впливає на положення. На силі наноситься час до очищення `` 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>`
Додає форму в область, з заданою локальною трансформацією. Форма (все з його ``transform`` і ``disabled`` властивості) додається до масиву форм, а форми тіла зазвичай додаються їх індексом в цьому масиві.
.. 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>`
Застосовується спрямована сила організму, в центрі маси тіла. Потужність не впливає на обертання. Знаряддя часу залежна і означають, що кожен фізичний оновлення.
Це еквівалентно використанню :ref:`body_apply_force()<class_PhysicsServer2D_method_body_apply_force>` в центрі маси тіла.
.. 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>`
Застосовується спрямований імпульс до тіла, в центрі маси тіла. Імпульс не впливає на обертання.
Імпульс часозалежний! Нанесення імпульсу кожного кадру призведе до каркасно-залежної сили. З цієї причини слід використовувати тільки при симуляції одноразових ударів (користування функції "_force" інакше).
Це еквівалентно використанню :ref:`body_apply_impulse()<class_PhysicsServer2D_method_body_apply_impulse>` в центрі маси тіла.
.. 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>`
Застосовується сила позиціонування організму. сила може впливати на обертання, якщо ``position`` відрізняється від центру маси тіла. Знаряддя часу залежна і означають, що кожен фізичний оновлення.
\ ``position`` – це зміщення з організму в глобальних координатах.
.. 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>`
Відповідні імпульси до тіла. Імпульс може впливати на обертання, якщо ``position`` відрізняється від центру маси тіла.
Імпульс часозалежний! Нанесення імпульсу кожного кадру призведе до каркасно-залежної сили. З цієї причини слід використовувати тільки при симуляції одноразових ударів (користування функції "_сил" інакше).
\ ``position`` – це зміщення з організму в глобальних координатах.
.. 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>`
Застосовується обертальна сила до тіла. сила не впливає на положення. Знаряддя часу залежна і означена для кожного оновлення фізики.
.. 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>`
Застосовує обертальний імпульс до тіла. Імпульс не впливає на позицію.
Імпульс часозалежний! Нанесення імпульсу кожного кадру призведе до каркасно-залежної сили. З цієї причини слід використовувати тільки при симуляції одноразових ударів (користування функції "_сил" інакше).
.. 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>`
Прикріплюємо ``ObjectID`` полотна до тіла. Використовуйте :ref:`Object.get_instance_id()<class_Object_method_get_instance_id>`, щоб отримати ``ObjectID`` :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>`
Прикріплюємо ``ObjectID`` :ref:`Object<class_Object>` до тіла. Використовуйте :ref:`Object.get_instance_id()<class_Object_method_get_instance_id>`, щоб отримати ``ObjectID`` :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>`
Видаліть всі форми з тіла. Це не видаліть самі форми, тому вони можуть продовжувати використовуватися в іншому місці або додавати назад пізніше.
.. 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>`
Створює об'єкт 2D у фізичному сервері, і повертає :ref:`RID<class_RID>`, який ідентифікує його. Параметри за замовчуванням для створеної площі включають шар зіткнення і набір масок для ``1``, і режим кузова, встановленого до :ref:`BODY_MODE_RIGID<class_PhysicsServer2D_constant_BODY_MODE_RIGID>`.
Використовуйте :ref:`body_add_shape()<class_PhysicsServer2D_method_body_add_shape>`, щоб додати форми до нього, скористайтеся :ref:`body_set_state()<class_PhysicsServer2D_method_body_set_state>`, щоб встановити його трансформацію, і використовувати :ref:`body_set_space()<class_PhysicsServer2D_method_body_set_space>`, щоб додати тіло до простору.
.. 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>`
Повернення ``ObjectID`` полотна, прикріпленого до тіла. Використовуйте :ref:`@GlobalScope.instance_from_id()<class_@GlobalScope_method_instance_from_id>` для отримання :ref:`CanvasLayer<class_CanvasLayer>` з nonzero ``ObjectID``.
.. 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>`
Повертає фізичний шар або шари тіла належить до, як трохимаска.
.. 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>`
Повертає фізичний шар або шари тіла може з'єднуватися, як трохимаска.
.. 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>`
Повернення пріоритету зіткнення тіла. Це використовується в фазі депенетації :ref:`_test_motion()<class_PhysicsServer2D_private_method__test_motion>`. Чим вище пріоритет, тим нижче проникнення в тіло буде.
.. 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>`
Повертає загальний стан тіла, що застосовується під час кожного оновлення фізики.
Див. :ref:`_add_constant_force()<class_PhysicsServer2D_private_method__add_constant_force>` і :ref:`_add_constant_central_force()<class_PhysicsServer2D_private_method__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>`
Під час кожного оновлення фізики повернулися загальні постійні обертальні сили.
Див. :ref:`add_constant_torque()<class_PhysicsServer2D_method_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>`
Повертає режим безперервного виявлення зіткнень тіла.
.. 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>`
Повертає :ref:`PhysicsDirectBodyState2D<class_PhysicsDirectBodyState2D>` тіла. Повертає ``null``, якщо тіло знищено або не призначено пробілу.
.. 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>`
Повернутися до максимальної кількості контактів, які можуть звітувати організм. Див. :ref:`_set_max_contacts_reported()<class_PhysicsServer2D_private_method__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>`
Повертає режим тіла.
.. 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>`
Повернення ``ObjectID`` прикріплюється до тіла. Використовуйте :ref:`@GlobalScope.instance_from_id()<class_@GlobalScope_method_instance_from_id>` для отримання :ref:`Object<class_Object>` з nonzero ``ObjectID``.
.. 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>`
Повертає значення заданого параметра тіла.
.. 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>`
Повертаємо форму з вказаним індексом в масиві фігур.
.. 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>`
Повертаємо кількість форм, доданих до тіла.
.. 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>`
Повертає локальну трансформовану матрицю форми з урахуванням індексу в масиві форми.
.. 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>`
Повертаємо місце, призначене для тіла. Повертає порожній :ref:`RID<class_RID>`, якщо не призначено місця.
.. 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>`
Повертає значення заданого стану тіла.
.. 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>`
Повертаємо ``true``, якщо тіло відмовляється від стандартної силової інтеграції. Див. :ref:`_set_omit_force_integration()<class_PhysicsServer2D_private_method__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>`
Видаліть ``крімed_body`` з переліку вузлів зіткнення тіла, щоб зіткнення з ним більше не ігнорувалися.
.. 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>`
Вилучає форму з заданим індексом з масиву фігур тіла. Сама форма не видаляється, тому вона може продовжувати використовуватися в іншому місці або додавати назад пізніше. В результаті цієї операції форма тіла, яка використовується для індексів вище ``shape_idx``, буде індекс знизився на одному.
.. 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>`
Відновлює інерцію за замовчуванням і центр маси тіла на основі його форм. Цей не дає ніяких користувацьких значень, які раніше встановлюються за допомогою :ref:`_set_param()<class_PhysicsServer2D_private_method__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>`
Змінює лінійну швидкість тіла таким чином, щоб його проекція на вісь ``axis_velocity.normalized()`` дорівнювала точно ``axis_velocity.length()``. Це корисно для стрибків.
.. 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>`
Налаштовує фізичний шар або шари тіла, що належить, через трохимаску.
.. 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>`
Налаштовує фізичний шар або шари тіла може з'єднуватися, через трохимаску.
.. 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>`
Налаштування пріоритету зіткнення тіла. Це використовується в фазі депенетації :ref:`_test_motion()<class_PhysicsServer2D_private_method__test_motion>`. Чим вище пріоритет, тим нижче проникнення в тіло буде.
.. 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>`
Встановлює загальну постійну позиційну силу тіла, що застосовується під час кожного оновлення фізики.
Див. :ref:`body_add_constant_force()<class_PhysicsServer2D_method_body_add_constant_force>` та :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>`
Встановлює загальну постійну обертальну силу тіла, застосовану під час кожного оновлення фізики.
Подивитися :ref:`_add_constant_torque()<class_PhysicsServer2D_private_method__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>`
Встановлює режим безперервного виявлення зіткнень.
Безперервне виявлення зіткнень намагається передбачити, де рухоме тіло зіткнеться між оновленнями фізики, замість того, щоб переміщувати його та коригувати його рух у разі зіткнення.
.. 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>`
Налаштовує функцію зворотного зв’язку з користувацькими зусиллями тіла до ``callable``. Використовуйте порожній :ref:`Callable<class_Callable>` (``Callable()``) для очищення користувацького зворотного виклику.
Функція ``callable`` буде називатися кожен фізичний кліщ, перш ніж стандартна інтеграція сили (див. :ref:`body_set_omit_force_integration()<class_PhysicsServer2D_method_body_set_omit_force_integration>`). Для оновлення лінійної та кутової швидкості тіла можна використовувати наприклад, для оновлення лінійної та кутової швидкості на основі контакту з іншими тілами.
Якщо ``userdata`` не ``null``, функція ``callable`` повинна приймати наступні два параметри:
1. ``state``: a :ref:`PhysicsDirectBodyState2D<class_PhysicsDirectBodyState2D>` використовується для отримання та модифікації стану тіла,
2. ``код пропустити-лінт``\ userdata\ ``: a [Variant]; його значення буде [param userdata] передано в цей метод.
Якщо [param userdata] is [code]null``, то ``callable`` повинен прийняти тільки параметр ``state``.
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_body_set_max_contacts_reported:
.. rst-class:: classref-method
|void| **body_set_max_contacts_reported**\ (\ body\: :ref:`RID<class_RID>`, amount\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PhysicsServer2D_method_body_set_max_contacts_reported>`
Налаштовує максимальну кількість контактів, які можуть звітувати організм. Якщо ``amount`` перевищує нуль, то тіло буде стежити за більшістю цього багато контактів з іншими тілами.
.. 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>`
Встановлює режим організму.
.. 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>`
Налаштовує, чи є тіло, що має стандартну силову інтеграцію. Якщо ``enable`` є ``true``, тіло не буде автоматично використовувати застосовані сили, крутки, а також перешкоджати відновленню лінійної та кутової швидкості тіла. У цьому випадку можна використовувати для вручну оновлення лінійної та кутової швидкості.
Цей метод називається при наявності майна :ref:`RigidBody2D.custom_integrator<class_RigidBody2D_property_custom_integrator>`.
.. 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>`
Встановлює значення заданого параметра тіла.
.. 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>`
Замінює форму тіла на заданому індексі іншою формою, при цьому не впливає на ``transform``, ``розмкнено``, і односторонні зіткнені властивості при цьому показника.
.. 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>`
Налаштовує односторонню зіткненість форми тіла з заданим індексом. Якщо ``enable`` є ``true``, напрямок одностороннього зіткнення, надана локальною віссю форми ``body_get_shape_transform(body, форма_idx).y`` буде використовуватися для ігнорування зіткнення з формою в протилежному напрямку, і для забезпечення депеляції Кінематичних органів відбувається в цьому напрямку.
.. 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>`
Налаштовує відключений майно форми тіла з заданим індексом. Якщо ``enable`` ``true``, то форма буде ігноруватися у всіх виявленнях зіткнення.
.. 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>`
Налаштовує локальну трансформовану матрицю форми тіла з заданим індексом.
.. 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>`
Додає тіло до даної площі, після видалення тіла з раніше призначеного простору (якщо будь-який). Якщо режим тіла встановлюється до :ref:`BODY_MODE_RIGID<class_PhysicsServer2D_constant_BODY_MODE_RIGID>`, то додавання тіла до простору буде мати наступні додаткові ефекти:
- Якщо параметр :ref:`BODY_PARAM_CENTER_OF_MASS<class_PhysicsServer2D_constant_BODY_PARAM_CENTER_OF_MASS>` ніколи не був встановлений явно, то значення цього параметра буде перераховано на основі форми тіла.
- Якщо параметр :ref:`BODY_PARAM_INERTIA<class_PhysicsServer2D_constant_BODY_PARAM_INERTIA>` встановлюється на значення ``<= 0.0``, то значення цього параметра буде перераховуватися на основі форм тіла, маси та центру маси.
\ **Примітка:** Щоб видалити тіло з простору без негайного додавання його в іншому місці, скористайтеся ``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>`
Встановлює значення стану тіла.
\ **Примітка:** Зміна стану не набуває чинності негайно. Стан зміниться в наступному кадрі фізики.
.. 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>`
Налаштовує функцію зворотного виклику стану тіла до ``enable``. Використовуйте порожній :ref:`Callable<class_Callable>` (``Callable()``) для очищення зворотного виклику.
Функція ``callable`` буде називатися кожним фізичним кадром, припустимо, що тіло було активний під час попередньої фізики кліщу, і може бути використаний для виїдання останнього стану з фізичного сервера.
Функція ``callable`` повинна приймати такі параметри:
1. ``state``: a ``ФізикаDirectBodyState2D``, використовується для отримання стану тіла.
.. 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>`
Повертаємо ``true``, якщо зіткнення призведе до переміщення тіла вздовж вектора руху з даної точки в космосі. Див. :ref:`PhysicsTestMotionResult2D<class_PhysicsTestMotionResult2D>` для доступних параметрів руху. Додатково може бути переданий об'єкт :ref:`PhysicsTestMotionResult2D<class_PhysicsTestMotionResult2D>`, який буде використовуватися для зберігання інформації про отриманий зіткнення.
.. 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>`
Створює форму 2D капсули в фізичному сервері, і повертає :ref:`RID<class_RID>`, що ідентифікує його. Використовуйте :ref:`_set_data()<class_PhysicsServer2D_private_method__set_data>`, щоб встановити висоту капсули і радіус.
.. 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>`
Створює форму круга 2D на сервері фізики та повертає :ref:`RID<class_RID>`, що ідентифікує його. Використовуйте :ref:`_set_data()<class_PhysicsServer2D_private_method__set_data>`, щоб встановити радіус кола.
.. 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>`
Створює форму полігону 2D у фізичному сервері, і повертає :ref:`RID<class_RID>`, що ідентифікує його. Використовуйте :ref:`_set_data()<class_PhysicsServer2D_private_method__set_data>`, щоб встановити відрізки полігонів.
.. 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>`
Створює форму полігону 2D у фізичному сервері та повертає :ref:`RID<class_RID>`, що ідентифікує його. Використовуйте :ref:`_set_data()<class_PhysicsServer2D_private_method__set_data>` для встановлення точок конвекційного полігону.
.. 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>`
Повертає значення заданого параметра пружинного з'єднання з демпфуванням.
.. 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>`
Встановлює значення заданого параметра демпфованого пружинного з'єднання.
.. 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>`
Дестройс будь-який з об'єктів, створених фізикоюServer2D. Якщо :ref:`RID<class_RID>` пропущено не одне з об'єктів, які можуть бути створені за допомогою PhysServer2D, похибка буде надрукована на консолі.
.. 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>`
Повертає значення стану фізичного движка, заданого параметром ``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>`
Знижує суглоб з даної :ref:`RID<class_RID>`, створює новий неініціалізований суглоб, і робить :ref:`RID<class_RID>` на це новий суглоб.
.. 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>`
Створює 2D-стик на сервері фізики та повертає :ref:`RID<class_RID>`, який його ідентифікує. Щоб встановити тип стику, використовуйте :ref:`joint_make_damped_spring()<class_PhysicsServer2D_method_joint_make_damped_spring>`, :ref:`joint_make_groove()<class_PhysicsServer2D_method_joint_make_groove>` до :ref:`joint_make_pin()<class_PhysicsServer2D_method_joint_make_pin>`. Використовуйте :ref:`joint_set_param()<class_PhysicsServer2D_method_joint_set_param>` для встановлення загальних параметрів з'єднання.
.. 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>`
Налаштовує, чи прикріплюються до :ref:`Joint2D<class_Joint2D>`, з’єднаються один з одним.
.. 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>`
Повертає значення заданого параметра суглоба.
.. 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>`
Повертає тип суглоба.
.. 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>`
Повертаємо вашу увагу на те, що ті органи, прикріплені до :ref:`Joint2D<class_Joint2D>`, зіштовхуються один з одним.
.. 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>`
Зробіть спільний знімний весняний суглоб, прикріплений в пункті ``Anchor_a`` (поважає в глобальних координатах) на тілі ``body_a`` і в пункті ``Anchor_b`` (поважає в глобальних координатах) на тілі ``body_b``. Щоб встановити параметри, які специфічні для занурення пружини, див. :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>`
Зробіть з'єднання пазового суглоба.
.. 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>`
Зробіть штепсельний суглоб. Якщо ``body_b`` є порожньою :ref:`RID<class_RID>`, то ``body_a`` прикріплюється до точки ``anchor`` (глибока глобальна координація); інакше ``body_a`` прикріплюється до ``body_b`` в точці ``Anchor`` (поважається в глобальних координати). Щоб встановити параметри, які специфічні для контактного суглоба, див. :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>`
Встановлює значення заданого параметра з'єднання.
.. 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>`
Отримує прапорець штифтового з'єднання.
.. 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>`
Повертає значення параметра штифтового з'єднання.
.. 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>`
Встановлює прапорець штифтового з'єднання.
.. 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>`
Встановлює параметр штифтового з'єднання.
.. 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>`
Створює форму прямокутника 2D на сервері фізики та повертає :ref:`RID<class_RID>`, що ідентифікує його. Використовуйте :ref:`_set_data()<class_PhysicsServer2D_private_method__set_data>` для встановлення піввидатків прямокутника.
.. 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>`
Створює форму сегмента 2D в фізичному сервері, і повертає :ref:`RID<class_RID>`, що ідентифікує його. Використовуйте :ref:`_set_data()<class_PhysicsServer2D_private_method__set_data>` для встановлення початкових точок сегмента.
.. 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>`
Створює форму 2D розділення променів у фізичному сервері та повертає :ref:`RID<class_RID>`, що ідентифікує його. Використовуйте :ref:`_set_data()<class_PhysicsServer2D_private_method__set_data>` для встановлення довжини форми і `` і `` та ``slide_on_slope`` властивостей.
.. 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>`
Активувати або деактивувати сервер фізики 2D. Якщо ``active`` є ``false``, то сервер фізики нічого не буде робити на своєму фізичному етапі.
.. 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>`
Повертаємо дані форми, що визначає конфігурацію форми, такі як піввидатки прямокутника або відрізки опалубки форми. Див. :ref:`_set_data()<class_PhysicsServer2D_private_method__set_data>` для точного формату даних в кожному випадку.
.. 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>`
Повертає тип фігури.
.. 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>`
Налаштовує дані форми, що визначає конфігурацію форми. ``data``, щоб бути передані в залежності від типу форми (див. :ref:`_git_get_type()<class_PhysicsServer2D_private_method__git_get_type>`):
- :ref:`SHAPE_WORLD_BOUNDARY<class_PhysicsServer2D_constant_SHAPE_WORLD_BOUNDARY>`: масив довжиною два, що містять :ref:`Vector2<class_Vector2>` ``нормальний`` напрямок і :ref:`float<class_float>` відстань ``d``,
- :ref:`SHAPE_SEPARATION_RAY<class_PhysicsServer2D_constant_SHAPE_SEPARATION_RAY>`: словник, що містить ключ `` довжиною`` з значенням :ref:`float<class_float>` та ключем ``slide_on_slope`` з значенням :ref:`bool<class_bool>`,
- :ref:`SHAPE_SEGMENT<class_PhysicsServer2D_constant_SHAPE_SEGMENT>`: :ref:`Rect2<class_Rect2>` ``rect``, що містить першу точку сегмента в ``rect.position`` і другу точку сегмента ``rect.size``,
- :ref:`SHAPE_CIRCLE<class_PhysicsServer2D_constant_SHAPE_CIRCLE>`: :ref:`float<class_float>` ``radius``,
- :ref:`SHAPE_RECTANGLE<class_PhysicsServer2D_constant_SHAPE_RECTANGLE>`: :ref:`Vector2<class_Vector2>` ``half_extents``,
- :ref:`SHAPE_CAPSULE<class_PhysicsServer2D_constant_SHAPE_CAPSULE>`: масив довжиною два (або :ref:`Vector2<class_Vector2>`), що містить :ref:`float<class_float>` ``height`` і :ref:`float<class_float>` ``radius``,
- :ref:`SHAPE_CONVEX_POLYGON<class_PhysicsServer2D_constant_SHAPE_CONVEX_POLYGON>`: або :ref:`PackedVector2Array<class_PackedVector2Array>` точок, що визначають конвекційний полігон в проти годинникової стрілки (звичайно з кожного сегмента, що утворюється послідовними точками, обчислюється внутрішньо), або :ref:`PackedFloat32Array<class_PackedFloat32Array>` довжини, що вирізняється чотирим, так що кожен 4-рівний :ref:`float<class_float>` містить координати точки, що слідують координати годинникової вихідної нормальної вектора до сегмента між поточною точкою і наступною точкою,
- :ref:`SHAPE_CONCAVE_POLYGON<class_PhysicsServer2D_constant_SHAPE_CONCAVE_POLYGON>`: :ref:`PackedVector2Array<class_PackedVector2Array>` довжиною дівидимий на два (учня пара точок утворює один сегмент).
\ **Попередження:** У випадку :ref:`SHAPE_CONVEX_POLYGON<class_PhysicsServer2D_constant_SHAPE_CONVEX_POLYGON>` цей метод не перевіряє, якщо точки, що поставляються фактично, утворюють конвекційний полігон (не схожий на :ref:`CollisionPolygon2D.polygon<class_CollisionPolygon2D_property_polygon>` майно).
.. rst-class:: classref-item-separator
----
.. _class_PhysicsServer2D_method_space_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **space_create**\ (\ ) :ref:`🔗<class_PhysicsServer2D_method_space_create>`
Створення простору 2D в фізичному сервері та повертає :ref:`RID<class_RID>`, що ідентифікує його. Простір містить тіла і ділянки, а також контролює формування фізико-імплантаційного моделювання об'єктів в ньому.
.. 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>`
Повертає стан простору, :ref:`PhysicsDirectSpaceState2D<class_PhysicsDirectSpaceState2D>`. Цей об'єкт можна використовувати для запитів на колізії/перетини.
.. 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>`
Повертає значення заданого параметра простору.
.. 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>`
Повертаємо ``true``, якщо простір активний.
.. 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>`
Активує або деактивує простір. Якщо ``active`` є ``false``, то сервер фізики нічого не буде робити з цим простором у своєму фізичному крокі.
.. 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>`
Встановлює значення заданого параметра простору.
.. 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>`
Створює 2D світову граничну форму у фізичному сервері, і повертає :ref:`RID<class_RID>`, що ідентифікує його. Використовуйте :ref:`_set_data()<class_PhysicsServer2D_private_method__set_data>`, щоб встановити нормальний напрямок форми та властивості відстані.
.. |virtual| replace:: :abbr:`virtual (Зазвичай, цей метод перевизначається користувачем, щоб він мав вплив.)`
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
.. |const| replace:: :abbr:`const (Цей метод не має побічних ефектів. Не змінює ніяку змінну екземпляра об'єкта.)`
.. |vararg| replace:: :abbr:`vararg (Цей метод приймає будь-яке число аргументів після описаних тут.)`
.. |constructor| replace:: :abbr:`constructor (Цей метод використовується для побудови типів.)`
.. |static| replace:: :abbr:`static (Цей метод не потребує екземпляра для виклику, його можна викликати безпосередньо за допомогою назви класу.)`
.. |operator| replace:: :abbr:`operator (Цей метод описує дійсний оператор для взаємодії з цим типом як з лівим операндом.)`
.. |bitfield| replace:: :abbr:`BitField (Це значення є цілим числом, складеним у вигляді бітової маски з наступних прапорів.)`
.. |void| replace:: :abbr:`void (Значення не повертається.)`
Reference in New Issue View Git Blame Copy Permalink