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/fr/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

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

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_CollisionObject2D:
CollisionObject2D
=================
**Hérite de :** :ref:`Node2D<class_Node2D>` **<** :ref:`CanvasItem<class_CanvasItem>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
**Hérité par :** :ref:`Area2D<class_Area2D>`, :ref:`PhysicsBody2D<class_PhysicsBody2D>`
Classe de base abstraite pour les objets physiques 2D.
.. rst-class:: classref-introduction-group
Description
-----------
Classe de base abstraite pour les objets physiques 2D. **CollisionObject2D** peut contenir n'importe quel nombre de :ref:`Shape2D<class_Shape2D>` pour les collisions. Chaque forme doit être attribuée à un *propriétaire de forme*. Les propriétaires de forme ne sont pas des nœuds et ne figurent pas dans l'éditeur, mais sont accessibles via le code en utilisant les méthodes ``shape_owner_*``.
\ **Note :** Seules les collisions entre des objets dans le même caneveas (:ref:`Viewport<class_Viewport>` ou :ref:`CanvasLayer<class_CanvasLayer>`) sont supportées. Le comportement des collisions entre des objets dans différents canevas est indéfini.
.. rst-class:: classref-reftable-group
Propriétés
--------------------
.. 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éthodes
----------------
.. 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
Signaux
--------------
.. _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>`
Émis lorsqu'un événement d'entrée se produit. Nécessite :ref:`input_pickable<class_CollisionObject2D_property_input_pickable>` de valoir ``true`` et au moins un des bits de :ref:`collision_layer<class_CollisionObject2D_property_collision_layer>` d'être défini. Voir :ref:`_input_event()<class_CollisionObject2D_private_method__input_event>` pour plus de détails.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_signal_mouse_entered:
.. rst-class:: classref-signal
**mouse_entered**\ (\ ) :ref:`🔗<class_CollisionObject2D_signal_mouse_entered>`
Émis lorsque le pointeur de la souris entre dans l'une des formes de cet objet. Nécessite que :ref:`input_pickable<class_CollisionObject2D_property_input_pickable>` vaille ``true`` et au moins un bit de :ref:`collision_layer<class_CollisionObject2D_property_collision_layer>` de défini. Notez que le déplacement entre différentes formes dans un seul **CollisionObject2D** ne fera pas émettre ce signal.
\ **Note :** En raison du manque de détection de collision continue, ce signal peut ne pas être émis dans l'ordre prévu si la souris se déplace assez rapidement et que la zone du **CollisionObject2D** est petite. Ce signal peut aussi ne pas être émis si un autre **CollisionObject2D** recouvre le **CollisionObject2D** en question.
.. rst-class:: classref-item-separator
----
.. _class_CollisionObject2D_signal_mouse_exited:
.. rst-class:: classref-signal
**mouse_exited**\ (\ ) :ref:`🔗<class_CollisionObject2D_signal_mouse_exited>`
Émis lorsque le pointeur de la souris sort de toutes les formes de cet objet. Nécessite que :ref:`input_pickable<class_CollisionObject2D_property_input_pickable>` vaille ``true`` et au moins qu'un bit de :ref:`collision_layer<class_CollisionObject2D_property_collision_layer>` soit défini. Notez que se déplacer entre deux formes différentes dans un unique **CollisionObject2D** ne causera pas à ce signal d'être émis.
\ **Note :** En raison de l'absence de détection de collision continue, ce signal peut ne pas être émis dans l'ordre prévu si la souris se déplace assez vite et que la zone du **CollisionObject2D** est petite. Ce signal peut aussi ne pas être émis si un autre **CollisionObject2D** chevauche le **CollisionObject2D** en question.
.. 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>`
Émis lorsque le curseur de la souris entre dans l'une des formes de cet objet ou se déplace d'une forme à l'autre. ``shape_idx`` est l'index d'enfant de la :ref:`Shape2D<class_Shape2D>` nouvellement entrée. Nécessite que :ref:`input_pickable<class_CollisionObject2D_property_input_pickable>` vaille ``true`` et au moins un des bits de :ref:`collision_layer<class_CollisionObject2D_property_collision_layer>` d'être défini.
.. 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>`
Émis lorsque le curseur de la souris entre dans l'une des formes de l'objet. ``shape_idx`` est l'index de l'enfant du :ref:`Shape2D<class_Shape2D>` sorti. Nécessite que :ref:`input_pickable<class_CollisionObject2D_property_input_pickable>` vaille ``true`` et au moins un des bits de :ref:`collision_layer<class_CollisionObject2D_property_collision_layer>` d'être défini.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Énumérations
------------------------
.. _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``
Quand :ref:`Node.process_mode<class_Node_property_process_mode>` est défini à :ref:`Node.PROCESS_MODE_DISABLED<class_Node_constant_PROCESS_MODE_DISABLED>`, le retirer de la simulation physique pour arrêter toutes les interactions physiques avec ce **CollisionObject2D**.
Ré-ajouté automatiquement à la simulation physique lorsque le :ref:`Node<class_Node>` est de nouveau traité.
.. _class_CollisionObject2D_constant_DISABLE_MODE_MAKE_STATIC:
.. rst-class:: classref-enumeration-constant
:ref:`DisableMode<enum_CollisionObject2D_DisableMode>` **DISABLE_MODE_MAKE_STATIC** = ``1``
Quand :ref:`Node.process_mode<class_Node_property_process_mode>` est défini à :ref:`Node.PROCESS_MODE_DISABLED<class_Node_constant_PROCESS_MODE_DISABLED>`, rend le corps statique. N'affecte pas les :ref:`Area2D<class_Area2D>`. Les :ref:`PhysicsBody2D<class_PhysicsBody2D>` ne peuvent être affectés par des forces ou d'autres corps lorsqu'ils sont statiques.
Rend automatiquement au :ref:`PhysicsBody2D<class_PhysicsBody2D>` son mode original lorsque le :ref:`Node<class_Node>` est de nouveau traité.
.. _class_CollisionObject2D_constant_DISABLE_MODE_KEEP_ACTIVE:
.. rst-class:: classref-enumeration-constant
:ref:`DisableMode<enum_CollisionObject2D_DisableMode>` **DISABLE_MODE_KEEP_ACTIVE** = ``2``
Quand :ref:`Node.process_mode<class_Node_property_process_mode>` est défini à :ref:`Node.PROCESS_MODE_DISABLED<class_Node_constant_PROCESS_MODE_DISABLED>`, ne pas affecter la simulation physique.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descriptions des propriétés
------------------------------------------------------
.. _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**\ (\ )
La couche physique où est ce CollisionObject2D. Les objets de collision peuvent exister dans un ou plusieurs des 32 couches différentes. Voir aussi :ref:`collision_mask<class_CollisionObject2D_property_collision_mask>`.
\ **Note :** Un objet A peut détecter un contact avec l'objet B seulement si l'objet B est dans l'une des couches que l'objet A scanne. Voir `Niveaux et masques de collisions <../tutorials/physics/physics_introduction.html#collision-layers-and-masks>`__ dans la documentation pour plus d'informations.
.. 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**\ (\ )
La couche physique que ce CollisionObject2D scanne. Les objets de collision peuvent exister dans une ou plusieurs des 32 couches différentes. Voir aussi :ref:`collision_mask<class_CollisionObject2D_property_collision_mask>`.
\ **Note :** Un objet A peut détecter un contact avec l'objet B seulement si l'objet B est dans l'une des couches que l'objet A scanne. Voir `Niveaux et masques de collisions <../tutorials/physics/physics_introduction.html#collision-layers-and-masks>`__ dans la documentation pour plus d'informations.
.. 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 priorité utilisée pour résoudre la collision lors de la pénétration. Plus la priorité est élevée, plus la pénétration dans l'objet sera faible. Cela peut par exemple être utilisé pour empêcher le joueur de franchir les limites d'un niveau.
.. 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**\ (\ )
Définit le comportement physique lorsque :ref:`Node.process_mode<class_Node_property_process_mode>` est défini à :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 ``true``, cet objet peut être sélectionné. Ces objets peuvent détecter l'entrée/la sortie du pointeur de la souris sur eux, et si la souris pointe sur l'objet, signaler par des événements d'entrée. Nécessite au moins un bit de :ref:`collision_layer<class_CollisionObject2D_property_collision_layer>` d'être réglé.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descriptions des méthodes
--------------------------------------------------
.. _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>`
Accepte les :ref:`InputEvent<class_InputEvent>`\ s non gérés. ``shape_idx`` est l'index de l'enfant du :ref:`Shape2D<class_Shape2D>` cliqué. Connectez-vous à :ref:`input_event<class_CollisionObject2D_signal_input_event>` pour récupérer facilement ces événements.
\ **Note :** :ref:`_input_event()<class_CollisionObject2D_private_method__input_event>` nécessite :ref:`input_pickable<class_CollisionObject2D_property_input_pickable>` de valoir ``true`` et au moins un bit de :ref:`collision_layer<class_CollisionObject2D_property_collision_layer>` d'être défini.
.. 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>`
Appelée lorsque le pointeur de la souris entre dans l'une des formes de cet objet. Nécessite :ref:`input_pickable<class_CollisionObject2D_property_input_pickable>` de valoir ``true`` et au moins un bit de :ref:`collision_layer<class_CollisionObject2D_property_collision_layer>` de défini. Notez que le déplacement entre différentes formes dans un seul **CollisionObject2D** ne causera pas l'appel de cette fonction.
.. 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>`
Appelée quand le pointeur de la souris sort toutes les formes de cet objet. Nécessite :ref:`input_pickable<class_CollisionObject2D_property_input_pickable>` de valoir ``true`` et au moins un bit de :ref:`collision_layer<class_CollisionObject2D_property_collision_layer>` de defini. Notez que le déplacement entre différentes formes dans un seul **CollisionObject2D** ne causera pas l'appel de cette fonction.
.. 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>`
Appelée lorsque le pointeur de la souris entre dans l'une des formes de cet objet ou se déplace d'une forme à une autre. ``shape_idx`` est l'index de l'enfant de la :ref:`Shape2D<class_Shape2D>` nouvellement entrée. Nécessite :ref:`input_pickable<class_CollisionObject2D_property_input_pickable>` de valoir ``true`` et au moins un bit de :ref:`collision_layer<class_CollisionObject2D_property_collision_layer>` d'être défini.
.. 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>`
Appelée quand le pointeur de la souris sort de l'une des formes de cet objet. ``shape_idx`` est l'index de l'enfant du :ref:`Shape2D<class_Shape2D>` sorti. Nécessite :ref:`input_pickable<class_CollisionObject2D_property_input_pickable>` de valoir ``true`` et au moins un bit de :ref:`collision_layer<class_CollisionObject2D_property_collision_layer>` d'être défini.
.. 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>`
Crée un nouveau propriétaire de forme pour l'objet donné. Renvoie l’\ ``owner_id`` du nouveau propriétaire pour une prochaine référence.
.. 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>`
Renvoie si la couche spécifiée du :ref:`collision_layer<class_CollisionObject2D_property_collision_layer>` est activée, étant donné un numéro de couche ``layer_number`` entre 1 et 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>`
Renvoie si la couche spécifiée du :ref:`collision_mask<class_CollisionObject2D_property_collision_mask>` est activée, étant donné un numéro de couche ``layer_number`` entre 1 et 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>`
Renvoie le :ref:`RID<class_RID>` de l'objet.
.. 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>`
Renvoie la ``one_way_collision_margin`` du propriétaire de la forme identifié par le ``owner_id`` donné.
.. 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>`
Renvoie un :ref:`Array<class_Array>` d'identifiants ``owner_id``. Vous pouvez utiliser ces identifiants dans les méthodes prenant ``owner_id`` comme argument.
.. 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 ``true``, le propriétaire de forme et ses formes sont désactivés.
.. 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>`
Renvoie ``true`` si les collisions pour le propriétaire de forme venant de ce **CollisionObject2D** ne seront pas signalées aux **CollisionObject2D** entrants en collision.
.. 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>`
Supprime le propriétaire de forme donné.
.. 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>`
Selon ``value``, active ou désactive la couche spécifiée dans le :ref:`collision_layer<class_CollisionObject2D_property_collision_layer>`, étant donné un numéro de couche ``layer_number`` entre 1 et 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>`
Selon ``value``, active ou désactive la couche spécifiée dans le :ref:`collision_mask<class_CollisionObject2D_property_collision_mask>`, étant donné un numéro de couche ``layer_number`` entre 1 et 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>`
Renvoie le ``owner_id`` de la forme spécifiée.
.. 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>`
Ajoute un :ref:`Shape2D<class_Shape2D>` au propriétaire de forme.
.. 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>`
Enlève toutes les formes au propriétaire de forme.
.. 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>`
Renvoie l'objet parent du propriétaire de forme spécifié.
.. 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>`
Renvoie la :ref:`Shape2D<class_Shape2D>` avec l'identifiant donné du propriétaire de forme donné.
.. 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>`
Renvoie le nombre de formes que le propriétaire de forme contient.
.. 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>`
Renvoie l'index de l'enfant de la :ref:`Shape2D<class_Shape2D>` avec l'identifiant donné du propriétaire de forme donné.
.. 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>`
Renvoie le :ref:`Transform2D<class_Transform2D>` du propriétaire de la forme.
.. 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>`
Retire la forme du propriétaire de forme donné.
.. 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 ``true``, désactive le propriétaire spécifié de la forme.
.. 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`` vaut ``true``, les collisions pour le propriétaire de forme originant de ce **CollisionObject2D** ne seront pas rapportées aux **CollisionObject2D** entrant en collision.
.. 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>`
Définit la marge ``one_way_collision_margin`` du propriétaire de la forme identifié par le ``owner_id`` donné à ``margin`` pixels.
.. 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>`
Définit la :ref:`Transform2D<class_Transform2D>` du propriétaire de forme spécifié.
.. |virtual| replace:: :abbr:`virtual (Cette méthode doit typiquement être redéfinie par l'utilisateur pour avoir un effet.)`
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
.. |const| replace:: :abbr:`const (Cette méthode n'a pas d'effets de bord. Elle ne modifie aucune des variables membres de l'instance.)`
.. |vararg| replace:: :abbr:`vararg (Cette méthode accepte n'importe quel nombre d'arguments après ceux décris ici.)`
.. |constructor| replace:: :abbr:`constructor (Cette méthode est utilisée pour construire un type.)`
.. |static| replace:: :abbr:`static (Cette méthode n'a pas besoin d'instance pour être appelée, elle peut donc être directement appelée en utilisant le nom de la classe.)`
.. |operator| replace:: :abbr:`operator (Cette méthode décrit un opérateur valide à utiliser avec ce type en tant qu'opérande gauche.)`
.. |bitfield| replace:: :abbr:`BitField (Cette valeur est un nombre entier composé d'un masque de bits des options suivantes.)`
.. |void| replace:: :abbr:`void (Aucune valeur de retour.)`
Reference in New Issue View Git Blame Copy Permalink