godotengine/godot-docs-l10n
1
0
Fork 0
mirror of https://github.com/godotengine/godot-docs-l10n.git synced 2025-12-31 09:49:22 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
4.x
godot-docs-l10n/classes/es/class_collisionobject2d.rst
Rémi Verschelde 369fd84a4f Sync classref with 4.5 branch
2025-12-19 14:34:07 +01:00

681 lines
43 KiB
ReStructuredText
Raw Permalink Blame History

:github_url: hide
.. _class_CollisionObject2D:
CollisionObject2D
=================
**Hereda:** :ref:`Node2D<class_Node2D>` **<** :ref:`CanvasItem<class_CanvasItem>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
**Heredado por:** :ref:`Area2D<class_Area2D>`, :ref:`PhysicsBody2D<class_PhysicsBody2D>`
Clase base abstracta para objetos de física 2D.
.. rst-class:: classref-introduction-group
Descripción
----------------------
Clase base abstracta para objetos físicos 2D. **CollisionObject2D** puede contener cualquier número de :ref:`Shape2D<class_Shape2D>`\ s para la colisión. Cada forma debe ser asignada a un *propietario de la forma*. Los propietarios de la forma no son nodos y no aparecen en el editor, pero son accesibles a través del código usando los métodos ``shape_owner_*``.
\ **Nota:** Sólo se admiten colisiones entre objetos dentro del mismo canvas (:ref:`Viewport<class_Viewport>` o :ref:`CanvasLayer<class_CanvasLayer>`). El comportamiento de las colisiones entre objetos en diferentes canvas no está definido.
.. rst-class:: classref-reftable-group
Propiedades
----------------------
.. table::
:widths: auto
+--------------------------------------------------------+--------------------------------------------------------------------------------+----------+
| :ref:`int<class_int>` | :ref:`collision_layer<class_CollisionObject2D_property_collision_layer>` | ``1`` |
+--------------------------------------------------------+--------------------------------------------------------------------------------+----------+
| :ref:`int<class_int>` | :ref:`collision_mask<class_CollisionObject2D_property_collision_mask>` | ``1`` |
+--------------------------------------------------------+--------------------------------------------------------------------------------+----------+
| :ref:`float<class_float>` | :ref:`collision_priority<class_CollisionObject2D_property_collision_priority>` | ``1.0`` |
+--------------------------------------------------------+--------------------------------------------------------------------------------+----------+
| :ref:`DisableMode<enum_CollisionObject2D_DisableMode>` | :ref:`disable_mode<class_CollisionObject2D_property_disable_mode>` | ``0`` |
+--------------------------------------------------------+--------------------------------------------------------------------------------+----------+
| :ref:`bool<class_bool>` | :ref:`input_pickable<class_CollisionObject2D_property_input_pickable>` | ``true`` |
+--------------------------------------------------------+--------------------------------------------------------------------------------+----------+
.. rst-class:: classref-reftable-group
Métodos
--------------
.. table::
:widths: auto
+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`_input_event<class_CollisionObject2D_private_method__input_event>`\ (\ viewport\: :ref:`Viewport<class_Viewport>`, event\: :ref:`InputEvent<class_InputEvent>`, shape_idx\: :ref:`int<class_int>`\ ) |virtual| |
+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`_mouse_enter<class_CollisionObject2D_private_method__mouse_enter>`\ (\ ) |virtual| |
+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`_mouse_exit<class_CollisionObject2D_private_method__mouse_exit>`\ (\ ) |virtual| |
+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`_mouse_shape_enter<class_CollisionObject2D_private_method__mouse_shape_enter>`\ (\ shape_idx\: :ref:`int<class_int>`\ ) |virtual| |
+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`_mouse_shape_exit<class_CollisionObject2D_private_method__mouse_shape_exit>`\ (\ shape_idx\: :ref:`int<class_int>`\ ) |virtual| |
+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`create_shape_owner<class_CollisionObject2D_method_create_shape_owner>`\ (\ owner\: :ref:`Object<class_Object>`\ ) |
+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`get_collision_layer_value<class_CollisionObject2D_method_get_collision_layer_value>`\ (\ layer_number\: :ref:`int<class_int>`\ ) |const| |
+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`get_collision_mask_value<class_CollisionObject2D_method_get_collision_mask_value>`\ (\ layer_number\: :ref:`int<class_int>`\ ) |const| |
+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`get_rid<class_CollisionObject2D_method_get_rid>`\ (\ ) |const| |
+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`get_shape_owner_one_way_collision_margin<class_CollisionObject2D_method_get_shape_owner_one_way_collision_margin>`\ (\ owner_id\: :ref:`int<class_int>`\ ) |const| |
+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedInt32Array<class_PackedInt32Array>` | :ref:`get_shape_owners<class_CollisionObject2D_method_get_shape_owners>`\ (\ ) |
+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_shape_owner_disabled<class_CollisionObject2D_method_is_shape_owner_disabled>`\ (\ owner_id\: :ref:`int<class_int>`\ ) |const| |
+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_shape_owner_one_way_collision_enabled<class_CollisionObject2D_method_is_shape_owner_one_way_collision_enabled>`\ (\ owner_id\: :ref:`int<class_int>`\ ) |const| |
+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`remove_shape_owner<class_CollisionObject2D_method_remove_shape_owner>`\ (\ owner_id\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_collision_layer_value<class_CollisionObject2D_method_set_collision_layer_value>`\ (\ layer_number\: :ref:`int<class_int>`, value\: :ref:`bool<class_bool>`\ ) |
+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_collision_mask_value<class_CollisionObject2D_method_set_collision_mask_value>`\ (\ layer_number\: :ref:`int<class_int>`, value\: :ref:`bool<class_bool>`\ ) |
+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`shape_find_owner<class_CollisionObject2D_method_shape_find_owner>`\ (\ shape_index\: :ref:`int<class_int>`\ ) |const| |
+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`shape_owner_add_shape<class_CollisionObject2D_method_shape_owner_add_shape>`\ (\ owner_id\: :ref:`int<class_int>`, shape\: :ref:`Shape2D<class_Shape2D>`\ ) |
+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`shape_owner_clear_shapes<class_CollisionObject2D_method_shape_owner_clear_shapes>`\ (\ owner_id\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Object<class_Object>` | :ref:`shape_owner_get_owner<class_CollisionObject2D_method_shape_owner_get_owner>`\ (\ owner_id\: :ref:`int<class_int>`\ ) |const| |
+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Shape2D<class_Shape2D>` | :ref:`shape_owner_get_shape<class_CollisionObject2D_method_shape_owner_get_shape>`\ (\ owner_id\: :ref:`int<class_int>`, shape_id\: :ref:`int<class_int>`\ ) |const| |
+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`shape_owner_get_shape_count<class_CollisionObject2D_method_shape_owner_get_shape_count>`\ (\ owner_id\: :ref:`int<class_int>`\ ) |const| |
+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`shape_owner_get_shape_index<class_CollisionObject2D_method_shape_owner_get_shape_index>`\ (\ owner_id\: :ref:`int<class_int>`, shape_id\: :ref:`int<class_int>`\ ) |const| |
+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Transform2D<class_Transform2D>` | :ref:`shape_owner_get_transform<class_CollisionObject2D_method_shape_owner_get_transform>`\ (\ owner_id\: :ref:`int<class_int>`\ ) |const| |
+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`shape_owner_remove_shape<class_CollisionObject2D_method_shape_owner_remove_shape>`\ (\ owner_id\: :ref:`int<class_int>`, shape_id\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`shape_owner_set_disabled<class_CollisionObject2D_method_shape_owner_set_disabled>`\ (\ owner_id\: :ref:`int<class_int>`, disabled\: :ref:`bool<class_bool>`\ ) |
+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`shape_owner_set_one_way_collision<class_CollisionObject2D_method_shape_owner_set_one_way_collision>`\ (\ owner_id\: :ref:`int<class_int>`, enable\: :ref:`bool<class_bool>`\ ) |
+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`shape_owner_set_one_way_collision_margin<class_CollisionObject2D_method_shape_owner_set_one_way_collision_margin>`\ (\ owner_id\: :ref:`int<class_int>`, margin\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`shape_owner_set_transform<class_CollisionObject2D_method_shape_owner_set_transform>`\ (\ owner_id\: :ref:`int<class_int>`, transform\: :ref:`Transform2D<class_Transform2D>`\ ) |
+-------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Señales
--------------
.. _class_CollisionObject2D_signal_input_event:
.. rst-class:: classref-signal
**input_event**\ (\ viewport\: :ref:`Node<class_Node>`, event\: :ref:`InputEvent<class_InputEvent>`, shape_idx\: :ref:`int<class_int>`\ ) :ref:`🔗<class_CollisionObject2D_signal_input_event>`
Emitida cuando ocurre un evento de entrada. Requiere que :ref:`input_pickable<class_CollisionObject2D_property_input_pickable>` sea ``true`` y que al menos un bit de :ref:`collision_layer<class_CollisionObject2D_property_collision_layer>` esté establecido. Véase :ref:`_input_event()<class_CollisionObject2D_private_method__input_event>` para más detalles.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_signal_mouse_entered:
.. rst-class:: classref-signal
**mouse_entered**\ (\ ) :ref:`🔗<class_CollisionObject2D_signal_mouse_entered>`
Emitida cuando el puntero del ratón entra en cualquiera de las formas de este objeto. Requiere que :ref:`input_pickable<class_CollisionObject2D_property_input_pickable>` sea ``true`` y que al menos un bit de :ref:`collision_layer<class_CollisionObject2D_property_collision_layer>` esté establecido. Ten en cuenta que moverse entre diferentes formas dentro de un único **CollisionObject2D** no provocará que esta señal se emita.
\ **Nota:** Debido a la falta de detección de colisión continua, esta señal puede no emitirse en el orden esperado si el ratón se mueve lo suficientemente rápido y el área del **CollisionObject2D** es pequeña. Esta señal también puede no emitirse si otro **CollisionObject2D** está solapando al **CollisionObject2D** en cuestión.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_signal_mouse_exited:
.. rst-class:: classref-signal
**mouse_exited**\ (\ ) :ref:`🔗<class_CollisionObject2D_signal_mouse_exited>`
Emitida cuando el puntero del ratón sale de todas las formas de este objeto. Requiere que :ref:`input_pickable<class_CollisionObject2D_property_input_pickable>` sea ``true`` y que al menos un bit de :ref:`collision_layer<class_CollisionObject2D_property_collision_layer>` esté establecido. Ten en cuenta que moverse entre diferentes formas dentro de un único **CollisionObject2D** no provocará que esta señal se emita.
\ **Nota:** Debido a la falta de detección de colisión continua, esta señal puede no emitirse en el orden esperado si el ratón se mueve lo suficientemente rápido y el área del **CollisionObject2D** es pequeña. Esta señal también puede no emitirse si otro **CollisionObject2D** está solapando al **CollisionObject2D** en cuestión.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_signal_mouse_shape_entered:
.. rst-class:: classref-signal
**mouse_shape_entered**\ (\ shape_idx\: :ref:`int<class_int>`\ ) :ref:`🔗<class_CollisionObject2D_signal_mouse_shape_entered>`
Emitida cuando el puntero del ratón entra en cualquiera de las formas de este objeto o se mueve de una forma a otra. ``shape_idx`` es el índice hijo de la :ref:`Shape2D<class_Shape2D>` recién entrada. Requiere que :ref:`input_pickable<class_CollisionObject2D_property_input_pickable>` sea ``true`` y que al menos un bit de :ref:`collision_layer<class_CollisionObject2D_property_collision_layer>` esté establecido.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_signal_mouse_shape_exited:
.. rst-class:: classref-signal
**mouse_shape_exited**\ (\ shape_idx\: :ref:`int<class_int>`\ ) :ref:`🔗<class_CollisionObject2D_signal_mouse_shape_exited>`
Emitida cuando el puntero del ratón sale de cualquiera de las formas de este objeto. ``shape_idx`` es el índice hijo de la :ref:`Shape2D<class_Shape2D>` de la que se ha salido. Requiere que :ref:`input_pickable<class_CollisionObject2D_property_input_pickable>` sea ``true`` y que al menos un bit de :ref:`collision_layer<class_CollisionObject2D_property_collision_layer>` esté establecido.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Enumeraciones
--------------------------
.. _enum_CollisionObject2D_DisableMode:
.. rst-class:: classref-enumeration
enum **DisableMode**: :ref:`🔗<enum_CollisionObject2D_DisableMode>`
.. _class_CollisionObject2D_constant_DISABLE_MODE_REMOVE:
.. rst-class:: classref-enumeration-constant
:ref:`DisableMode<enum_CollisionObject2D_DisableMode>` **DISABLE_MODE_REMOVE** = ``0``
Cuando :ref:`Node.process_mode<class_Node_property_process_mode>` se establece en :ref:`Node.PROCESS_MODE_DISABLED<class_Node_constant_PROCESS_MODE_DISABLED>`, se elimina de la simulación de físicas para detener todas las interacciones de físicas con este **CollisionObject2D**.
Se vuelve a añadir automáticamente a la simulación de físicas cuando el :ref:`Node<class_Node>` se procesa de nuevo.
.. _class_CollisionObject2D_constant_DISABLE_MODE_MAKE_STATIC:
.. rst-class:: classref-enumeration-constant
:ref:`DisableMode<enum_CollisionObject2D_DisableMode>` **DISABLE_MODE_MAKE_STATIC** = ``1``
Cuando :ref:`Node.process_mode<class_Node_property_process_mode>` se establece en :ref:`Node.PROCESS_MODE_DISABLED<class_Node_constant_PROCESS_MODE_DISABLED>`, hace que el cuerpo sea estático. No afecta a :ref:`Area2D<class_Area2D>`. Un :ref:`PhysicsBody2D<class_PhysicsBody2D>` no puede ser afectado por fuerzas u otros cuerpos mientras es estático.
Automáticamente devuelve el :ref:`PhysicsBody2D<class_PhysicsBody2D>` a su modo original cuando el :ref:`Node<class_Node>` se procesa de nuevo.
.. _class_CollisionObject2D_constant_DISABLE_MODE_KEEP_ACTIVE:
.. rst-class:: classref-enumeration-constant
:ref:`DisableMode<enum_CollisionObject2D_DisableMode>` **DISABLE_MODE_KEEP_ACTIVE** = ``2``
Cuando :ref:`Node.process_mode<class_Node_property_process_mode>` se establece en :ref:`Node.PROCESS_MODE_DISABLED<class_Node_constant_PROCESS_MODE_DISABLED>`, no afecta a la simulación de físicas.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descripciones de Propiedades
--------------------------------------------------------
.. _class_CollisionObject2D_property_collision_layer:
.. rst-class:: classref-property
:ref:`int<class_int>` **collision_layer** = ``1`` :ref:`🔗<class_CollisionObject2D_property_collision_layer>`
.. rst-class:: classref-property-setget
- |void| **set_collision_layer**\ (\ value\: :ref:`int<class_int>`\ )
- :ref:`int<class_int>` **get_collision_layer**\ (\ )
Las capas de físicas en las que se encuentra este CollisionObject2D. Los objetos de colisión pueden existir en una o más de 32 capas diferentes. Ver también :ref:`collision_mask<class_CollisionObject2D_property_collision_mask>`.
\ **Nota:** Un objeto A puede detectar un contacto con un objeto B solo si el objeto B está en alguna de las capas que el objeto A escanea. Para más información, Véase `Capas y máscaras de colisión <../tutorials/physics/physics_introduction.html#collision-layers-and-masks>`__ en la documentación.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_property_collision_mask:
.. rst-class:: classref-property
:ref:`int<class_int>` **collision_mask** = ``1`` :ref:`🔗<class_CollisionObject2D_property_collision_mask>`
.. rst-class:: classref-property-setget
- |void| **set_collision_mask**\ (\ value\: :ref:`int<class_int>`\ )
- :ref:`int<class_int>` **get_collision_mask**\ (\ )
Las capas de físicas que este CollisionObject2D escanea. Los objetos de colisión pueden escanear una o más de 32 capas diferentes. Véase también :ref:`collision_layer<class_CollisionObject2D_property_collision_layer>`.
\ **Nota:** Un objeto A puede detectar un contacto con un objeto B solo si el objeto B está en alguna de las capas que el objeto A escanea. Para más información, Véase `Capas y máscaras de colisión <../tutorials/physics/physics_introduction.html#collision-layers-and-masks>`__ en la documentación.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_property_collision_priority:
.. rst-class:: classref-property
:ref:`float<class_float>` **collision_priority** = ``1.0`` :ref:`🔗<class_CollisionObject2D_property_collision_priority>`
.. rst-class:: classref-property-setget
- |void| **set_collision_priority**\ (\ value\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_collision_priority**\ (\ )
La prioridad usada para resolver colisiones cuando ocurre penetración. Cuanto mayor sea la prioridad, menor será la penetración en el objeto. Esto puede usarse, por ejemplo, para evitar que el jugador atraviese los límites de un nivel.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_property_disable_mode:
.. rst-class:: classref-property
:ref:`DisableMode<enum_CollisionObject2D_DisableMode>` **disable_mode** = ``0`` :ref:`🔗<class_CollisionObject2D_property_disable_mode>`
.. rst-class:: classref-property-setget
- |void| **set_disable_mode**\ (\ value\: :ref:`DisableMode<enum_CollisionObject2D_DisableMode>`\ )
- :ref:`DisableMode<enum_CollisionObject2D_DisableMode>` **get_disable_mode**\ (\ )
Define el comportamiento en la física cuando :ref:`Node.process_mode<class_Node_property_process_mode>` se establece a :ref:`Node.PROCESS_MODE_DISABLED<class_Node_constant_PROCESS_MODE_DISABLED>`.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_property_input_pickable:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **input_pickable** = ``true`` :ref:`🔗<class_CollisionObject2D_property_input_pickable>`
.. rst-class:: classref-property-setget
- |void| **set_pickable**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_pickable**\ (\ )
Si es ``true``, este objeto es seleccionable. Un objeto seleccionable puede detectar la entrada/salida del puntero del ratón y, si el ratón está dentro de él, informar de los eventos de entrada. Requiere que al menos un bit de :ref:`collision_layer<class_CollisionObject2D_property_collision_layer>` esté establecido.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descripciones de Métodos
------------------------------------------------
.. _class_CollisionObject2D_private_method__input_event:
.. rst-class:: classref-method
|void| **_input_event**\ (\ viewport\: :ref:`Viewport<class_Viewport>`, event\: :ref:`InputEvent<class_InputEvent>`, shape_idx\: :ref:`int<class_int>`\ ) |virtual| :ref:`🔗<class_CollisionObject2D_private_method__input_event>`
Acepta :ref:`InputEvent<class_InputEvent>`\ s no gestionados. ``shape_idx`` es el índice hijo del :ref:`Shape2D<class_Shape2D>` clickeado. Conéctate a la :ref:`input_event<class_CollisionObject2D_signal_input_event>` para capturar fácilmente estos eventos.
\ **Nota:** :ref:`_input_event()<class_CollisionObject2D_private_method__input_event>` requiere que :ref:`input_pickable<class_CollisionObject2D_property_input_pickable>` sea ``true`` y que al menos un bit de :ref:`collision_layer<class_CollisionObject2D_property_collision_layer>` esté establecido.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_private_method__mouse_enter:
.. rst-class:: classref-method
|void| **_mouse_enter**\ (\ ) |virtual| :ref:`🔗<class_CollisionObject2D_private_method__mouse_enter>`
Llamado cuando el puntero del ratón entra en cualquiera de las formas de este objeto. Requiere que :ref:`input_pickable<class_CollisionObject2D_property_input_pickable>` sea ``true`` y que al menos un bit de :ref:`collision_layer<class_CollisionObject2D_property_collision_layer>` esté establecido. Ten en cuenta que moverte entre diferentes formas dentro de un único **CollisionObject2D** no causará que esta función sea llamada.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_private_method__mouse_exit:
.. rst-class:: classref-method
|void| **_mouse_exit**\ (\ ) |virtual| :ref:`🔗<class_CollisionObject2D_private_method__mouse_exit>`
Llamado cuando el puntero del ratón sale de todas las formas de este objeto. Requiere que :ref:`input_pickable<class_CollisionObject2D_property_input_pickable>` sea ``true`` y que al menos un bit de :ref:`collision_layer<class_CollisionObject2D_property_collision_layer>` esté establecido. Ten en cuenta que moverte entre diferentes formas dentro de un único **CollisionObject2D** no causará que esta función sea llamada.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_private_method__mouse_shape_enter:
.. rst-class:: classref-method
|void| **_mouse_shape_enter**\ (\ shape_idx\: :ref:`int<class_int>`\ ) |virtual| :ref:`🔗<class_CollisionObject2D_private_method__mouse_shape_enter>`
Llamado cuando el puntero del ratón entra en cualquiera de las formas de este objeto o se mueve de una forma a otra. ``shape_idx`` es el índice del hijo :ref:`Shape2D<class_Shape2D>` recién entrado. Requiere que :ref:`input_pickable<class_CollisionObject2D_property_input_pickable>` sea ``true`` y que al menos un bit de :ref:`collision_layer<class_CollisionObject2D_property_collision_layer>` esté establecido.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_private_method__mouse_shape_exit:
.. rst-class:: classref-method
|void| **_mouse_shape_exit**\ (\ shape_idx\: :ref:`int<class_int>`\ ) |virtual| :ref:`🔗<class_CollisionObject2D_private_method__mouse_shape_exit>`
Llamado cuando el puntero del ratón sale de cualquiera de las formas de este objeto. ``shape_idx`` es el índice hijo del :ref:`Shape2D<class_Shape2D>` que se ha salido. Requiere que :ref:`input_pickable<class_CollisionObject2D_property_input_pickable>` sea ``true`` y al menos un bit de :ref:`collision_layer<class_CollisionObject2D_property_collision_layer>` esté establecido.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_method_create_shape_owner:
.. rst-class:: classref-method
:ref:`int<class_int>` **create_shape_owner**\ (\ owner\: :ref:`Object<class_Object>`\ ) :ref:`🔗<class_CollisionObject2D_method_create_shape_owner>`
Crea un nuevo dueño de la forma para el objeto dado. Devuelve ``owner_id`` del nuevo propietario para futuras referencias.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_method_get_collision_layer_value:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **get_collision_layer_value**\ (\ layer_number\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_CollisionObject2D_method_get_collision_layer_value>`
Devuelve si la capa especificada de :ref:`collision_layer<class_CollisionObject2D_property_collision_layer>` está habilitada o no, dado un ``layer_number`` entre 1 y 32.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_method_get_collision_mask_value:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **get_collision_mask_value**\ (\ layer_number\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_CollisionObject2D_method_get_collision_mask_value>`
Devuelve si la capa especificada de :ref:`collision_mask<class_CollisionObject2D_property_collision_mask>` está habilitada o no, dado un ``layer_number`` entre 1 y 32.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_method_get_rid:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **get_rid**\ (\ ) |const| :ref:`🔗<class_CollisionObject2D_method_get_rid>`
Devuelve el :ref:`RID<class_RID>` del objeto.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_method_get_shape_owner_one_way_collision_margin:
.. rst-class:: classref-method
:ref:`float<class_float>` **get_shape_owner_one_way_collision_margin**\ (\ owner_id\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_CollisionObject2D_method_get_shape_owner_one_way_collision_margin>`
Devuelve el ``one_way_collision_margin`` del propietario de la forma identificado por el ``owner_id`` dado.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_method_get_shape_owners:
.. rst-class:: classref-method
:ref:`PackedInt32Array<class_PackedInt32Array>` **get_shape_owners**\ (\ ) :ref:`🔗<class_CollisionObject2D_method_get_shape_owners>`
Devuelve un :ref:`Array<class_Array>` de identificadores ``owner_id``. Puedes usar estos identificadores en otros métodos que toman ``owner_id`` como argumento.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_method_is_shape_owner_disabled:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_shape_owner_disabled**\ (\ owner_id\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_CollisionObject2D_method_is_shape_owner_disabled>`
Si es ``true``, el propietario de la forma y sus formas se desactivan.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_method_is_shape_owner_one_way_collision_enabled:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_shape_owner_one_way_collision_enabled**\ (\ owner_id\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_CollisionObject2D_method_is_shape_owner_one_way_collision_enabled>`
Devuelve ``true`` si las colisiones para el propietario de la forma originadas por este **CollisionObject2D** no serán reportadas como colisionadas con los **CollisionObject2D**\ s.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_method_remove_shape_owner:
.. rst-class:: classref-method
|void| **remove_shape_owner**\ (\ owner_id\: :ref:`int<class_int>`\ ) :ref:`🔗<class_CollisionObject2D_method_remove_shape_owner>`
Elimina al dueño de la forma dada.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_method_set_collision_layer_value:
.. rst-class:: classref-method
|void| **set_collision_layer_value**\ (\ layer_number\: :ref:`int<class_int>`, value\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_CollisionObject2D_method_set_collision_layer_value>`
Basado en ``value``, habilita o deshabilita la capa especificada en :ref:`collision_layer<class_CollisionObject2D_property_collision_layer>`, dado un ``layer_number`` entre 1 y 32.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_method_set_collision_mask_value:
.. rst-class:: classref-method
|void| **set_collision_mask_value**\ (\ layer_number\: :ref:`int<class_int>`, value\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_CollisionObject2D_method_set_collision_mask_value>`
Basado en ``value``, habilita o deshabilita la capa especificada en :ref:`collision_mask<class_CollisionObject2D_property_collision_mask>`, dado un ``layer_number`` entre 1 y 32.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_method_shape_find_owner:
.. rst-class:: classref-method
:ref:`int<class_int>` **shape_find_owner**\ (\ shape_index\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_CollisionObject2D_method_shape_find_owner>`
Devuelve el ``owner_id`` de la forma dada.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_method_shape_owner_add_shape:
.. rst-class:: classref-method
|void| **shape_owner_add_shape**\ (\ owner_id\: :ref:`int<class_int>`, shape\: :ref:`Shape2D<class_Shape2D>`\ ) :ref:`🔗<class_CollisionObject2D_method_shape_owner_add_shape>`
Añade un :ref:`Shape2D<class_Shape2D>` al dueño de la forma.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_method_shape_owner_clear_shapes:
.. rst-class:: classref-method
|void| **shape_owner_clear_shapes**\ (\ owner_id\: :ref:`int<class_int>`\ ) :ref:`🔗<class_CollisionObject2D_method_shape_owner_clear_shapes>`
Elimina todas las formas del dueño de la forma.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_method_shape_owner_get_owner:
.. rst-class:: classref-method
:ref:`Object<class_Object>` **shape_owner_get_owner**\ (\ owner_id\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_CollisionObject2D_method_shape_owner_get_owner>`
Devuelve el objeto padre del propietario de la forma dada.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_method_shape_owner_get_shape:
.. rst-class:: classref-method
:ref:`Shape2D<class_Shape2D>` **shape_owner_get_shape**\ (\ owner_id\: :ref:`int<class_int>`, shape_id\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_CollisionObject2D_method_shape_owner_get_shape>`
Devuelve la :ref:`Shape2D<class_Shape2D>` con el ID dado del propietario de la forma especificado.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_method_shape_owner_get_shape_count:
.. rst-class:: classref-method
:ref:`int<class_int>` **shape_owner_get_shape_count**\ (\ owner_id\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_CollisionObject2D_method_shape_owner_get_shape_count>`
Devuelve el número de formas que contiene el propietario de la forma dada.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_method_shape_owner_get_shape_index:
.. rst-class:: classref-method
:ref:`int<class_int>` **shape_owner_get_shape_index**\ (\ owner_id\: :ref:`int<class_int>`, shape_id\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_CollisionObject2D_method_shape_owner_get_shape_index>`
Devuelve el índice hijo de la :ref:`Shape2D<class_Shape2D>` con el ID dado del propietario de la forma especificado.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_method_shape_owner_get_transform:
.. rst-class:: classref-method
:ref:`Transform2D<class_Transform2D>` **shape_owner_get_transform**\ (\ owner_id\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_CollisionObject2D_method_shape_owner_get_transform>`
Devuelve la forma del dueño :ref:`Transform2D<class_Transform2D>`.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_method_shape_owner_remove_shape:
.. rst-class:: classref-method
|void| **shape_owner_remove_shape**\ (\ owner_id\: :ref:`int<class_int>`, shape_id\: :ref:`int<class_int>`\ ) :ref:`🔗<class_CollisionObject2D_method_shape_owner_remove_shape>`
Quita una forma del dueño de la forma dada.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_method_shape_owner_set_disabled:
.. rst-class:: classref-method
|void| **shape_owner_set_disabled**\ (\ owner_id\: :ref:`int<class_int>`, disabled\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_CollisionObject2D_method_shape_owner_set_disabled>`
Si es ``true``, deshabilita al dueño de la forma dada.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_method_shape_owner_set_one_way_collision:
.. rst-class:: classref-method
|void| **shape_owner_set_one_way_collision**\ (\ owner_id\: :ref:`int<class_int>`, enable\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_CollisionObject2D_method_shape_owner_set_one_way_collision>`
Si ``enable`` es ``true``, las colisiones para el propietario de la forma que se originen en este **CollisionObject2D** no se reportarán a los **CollisionObject2D** con los que colisione.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_method_shape_owner_set_one_way_collision_margin:
.. rst-class:: classref-method
|void| **shape_owner_set_one_way_collision_margin**\ (\ owner_id\: :ref:`int<class_int>`, margin\: :ref:`float<class_float>`\ ) :ref:`🔗<class_CollisionObject2D_method_shape_owner_set_one_way_collision_margin>`
Establece el ``one_way_collision_margin`` del propietario de la forma identificado por el ``owner_id`` dado a ``margin`` píxeles.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_method_shape_owner_set_transform:
.. rst-class:: classref-method
|void| **shape_owner_set_transform**\ (\ owner_id\: :ref:`int<class_int>`, transform\: :ref:`Transform2D<class_Transform2D>`\ ) :ref:`🔗<class_CollisionObject2D_method_shape_owner_set_transform>`
Establece la :ref:`Transform2D<class_Transform2D>` del propietario de la forma dada.
.. |virtual| replace:: :abbr:`virtual (Normalmente, este método debería ser sobreescrito por el usuario para que tenga algún efecto.)`
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
.. |const| replace:: :abbr:`const (Este método no tiene efectos secundarios. No modifica ninguna de las variables miembro de la instancia.)`
.. |vararg| replace:: :abbr:`vararg (Este método permite agregar cualquier número de argumentos después de los descritos aquí.)`
.. |constructor| replace:: :abbr:`constructor (Este método se utiliza para construir un tipo.)`
.. |static| replace:: :abbr:`static (Este método no necesita una instancia para ser llamado, por lo que puede llamarse directamente utilizando el nombre de la clase.)`
.. |operator| replace:: :abbr:`operator (Este método describe un operador válido para usar con este tipo como operando izquierdo.)`
.. |bitfield| replace:: :abbr:`BitField (Este valor es un entero compuesto como una máscara de bits de las siguientes banderas.)`
.. |void| replace:: :abbr:`void (Sin valor de retorno.)`
Reference in New Issue View Git Blame Copy Permalink