:github_url: hide .. _class_PackedVector2Array: PackedVector2Array ================== Пакетний масив :ref:`Vector2`\ s. .. rst-class:: classref-introduction-group Опис -------- Масив, спеціально розроблений для зберігання :ref:`Vector2`. Щільно упаковує дані, що економить пам'ять для масивів великого розміру. \ **Відмінності між упакованими масивами, типізованими масивами та нетипізованими масивами:** Упаковані масиви, як правило, швидше перебираються та модифікуються порівняно з типізованим масивом того ж типу (наприклад, **PackedVector2Array** проти ``Array[Vector2]``). Крім того, упаковані масиви споживають менше пам'яті. Недоліком є те, що упаковані масиви менш гнучкі, оскільки вони не пропонують стільки зручних методів, як :ref:`Array.map()`. Типізовані масиви, у свою чергу, швидше перебираються та модифікуються, ніж нетипізовані масиви. \ **Примітка:** Упаковані масиви завжди передаються за посиланням. Щоб отримати копію масиву, яку можна модифікувати незалежно від оригінального масиву, використовуйте :ref:`duplicate()`. Це *не* стосується вбудованих властивостей та методів. У цих випадках повернутий упакований масив є копією, і його зміна *не* вплине на початкове значення. Щоб оновити вбудовану властивість цього типу, змініть повернутий масив, а потім знову призначте його властивості. .. note:: Існують значні відмінності при використанні цього API із С#. Більше інформації: ref:`doc_c_sharp_differences`. .. rst-class:: classref-introduction-group Посібники ------------------ - `Навігація на основі сітки з AStarGrid2D Демонстрація `__ .. rst-class:: classref-reftable-group Конструктори ------------------------ .. table:: :widths: auto +-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedVector2Array` | :ref:`PackedVector2Array`\ (\ ) | +-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedVector2Array` | :ref:`PackedVector2Array`\ (\ from\: :ref:`PackedVector2Array`\ ) | +-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedVector2Array` | :ref:`PackedVector2Array`\ (\ from\: :ref:`Array`\ ) | +-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+ .. rst-class:: classref-reftable-group Методи ------------ .. table:: :widths: auto +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`append`\ (\ value\: :ref:`Vector2`\ ) | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`append_array`\ (\ array\: :ref:`PackedVector2Array`\ ) | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`bsearch`\ (\ value\: :ref:`Vector2`, before\: :ref:`bool` = true\ ) |const| | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`clear`\ (\ ) | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`count`\ (\ value\: :ref:`Vector2`\ ) |const| | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedVector2Array` | :ref:`duplicate`\ (\ ) |const| | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`erase`\ (\ value\: :ref:`Vector2`\ ) | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`fill`\ (\ value\: :ref:`Vector2`\ ) | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`find`\ (\ value\: :ref:`Vector2`, from\: :ref:`int` = 0\ ) |const| | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Vector2` | :ref:`get`\ (\ index\: :ref:`int`\ ) |const| | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`has`\ (\ value\: :ref:`Vector2`\ ) |const| | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`insert`\ (\ at_index\: :ref:`int`, value\: :ref:`Vector2`\ ) | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`is_empty`\ (\ ) |const| | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`push_back`\ (\ value\: :ref:`Vector2`\ ) | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`remove_at`\ (\ index\: :ref:`int`\ ) | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`resize`\ (\ new_size\: :ref:`int`\ ) | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`reverse`\ (\ ) | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`rfind`\ (\ value\: :ref:`Vector2`, from\: :ref:`int` = -1\ ) |const| | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`set`\ (\ index\: :ref:`int`, value\: :ref:`Vector2`\ ) | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`size`\ (\ ) |const| | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedVector2Array` | :ref:`slice`\ (\ begin\: :ref:`int`, end\: :ref:`int` = 2147483647\ ) |const| | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`sort`\ (\ ) | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedByteArray` | :ref:`to_byte_array`\ (\ ) |const| | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+ .. rst-class:: classref-reftable-group Оператори ------------------ .. table:: :widths: auto +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`operator !=`\ (\ right\: :ref:`PackedVector2Array`\ ) | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedVector2Array` | :ref:`operator *`\ (\ right\: :ref:`Transform2D`\ ) | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedVector2Array` | :ref:`operator +`\ (\ right\: :ref:`PackedVector2Array`\ ) | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`operator ==`\ (\ right\: :ref:`PackedVector2Array`\ ) | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Vector2` | :ref:`operator []`\ (\ index\: :ref:`int`\ ) | +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------+ .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Описи конструкторів -------------------------------------- .. _class_PackedVector2Array_constructor_PackedVector2Array: .. rst-class:: classref-constructor :ref:`PackedVector2Array` **PackedVector2Array**\ (\ ) :ref:`🔗` Будуємо порожній **PackedVector2Array**. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`PackedVector2Array` **PackedVector2Array**\ (\ from\: :ref:`PackedVector2Array`\ ) Constructs a **PackedVector2Array** як копія даної **PackedVector2Array**. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`PackedVector2Array` **PackedVector2Array**\ (\ from\: :ref:`Array`\ ) Створює новий **PackedVector2Array**. За бажанням, ви можете передати загальний :ref:`Array`, який буде конвертовано. \ **Примітка:** Під час ініціалізації **PackedVector2Array** елементами, його необхідно ініціалізувати значеннями :ref:`Array` з :ref:`Vector2`: :: var array = PackedVector2Array([Vector2(12, 34), Vector2(56, 78)]) .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Описи методів -------------------------- .. _class_PackedVector2Array_method_append: .. rst-class:: classref-method :ref:`bool` **append**\ (\ value\: :ref:`Vector2`\ ) :ref:`🔗` Додає елемент у кінець масиву (псевдонім :ref:`push_back()`). .. rst-class:: classref-item-separator ---- .. _class_PackedVector2Array_method_append_array: .. rst-class:: classref-method |void| **append_array**\ (\ array\: :ref:`PackedVector2Array`\ ) :ref:`🔗` Додаток **PackedVector2Array** в кінці цього масиву. .. rst-class:: classref-item-separator ---- .. _class_PackedVector2Array_method_bsearch: .. rst-class:: classref-method :ref:`int` **bsearch**\ (\ value\: :ref:`Vector2`, before\: :ref:`bool` = true\ ) |const| :ref:`🔗` Знаходить індекс існуючого значення (або індекс вставки, який підтримує порядок сортування, якщо значення ще не присутнє в масиві) за допомогою бінарного пошуку. За бажанням можна передати специфікатор ``before``. Якщо ``false``, індекс, що повертається, йде після всіх існуючих записів значення в масиві. \ **Примітка:** Виклик :ref:`bsearch()` на невідсортованому масиві призводить до неочікуваної поведінки. \ **Примітка:** Поведінка векторів з :ref:`@GDScript.NAN` відрізняється від інших. Через це результати цього методу можуть бути неточними за наявності NaN-ів. .. rst-class:: classref-item-separator ---- .. _class_PackedVector2Array_method_clear: .. rst-class:: classref-method |void| **clear**\ (\ ) :ref:`🔗` Очищає масив. Еквівалентно використанню :ref:`resize()` з розміром ``0``. .. rst-class:: classref-item-separator ---- .. _class_PackedVector2Array_method_count: .. rst-class:: classref-method :ref:`int` **count**\ (\ value\: :ref:`Vector2`\ ) |const| :ref:`🔗` Повертає кількість разів елемент знаходиться в масиві. \ **Примітка:** Поведінка векторів з :ref:`@GDScript.NAN` відрізняється від інших. Через це результати цього методу можуть бути неточними за наявності NaN-ів. .. rst-class:: classref-item-separator ---- .. _class_PackedVector2Array_method_duplicate: .. rst-class:: classref-method :ref:`PackedVector2Array` **duplicate**\ (\ ) |const| :ref:`🔗` Створює копію масиву і повертає його. .. rst-class:: classref-item-separator ---- .. _class_PackedVector2Array_method_erase: .. rst-class:: classref-method :ref:`bool` **erase**\ (\ value\: :ref:`Vector2`\ ) :ref:`🔗` Видаляє перше входження значення з масиву та повертає ``true``. Якщо значення не існує в масиві, нічого не відбувається, і повертається ``false``. Щоб видалити елемент за індексом, використовуйте метод ``remove_at``. \ **Примітка:** Вектори з елементами :ref:`@GDScript.NAN` поводяться інакше, ніж інші вектори. Тому результати цього методу можуть бути неточними, якщо включені NaN. .. rst-class:: classref-item-separator ---- .. _class_PackedVector2Array_method_fill: .. rst-class:: classref-method |void| **fill**\ (\ value\: :ref:`Vector2`\ ) :ref:`🔗` Присвоює задане значення всім елементам масиву. Зазвичай це можна використовувати разом з :ref:`resize()` для створення масиву заданого розміру та ініціалізованих елементів. .. rst-class:: classref-item-separator ---- .. _class_PackedVector2Array_method_find: .. rst-class:: classref-method :ref:`int` **find**\ (\ value\: :ref:`Vector2`, from\: :ref:`int` = 0\ ) |const| :ref:`🔗` Шукаж значення в масиві та повертає індекс або ``-1``, якщо не знайдено. Додатково може бути переданий початковий індекс пошуку. \ **Примітка:** Поведінка векторів з :ref:`@GDScript.NAN` відрізняється від інших. Через це результати цього методу можуть бути неточними за наявності NaN-ів. .. rst-class:: classref-item-separator ---- .. _class_PackedVector2Array_method_get: .. rst-class:: classref-method :ref:`Vector2` **get**\ (\ index\: :ref:`int`\ ) |const| :ref:`🔗` Returns the :ref:`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` **has**\ (\ value\: :ref:`Vector2`\ ) |const| :ref:`🔗` Повертає ``true``, якщо масив містить ``value``. \ **Примітка:** Вектори з елементами :ref:`@GDScript.NAN` не поводять себе так, як інші вектори. Через це результати цього методу можуть бути неточними за наявності NaN-ів. .. rst-class:: classref-item-separator ---- .. _class_PackedVector2Array_method_insert: .. rst-class:: classref-method :ref:`int` **insert**\ (\ at_index\: :ref:`int`, value\: :ref:`Vector2`\ ) :ref:`🔗` Вставте новий елемент на даній позиції в масиві. Посада повинна бути дійсна, або в кінці масиву (``idx == розмір()``). .. rst-class:: classref-item-separator ---- .. _class_PackedVector2Array_method_is_empty: .. rst-class:: classref-method :ref:`bool` **is_empty**\ (\ ) |const| :ref:`🔗` Повертає ``true``, якщо масив порожній. .. rst-class:: classref-item-separator ---- .. _class_PackedVector2Array_method_push_back: .. rst-class:: classref-method :ref:`bool` **push_back**\ (\ value\: :ref:`Vector2`\ ) :ref:`🔗` Вставте :ref:`Vector2` в кінці. .. rst-class:: classref-item-separator ---- .. _class_PackedVector2Array_method_remove_at: .. rst-class:: classref-method |void| **remove_at**\ (\ index\: :ref:`int`\ ) :ref:`🔗` Видаляє елемент з масиву за індексом. .. rst-class:: classref-item-separator ---- .. _class_PackedVector2Array_method_resize: .. rst-class:: classref-method :ref:`int` **resize**\ (\ new_size\: :ref:`int`\ ) :ref:`🔗` Встановлює розмір масиву. Якщо масив збільшується, резервує елементи в кінці масиву. Якщо масив скорочується, обрізає масив до нового розміру. Виклик методу :ref:`resize()` один раз і призначення нових значень відбувається швидше, ніж додавання нових елементів по одному. Повертає :ref:`@GlobalScope.OK` у разі успіху або одну з наступних констант :ref:`Error`, якщо цей метод не працює: :ref:`@GlobalScope.ERR_INVALID_PARAMETER`, якщо розмір від'ємний, або :ref:`@GlobalScope.ERR_OUT_OF_MEMORY`, якщо розподіл пам'яті не вдається. Використовуйте метод :ref:`size()`, щоб знайти фактичний розмір масиву після зміни розміру. .. rst-class:: classref-item-separator ---- .. _class_PackedVector2Array_method_reverse: .. rst-class:: classref-method |void| **reverse**\ (\ ) :ref:`🔗` Змінює порядок елементів у масиві на протилежний. .. rst-class:: classref-item-separator ---- .. _class_PackedVector2Array_method_rfind: .. rst-class:: classref-method :ref:`int` **rfind**\ (\ value\: :ref:`Vector2`, from\: :ref:`int` = -1\ ) |const| :ref:`🔗` Шукає значення в масиві у зворотному порядку. Додатково може бути переданий початковий індекс пошуку. Якщо негативний, початковий індекс вважається відносно кінця масиву. \ **Примітка:** Поведінка векторів з :ref:`@GDScript.NAN` відрізняється від інших. Через це результати цього методу можуть бути неточними за наявності NaN-ів. .. rst-class:: classref-item-separator ---- .. _class_PackedVector2Array_method_set: .. rst-class:: classref-method |void| **set**\ (\ index\: :ref:`int`, value\: :ref:`Vector2`\ ) :ref:`🔗` Змінює :ref:`Vector2` в даній позиції. .. rst-class:: classref-item-separator ---- .. _class_PackedVector2Array_method_size: .. rst-class:: classref-method :ref:`int` **size**\ (\ ) |const| :ref:`🔗` Повертає кількість елементів у масиві. .. rst-class:: classref-item-separator ---- .. _class_PackedVector2Array_method_slice: .. rst-class:: classref-method :ref:`PackedVector2Array` **slice**\ (\ begin\: :ref:`int`, end\: :ref:`int` = 2147483647\ ) |const| :ref:`🔗` Повертає розріз **PackedVector2Array**, з ``start`` (включно) до ``end`` (виключно), як новий **PackedVector2Array**. Абсолютне значення ``start`` і ``end`` буде зафіксовано до розміру масиву, тому значення за замовчуванням для ``end`` робить кінець розрізу кінцем масиву за замовчуванням (тобто ``arr.slice(1)`` є скороченим записом для ``arr.slice(1, arr.size())``). Якщо ж ``start`` або ``end`` є негативними, вони будуть відносно кінця масиву (тобто ``arr.slice(0, -2)`` є скороченим записом для ``arr.slice(0, arr.size() - 2)``). .. rst-class:: classref-item-separator ---- .. _class_PackedVector2Array_method_sort: .. rst-class:: classref-method |void| **sort**\ (\ ) :ref:`🔗` Сортує елементи масиву в порядку зростання. \ **Примітка:** Поведінка векторів з :ref:`@GDScript.NAN` відрізняється від інших. Через це результати цього методу можуть бути неточними за наявності NaN-ів. .. rst-class:: classref-item-separator ---- .. _class_PackedVector2Array_method_to_byte_array: .. rst-class:: classref-method :ref:`PackedByteArray` **to_byte_array**\ (\ ) |const| :ref:`🔗` Повернення :ref:`PackedByteArray` з кожним вектором закодовано як байти. .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Описи операторів -------------------------------- .. _class_PackedVector2Array_operator_neq_PackedVector2Array: .. rst-class:: classref-operator :ref:`bool` **operator !=**\ (\ right\: :ref:`PackedVector2Array`\ ) :ref:`🔗` Повертає ``true``, якщо вміст масивів відрізняється. .. rst-class:: classref-item-separator ---- .. _class_PackedVector2Array_operator_mul_Transform2D: .. rst-class:: classref-operator :ref:`PackedVector2Array` **operator ***\ (\ right\: :ref:`Transform2D`\ ) :ref:`🔗` Повертає нову **PackedVector2Array** з усіма векторами в цьому масиві, навпаки, трансформується (multiplied) за допомогою даної :ref:`Transform2D` матриці перетворення, під припущенням, що основа трансформації є ортонормальним (тобто обертання / рефлекція є дрібним, масштабування / шавлія не). \ ``array * трансформатор`` еквівалент ``transform.inverse() * array``. :ref:`Transform2D.inverse()`. Для перетворення інверсом афінової трансформації (наприклад, з масштабуванням) ``transform.affine_inverse() * array`` може використовуватися замість. :ref:`Transform2D.affine_inverse()`. .. rst-class:: classref-item-separator ---- .. _class_PackedVector2Array_operator_sum_PackedVector2Array: .. rst-class:: classref-operator :ref:`PackedVector2Array` **operator +**\ (\ right\: :ref:`PackedVector2Array`\ ) :ref:`🔗` Повертає новий **PackedVector2Array** з вмістом ``right`` додано в кінці цього масиву. Для кращої роботи розглянемо використання :ref:`append_array()` замість. .. rst-class:: classref-item-separator ---- .. _class_PackedVector2Array_operator_eq_PackedVector2Array: .. rst-class:: classref-operator :ref:`bool` **operator ==**\ (\ right\: :ref:`PackedVector2Array`\ ) :ref:`🔗` Повертає ``true``, якщо вміст обох масивів однаково, тобто вони мають всі рівні :ref:`Vector2` на відповідних показниках. .. rst-class:: classref-item-separator ---- .. _class_PackedVector2Array_operator_idx_int: .. rst-class:: classref-operator :ref:`Vector2` **operator []**\ (\ index\: :ref:`int`\ ) :ref:`🔗` Повернення :ref:`Vector2` в індекс ``index``. Негативні індекси можуть використовуватися для доступу до елементів з кінця. Використання індексу з меж масиву призведе до помилки. .. |virtual| replace:: :abbr:`virtual (Зазвичай, цей метод перевизначається користувачем, щоб він мав вплив.)` .. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)` .. |const| replace:: :abbr:`const (Цей метод не має побічних ефектів. Не змінює ніяку змінну екземпляра об'єкта.)` .. |vararg| replace:: :abbr:`vararg (Цей метод приймає будь-яке число аргументів після описаних тут.)` .. |constructor| replace:: :abbr:`constructor (Цей метод використовується для побудови типів.)` .. |static| replace:: :abbr:`static (Цей метод не потребує екземпляра для виклику, його можна викликати безпосередньо за допомогою назви класу.)` .. |operator| replace:: :abbr:`operator (Цей метод описує дійсний оператор для взаємодії з цим типом як з лівим операндом.)` .. |bitfield| replace:: :abbr:`BitField (Це значення є цілим числом, складеним у вигляді бітової маски з наступних прапорів.)` .. |void| replace:: :abbr:`void (Значення не повертається.)`