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_packedvector2array.rst
Rémi Verschelde c3f2364c10 Sync classref with 4.6 branch 
Lots of translations invalidated (fuzzied) as we just synced Weblate.
2025-12-19 16:39:51 +01:00

550 lines
33 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.

:github_url: hide
.. _class_PackedVector2Array:
PackedVector2Array
==================
Un tableau compacté de :ref:`Vector2<class_Vector2>`\ s.
.. rst-class:: classref-introduction-group
Description
-----------
Un tableau spécialement conçu pour contenir des :ref:`Vector2<class_Vector2>`. Compacte les données de manière serrée, il sauve de la mémoire pour les grandes tailles de tableaux.
\ **Différences entre les tableaux compactés, les tableaux typés et les tableaux non typés :** Les tableaux compactés sont généralement plus rapides pour itérer et modifier par rapport à un tableau typé du même type (par exemple **PackedVector2Array** contre ``Array[Vector2]``). De plus, les tableaux compactés consomment moins de mémoire. À l'inverse, les tableaux compactés sont moins flexibles car ils ne proposent pas autant de méthodes de commodité comme :ref:`Array.map()<class_Array_method_map>`. Les tableaux typés sont à leur tour plus rapides pour itérer dessus et modifier que les tableaux non typés.
\ **Note :** Les tableaux compactés sont toujours passés par référence. Pour obtenir une copie d'un tableau qui peut être modifié indépendamment du tableau original, utilisez :ref:`duplicate()<class_PackedVector2Array_method_duplicate>`. Ceci n'est *pas* le cas pour les propriétés et les méthodes intégrées. Le tableau compacté renvoyé de ceux-ci est une copie, et le changer n'affectera *pas* la valeur originale. Pour mettre à jour une propriété intégrée, vous devez modifier le tableau renvoyé, puis l'affecter à nouveau à la propriété.
.. note::
Il y a des différences notables dans l'utilisation de cette API en C#. Voir :ref:`doc_c_sharp_differences` pour plus d'informations.
.. rst-class:: classref-introduction-group
Tutoriels
------------------
- `Démo de navigation sur une grille avec AStarGrid2D <https://godotengine.org/asset-library/asset/2723>`__
.. rst-class:: classref-reftable-group
Constructeurs
--------------------------
.. table::
:widths: auto
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedVector2Array<class_PackedVector2Array>` | :ref:`PackedVector2Array<class_PackedVector2Array_constructor_PackedVector2Array>`\ (\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedVector2Array<class_PackedVector2Array>` | :ref:`PackedVector2Array<class_PackedVector2Array_constructor_PackedVector2Array>`\ (\ from\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedVector2Array<class_PackedVector2Array>` | :ref:`PackedVector2Array<class_PackedVector2Array_constructor_PackedVector2Array>`\ (\ from\: :ref:`Array<class_Array>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-reftable-group
Méthodes
----------------
.. table::
:widths: auto
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`append<class_PackedVector2Array_method_append>`\ (\ value\: :ref:`Vector2<class_Vector2>`\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`append_array<class_PackedVector2Array_method_append_array>`\ (\ array\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`bsearch<class_PackedVector2Array_method_bsearch>`\ (\ value\: :ref:`Vector2<class_Vector2>`, before\: :ref:`bool<class_bool>` = true\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`clear<class_PackedVector2Array_method_clear>`\ (\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`count<class_PackedVector2Array_method_count>`\ (\ value\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedVector2Array<class_PackedVector2Array>` | :ref:`duplicate<class_PackedVector2Array_method_duplicate>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`erase<class_PackedVector2Array_method_erase>`\ (\ value\: :ref:`Vector2<class_Vector2>`\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`fill<class_PackedVector2Array_method_fill>`\ (\ value\: :ref:`Vector2<class_Vector2>`\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`find<class_PackedVector2Array_method_find>`\ (\ value\: :ref:`Vector2<class_Vector2>`, from\: :ref:`int<class_int>` = 0\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`get<class_PackedVector2Array_method_get>`\ (\ index\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`has<class_PackedVector2Array_method_has>`\ (\ value\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`insert<class_PackedVector2Array_method_insert>`\ (\ at_index\: :ref:`int<class_int>`, value\: :ref:`Vector2<class_Vector2>`\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_empty<class_PackedVector2Array_method_is_empty>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`push_back<class_PackedVector2Array_method_push_back>`\ (\ value\: :ref:`Vector2<class_Vector2>`\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`remove_at<class_PackedVector2Array_method_remove_at>`\ (\ index\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`resize<class_PackedVector2Array_method_resize>`\ (\ new_size\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`reverse<class_PackedVector2Array_method_reverse>`\ (\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`rfind<class_PackedVector2Array_method_rfind>`\ (\ value\: :ref:`Vector2<class_Vector2>`, from\: :ref:`int<class_int>` = -1\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set<class_PackedVector2Array_method_set>`\ (\ index\: :ref:`int<class_int>`, value\: :ref:`Vector2<class_Vector2>`\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`size<class_PackedVector2Array_method_size>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedVector2Array<class_PackedVector2Array>` | :ref:`slice<class_PackedVector2Array_method_slice>`\ (\ begin\: :ref:`int<class_int>`, end\: :ref:`int<class_int>` = 2147483647\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`sort<class_PackedVector2Array_method_sort>`\ (\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`to_byte_array<class_PackedVector2Array_method_to_byte_array>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-reftable-group
Opérateurs
--------------------
.. table::
:widths: auto
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator !=<class_PackedVector2Array_operator_neq_PackedVector2Array>`\ (\ right\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedVector2Array<class_PackedVector2Array>` | :ref:`operator *<class_PackedVector2Array_operator_mul_Transform2D>`\ (\ right\: :ref:`Transform2D<class_Transform2D>`\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedVector2Array<class_PackedVector2Array>` | :ref:`operator +<class_PackedVector2Array_operator_sum_PackedVector2Array>`\ (\ right\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator ==<class_PackedVector2Array_operator_eq_PackedVector2Array>`\ (\ right\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`operator []<class_PackedVector2Array_operator_idx_int>`\ (\ index\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descriptions des constructeurs
------------------------------------------------------------
.. _class_PackedVector2Array_constructor_PackedVector2Array:
.. rst-class:: classref-constructor
:ref:`PackedVector2Array<class_PackedVector2Array>` **PackedVector2Array**\ (\ ) :ref:`🔗<class_PackedVector2Array_constructor_PackedVector2Array>`
Construit un **PackedVector2Array** vide.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`PackedVector2Array<class_PackedVector2Array>` **PackedVector2Array**\ (\ from\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ )
Construit un **PackedVector2Array** en copie du **PackedVector2Array** donné.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`PackedVector2Array<class_PackedVector2Array>` **PackedVector2Array**\ (\ from\: :ref:`Array<class_Array>`\ )
Construit un nouveau **PackedVector2Array**. Optionnellement, vous pouvez passer un tableau :ref:`Array<class_Array>` générique qui sera converti.
\ **Note :** Lors de l'initialisation d'un **PackedVector2Array** avec des éléments, il doit être initialisé avec un :ref:`Array<class_Array>` de valeurs de :ref:`Vector2<class_Vector2>`\  :
::
var tableau = PackedVector2Array([Vector2(12, 34), Vector2(56, 78)])
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descriptions des méthodes
--------------------------------------------------
.. _class_PackedVector2Array_method_append:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **append**\ (\ value\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_PackedVector2Array_method_append>`
Ajoute un élément à la fin du tableau (c'est un raccourci vers :ref:`push_back()<class_PackedVector2Array_method_push_back>`).
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_append_array:
.. rst-class:: classref-method
|void| **append_array**\ (\ array\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) :ref:`🔗<class_PackedVector2Array_method_append_array>`
Ajoute un **PackedVector2Array** à la fin de ce tableau.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_bsearch:
.. rst-class:: classref-method
:ref:`int<class_int>` **bsearch**\ (\ value\: :ref:`Vector2<class_Vector2>`, before\: :ref:`bool<class_bool>` = true\ ) |const| :ref:`🔗<class_PackedVector2Array_method_bsearch>`
Cherche l'index d'une valeur existante (ou l'index d'insertion qui maintient l'ordre de tri, si la valeur n'est pas encore présente dans le tableau) en utilisant la recherche binaire. Optionnellement, un spécificateur ``before`` peut être passé. Si ``false``, l'index renvoyé vient après toutes les entrées existantes de la valeur dans le tableau.
\ **Note :** Appeler :ref:`bsearch()<class_PackedVector2Array_method_bsearch>` sur un tableau non trié résulte en un comportement inattendu.
\ **Note :** Les vecteurs avec des éléments :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` ne se comportent pas comme les autres vecteurs. Par conséquent, les résultats de cette méthode peuvent ne pas être corrects si des NaNs sont inclus.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_clear:
.. rst-class:: classref-method
|void| **clear**\ (\ ) :ref:`🔗<class_PackedVector2Array_method_clear>`
Efface le contenu du tableau. C'est équivalent à :ref:`resize()<class_PackedVector2Array_method_resize>` avec une taille de ``0``.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_count:
.. rst-class:: classref-method
:ref:`int<class_int>` **count**\ (\ value\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_PackedVector2Array_method_count>`
Renvoie le nombre de fois qu'un élément apparaît dans le tableau.
\ **Note :** Les vecteurs avec des éléments :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` ne se comportent pas comme les autres vecteurs. Par conséquent, les résultats de cette méthode peuvent ne pas être corrects si des NaNs sont inclus.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_duplicate:
.. rst-class:: classref-method
:ref:`PackedVector2Array<class_PackedVector2Array>` **duplicate**\ (\ ) |const| :ref:`🔗<class_PackedVector2Array_method_duplicate>`
Crée une copie du tableau, et le renvoie.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_erase:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **erase**\ (\ value\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_PackedVector2Array_method_erase>`
Retire la première occurrence d'une valeur du tableau et renvoie ``true``. Si la valeur n'existe pas dans le tableau, rien ne se passe et ``false`` est renvoyé. Pour supprimer un élément par index, utilisez :ref:`remove_at()<class_PackedVector2Array_method_remove_at>` à la place.
\ **Note :** Les vecteurs avec des éléments :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` ne se comportent pas comme les autres vecteurs. Par conséquent, les résultats de cette méthode peuvent ne pas être corrects si des NaNs sont inclus.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_fill:
.. rst-class:: classref-method
|void| **fill**\ (\ value\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_PackedVector2Array_method_fill>`
Attribue la valeur donnée à tous les éléments du tableau. Cela peut généralement être utilisé avec :ref:`resize()<class_PackedVector2Array_method_resize>` pour créer un tableau avec une taille donnée et des éléments initialisés.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_find:
.. rst-class:: classref-method
:ref:`int<class_int>` **find**\ (\ value\: :ref:`Vector2<class_Vector2>`, from\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_PackedVector2Array_method_find>`
Cherche le tableau pour une valeur et renvoie son index ou ``-1`` si elle n'est pas trouvé. Optionnellement, l'index de recherche initial peut être passé.
\ **Note :** Les vecteurs avec des éléments :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` ne se comportent pas comme les autres vecteurs. Par conséquent, les résultats de cette méthode peuvent ne pas être corrects si des NaNs sont inclus.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_get:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **get**\ (\ index\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_PackedVector2Array_method_get>`
Returns the :ref:`Vector2<class_Vector2>` at the given ``index`` in the array. If ``index`` is out-of-bounds or negative, this method fails and returns ``Vector2(0, 0)``.
This method is similar (but not identical) to the ``[]`` operator. Most notably, when this method fails, it doesn't pause project execution if run from the editor.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_has:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **has**\ (\ value\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_PackedVector2Array_method_has>`
Renvoie ``true`` si le tableau contient la valeur ``value``.
\ **Note :** Les vecteurs avec des éléments :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` ne se comportent pas comme les autres vecteurs. Par conséquent, les résultats de cette méthode peuvent ne pas être corrects si des NaNs sont inclus.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_insert:
.. rst-class:: classref-method
:ref:`int<class_int>` **insert**\ (\ at_index\: :ref:`int<class_int>`, value\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_PackedVector2Array_method_insert>`
Insérer un nouvel élément à une position donnée dans le tableau. La position doit être valide, ou à la fin du tableau (``idx == size()``).
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_is_empty:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_empty**\ (\ ) |const| :ref:`🔗<class_PackedVector2Array_method_is_empty>`
Renvoie ``true`` si le tableau est vide.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_push_back:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **push_back**\ (\ value\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_PackedVector2Array_method_push_back>`
Insère un :ref:`Vector2<class_Vector2>` à la fin.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_remove_at:
.. rst-class:: classref-method
|void| **remove_at**\ (\ index\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedVector2Array_method_remove_at>`
Retire l'élément du tableau à l'index donné.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_resize:
.. rst-class:: classref-method
:ref:`int<class_int>` **resize**\ (\ new_size\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedVector2Array_method_resize>`
Définit la taille du tableau. Si le tableau est agrandi, réserve des éléments à la fin du tableau. Si le tableau est rétrécit, tronque le tableau à la nouvelle taille. Appeler :ref:`resize()<class_PackedVector2Array_method_resize>` une fois et attribuer les nouvelles valeurs est plus rapide que l'ajout de nouveaux éléments un par un.
Renvoie :ref:`@GlobalScope.OK<class_@GlobalScope_constant_OK>` sur le succès, ou une des constantes :ref:`Error<enum_@GlobalScope_Error>` suivantes si cette méthode échoue : :ref:`@GlobalScope.ERR_INVALID_PARAMETER<class_@GlobalScope_constant_ERR_INVALID_PARAMETER>` si la taille est négative, ou :ref:`@GlobalScope.ERR_OUT_OF_MEMORY<class_@GlobalScope_constant_ERR_OUT_OF_MEMORY>` si les allocations échouent. Utilisez :ref:`size()<class_PackedVector2Array_method_size>` pour trouver la taille réelle du tableau après le redimensionnement.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_reverse:
.. rst-class:: classref-method
|void| **reverse**\ (\ ) :ref:`🔗<class_PackedVector2Array_method_reverse>`
Inverse l'ordre des éléments du tableau.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_rfind:
.. rst-class:: classref-method
:ref:`int<class_int>` **rfind**\ (\ value\: :ref:`Vector2<class_Vector2>`, from\: :ref:`int<class_int>` = -1\ ) |const| :ref:`🔗<class_PackedVector2Array_method_rfind>`
Cherche le tableau en sens inverse. Optionnellement, un index de recherche initial peut être passé. Si négatif, l'indice initial est considéré comme relatif par rapport à la fin du tableau.
\ **Note :** Les vecteurs avec des éléments :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` ne se comportent pas comme les autres vecteurs. Par conséquent, les résultats de cette méthode peuvent ne pas être corrects si des NaNs sont inclus.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_set:
.. rst-class:: classref-method
|void| **set**\ (\ index\: :ref:`int<class_int>`, value\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_PackedVector2Array_method_set>`
Change la :ref:`Vector2<class_Vector2>` à la position donnée.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_size:
.. rst-class:: classref-method
:ref:`int<class_int>` **size**\ (\ ) |const| :ref:`🔗<class_PackedVector2Array_method_size>`
Renvoie le nombre d'éléments dans le tableau.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_slice:
.. rst-class:: classref-method
:ref:`PackedVector2Array<class_PackedVector2Array>` **slice**\ (\ begin\: :ref:`int<class_int>`, end\: :ref:`int<class_int>` = 2147483647\ ) |const| :ref:`🔗<class_PackedVector2Array_method_slice>`
Renvoie la tranche du **PackedVector2Array**, de ``begin`` (inclusive) à ``end`` (exclusive), en tant que nouveau **PackedVector2Array**.
La valeur absolue de ``begin`` et ``end`` sera bornée à la taille du tableau, de sorte que la valeur par défaut pour ``end`` le fait trancher à la taille du tableau par défaut (c.a.d. ``arr.slice(1)`` est un raccourci pour ``arr.slice(1, arr.size())``).
Si ``begin`` ou ``end`` sont négatifs, ils seront par rapport à la fin du tableau (c.a.d. ``arr.slice(0, -2)`` est un raccourci pour ``arr.slice(0, arr.size() - 2)``).
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_sort:
.. rst-class:: classref-method
|void| **sort**\ (\ ) :ref:`🔗<class_PackedVector2Array_method_sort>`
Trie les éléments du tableau dans l'ordre ascendant.
\ **Note :** Les vecteurs avec des éléments :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` ne se comportent pas comme les autres vecteurs. Par conséquent, les résultats de cette méthode peuvent ne pas être corrects si des NaNs sont inclus.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_to_byte_array:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **to_byte_array**\ (\ ) |const| :ref:`🔗<class_PackedVector2Array_method_to_byte_array>`
Renvoie un :ref:`PackedByteArray<class_PackedByteArray>` avec chaque vecteur encodé en octets.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descriptions des opérateurs
------------------------------------------------------
.. _class_PackedVector2Array_operator_neq_PackedVector2Array:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator !=**\ (\ right\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) :ref:`🔗<class_PackedVector2Array_operator_neq_PackedVector2Array>`
Renvoie ``true`` si le contenu des tableaux diffère.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_operator_mul_Transform2D:
.. rst-class:: classref-operator
:ref:`PackedVector2Array<class_PackedVector2Array>` **operator ***\ (\ right\: :ref:`Transform2D<class_Transform2D>`\ ) :ref:`🔗<class_PackedVector2Array_operator_mul_Transform2D>`
Renvoie un nouveau **PackedVector2Array** avec tous les vecteurs de ce tableau transformés (multipliés) de manière inverse par la matrice de transformation :ref:`Transform2D<class_Transform2D>` donnée, avec la supposition que la base de la transformation est orthonormée (c.a.d. une rotation/réflexion est OK, une échelle/un cisaillement ne l'est pas).
\ ``array * transform`` est équivalent à ``transform.inverse() * array``. Voir :ref:`Transform2D.inverse()<class_Transform2D_method_inverse>`.
Pour transformer par l'inverse d'une transformation affine (par ex. avec une mise à l'échelle), ``transform.affine_inverse() * array`` peut être utilisé à la place. Voir :ref:`Transform2D.affine_inverse()<class_Transform2D_method_affine_inverse>`.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_operator_sum_PackedVector2Array:
.. rst-class:: classref-operator
:ref:`PackedVector2Array<class_PackedVector2Array>` **operator +**\ (\ right\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) :ref:`🔗<class_PackedVector2Array_operator_sum_PackedVector2Array>`
Renvoie un nouveau **PackedVector2Array** avec le contenu de ``right`` ajouté à la fin de ce tableau. Pour de meilleurs performances, envisagez d'utiliser :ref:`append_array()<class_PackedVector2Array_method_append_array>` à la place.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_operator_eq_PackedVector2Array:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator ==**\ (\ right\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) :ref:`🔗<class_PackedVector2Array_operator_eq_PackedVector2Array>`
Renvoie ``true`` si le contenu des deux tableaux est le même, c'est-à-dire qu'ils ont tous leurs :ref:`Vector2<class_Vector2>` égaux aux indices correspondants.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_operator_idx_int:
.. rst-class:: classref-operator
:ref:`Vector2<class_Vector2>` **operator []**\ (\ index\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedVector2Array_operator_idx_int>`
Renvoie le :ref:`Vector2<class_Vector2>` à la position ``index``. Les indices négatifs peuvent être utilisés pour accéder aux éléments à partir de la fin. L'utilisation d'un index hors des limites du tableau entraînera une erreur.
.. |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