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

1293 lines
85 KiB
ReStructuredText
Raw Permalink Blame History

:github_url: hide
.. _class_Vector2:
Vector2
=======
Un vector 2D que utiliza coordenadas de punto flotante.
.. rst-class:: classref-introduction-group
Descripción
----------------------
Estructura de 2 elementos que se puede usar para representar coordenadas 2D o cualquier otro par de valores numéricos.
Utiliza coordenadas de punto flotante. De forma predeterminada, estos valores de punto flotante utilizan una precisión de 32 bits, a diferencia de :ref:`float<class_float>` que siempre tiene 64 bits. Si se necesita una precisión doble, compila el motor con la opción ``precision=double``.
Véase :ref:`Vector2i<class_Vector2i>` para su contraparte entera.
\ **Nota:** En un contexto booleano, un Vector2 se evaluará como ``false`` si es igual a ``Vector2(0, 0)``. De lo contrario, un Vector2 siempre se evaluará como ``true``.
.. rst-class:: classref-introduction-group
Tutoriales
--------------------
- :doc:`Índice de documentación matemática <../tutorials/math/index>`
- :doc:`Matemáticas vectoriales <../tutorials/math/vector_math>`
- :doc:`Matemática vectorial avanzada <../tutorials/math/vectors_advanced>`
- `Esencia del álgebra lineal de 3Blue1Brown <https://www.youtube.com/playlist?list=PLZHQObOWTQDPD3MizzM2xVFitgF8hE_ab>`__
- `Demo de Transformación de Matriz <https://godotengine.org/asset-library/asset/2787>`__
- `Todos los Demos 2D <https://github.com/godotengine/godot-demo-projects/tree/master/2d>`__
.. rst-class:: classref-reftable-group
Propiedades
----------------------
.. table::
:widths: auto
+---------------------------+------------------------------------+---------+
| :ref:`float<class_float>` | :ref:`x<class_Vector2_property_x>` | ``0.0`` |
+---------------------------+------------------------------------+---------+
| :ref:`float<class_float>` | :ref:`y<class_Vector2_property_y>` | ``0.0`` |
+---------------------------+------------------------------------+---------+
.. rst-class:: classref-reftable-group
Constructores
--------------------------
.. table::
:widths: auto
+-------------------------------+-----------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`Vector2<class_Vector2_constructor_Vector2>`\ (\ ) |
+-------------------------------+-----------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`Vector2<class_Vector2_constructor_Vector2>`\ (\ from\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------+-----------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`Vector2<class_Vector2_constructor_Vector2>`\ (\ from\: :ref:`Vector2i<class_Vector2i>`\ ) |
+-------------------------------+-----------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`Vector2<class_Vector2_constructor_Vector2>`\ (\ x\: :ref:`float<class_float>`, y\: :ref:`float<class_float>`\ ) |
+-------------------------------+-----------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-reftable-group
Métodos
--------------
.. table::
:widths: auto
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`abs<class_Vector2_method_abs>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`angle<class_Vector2_method_angle>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`angle_to<class_Vector2_method_angle_to>`\ (\ to\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`angle_to_point<class_Vector2_method_angle_to_point>`\ (\ to\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`aspect<class_Vector2_method_aspect>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`bezier_derivative<class_Vector2_method_bezier_derivative>`\ (\ control_1\: :ref:`Vector2<class_Vector2>`, control_2\: :ref:`Vector2<class_Vector2>`, end\: :ref:`Vector2<class_Vector2>`, t\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`bezier_interpolate<class_Vector2_method_bezier_interpolate>`\ (\ control_1\: :ref:`Vector2<class_Vector2>`, control_2\: :ref:`Vector2<class_Vector2>`, end\: :ref:`Vector2<class_Vector2>`, t\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`bounce<class_Vector2_method_bounce>`\ (\ n\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`ceil<class_Vector2_method_ceil>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`clamp<class_Vector2_method_clamp>`\ (\ min\: :ref:`Vector2<class_Vector2>`, max\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`clampf<class_Vector2_method_clampf>`\ (\ min\: :ref:`float<class_float>`, max\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`cross<class_Vector2_method_cross>`\ (\ with\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`cubic_interpolate<class_Vector2_method_cubic_interpolate>`\ (\ b\: :ref:`Vector2<class_Vector2>`, pre_a\: :ref:`Vector2<class_Vector2>`, post_b\: :ref:`Vector2<class_Vector2>`, weight\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`cubic_interpolate_in_time<class_Vector2_method_cubic_interpolate_in_time>`\ (\ b\: :ref:`Vector2<class_Vector2>`, pre_a\: :ref:`Vector2<class_Vector2>`, post_b\: :ref:`Vector2<class_Vector2>`, weight\: :ref:`float<class_float>`, b_t\: :ref:`float<class_float>`, pre_a_t\: :ref:`float<class_float>`, post_b_t\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`direction_to<class_Vector2_method_direction_to>`\ (\ to\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`distance_squared_to<class_Vector2_method_distance_squared_to>`\ (\ to\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`distance_to<class_Vector2_method_distance_to>`\ (\ to\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`dot<class_Vector2_method_dot>`\ (\ with\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`floor<class_Vector2_method_floor>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`from_angle<class_Vector2_method_from_angle>`\ (\ angle\: :ref:`float<class_float>`\ ) |static| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_equal_approx<class_Vector2_method_is_equal_approx>`\ (\ to\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_finite<class_Vector2_method_is_finite>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_normalized<class_Vector2_method_is_normalized>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_zero_approx<class_Vector2_method_is_zero_approx>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`length<class_Vector2_method_length>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`length_squared<class_Vector2_method_length_squared>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`lerp<class_Vector2_method_lerp>`\ (\ to\: :ref:`Vector2<class_Vector2>`, weight\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`limit_length<class_Vector2_method_limit_length>`\ (\ length\: :ref:`float<class_float>` = 1.0\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`max<class_Vector2_method_max>`\ (\ with\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`max_axis_index<class_Vector2_method_max_axis_index>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`maxf<class_Vector2_method_maxf>`\ (\ with\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`min<class_Vector2_method_min>`\ (\ with\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`min_axis_index<class_Vector2_method_min_axis_index>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`minf<class_Vector2_method_minf>`\ (\ with\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`move_toward<class_Vector2_method_move_toward>`\ (\ to\: :ref:`Vector2<class_Vector2>`, delta\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`normalized<class_Vector2_method_normalized>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`orthogonal<class_Vector2_method_orthogonal>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`posmod<class_Vector2_method_posmod>`\ (\ mod\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`posmodv<class_Vector2_method_posmodv>`\ (\ modv\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`project<class_Vector2_method_project>`\ (\ b\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`reflect<class_Vector2_method_reflect>`\ (\ line\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`rotated<class_Vector2_method_rotated>`\ (\ angle\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`round<class_Vector2_method_round>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`sign<class_Vector2_method_sign>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`slerp<class_Vector2_method_slerp>`\ (\ to\: :ref:`Vector2<class_Vector2>`, weight\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`slide<class_Vector2_method_slide>`\ (\ n\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`snapped<class_Vector2_method_snapped>`\ (\ step\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`snappedf<class_Vector2_method_snappedf>`\ (\ step\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-reftable-group
Operadores
--------------------
.. table::
:widths: auto
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator !=<class_Vector2_operator_neq_Vector2>`\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`operator *<class_Vector2_operator_mul_Transform2D>`\ (\ right\: :ref:`Transform2D<class_Transform2D>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`operator *<class_Vector2_operator_mul_Vector2>`\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`operator *<class_Vector2_operator_mul_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`operator *<class_Vector2_operator_mul_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`operator +<class_Vector2_operator_sum_Vector2>`\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`operator -<class_Vector2_operator_dif_Vector2>`\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`operator /<class_Vector2_operator_div_Vector2>`\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`operator /<class_Vector2_operator_div_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`operator /<class_Vector2_operator_div_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator \<<class_Vector2_operator_lt_Vector2>`\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator \<=<class_Vector2_operator_lte_Vector2>`\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator ==<class_Vector2_operator_eq_Vector2>`\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator ><class_Vector2_operator_gt_Vector2>`\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator >=<class_Vector2_operator_gte_Vector2>`\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`operator []<class_Vector2_operator_idx_int>`\ (\ index\: :ref:`int<class_int>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`operator unary+<class_Vector2_operator_unplus>`\ (\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`operator unary-<class_Vector2_operator_unminus>`\ (\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Enumeraciones
--------------------------
.. _enum_Vector2_Axis:
.. rst-class:: classref-enumeration
enum **Axis**: :ref:`🔗<enum_Vector2_Axis>`
.. _class_Vector2_constant_AXIS_X:
.. rst-class:: classref-enumeration-constant
:ref:`Axis<enum_Vector2_Axis>` **AXIS_X** = ``0``
Valor enumerado para el eje X. Devuelto por :ref:`max_axis_index()<class_Vector2_method_max_axis_index>` y :ref:`min_axis_index()<class_Vector2_method_min_axis_index>`.
.. _class_Vector2_constant_AXIS_Y:
.. rst-class:: classref-enumeration-constant
:ref:`Axis<enum_Vector2_Axis>` **AXIS_Y** = ``1``
Valor enumerado para el eje Y. Devuelto por :ref:`max_axis_index()<class_Vector2_method_max_axis_index>` y :ref:`min_axis_index()<class_Vector2_method_min_axis_index>`.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Constantes
--------------------
.. _class_Vector2_constant_ZERO:
.. rst-class:: classref-constant
**ZERO** = ``Vector2(0, 0)`` :ref:`🔗<class_Vector2_constant_ZERO>`
Vector cero, un vector con todos los componentes ajustados a ``0``.
.. _class_Vector2_constant_ONE:
.. rst-class:: classref-constant
**ONE** = ``Vector2(1, 1)`` :ref:`🔗<class_Vector2_constant_ONE>`
Un vector, un vector con todos los componentes ajustados a ``1``.
.. _class_Vector2_constant_INF:
.. rst-class:: classref-constant
**INF** = ``Vector2(inf, inf)`` :ref:`🔗<class_Vector2_constant_INF>`
Vector infinito, un vector con todos los componentes ajustados a :ref:`@GDScript.INF<class_@GDScript_constant_INF>`.
.. _class_Vector2_constant_LEFT:
.. rst-class:: classref-constant
**LEFT** = ``Vector2(-1, 0)`` :ref:`🔗<class_Vector2_constant_LEFT>`
Vector de la unidad izquierda. Representa la dirección de la izquierda.
.. _class_Vector2_constant_RIGHT:
.. rst-class:: classref-constant
**RIGHT** = ``Vector2(1, 0)`` :ref:`🔗<class_Vector2_constant_RIGHT>`
Vector de la unidad derecha. Representa la dirección de la derecha.
.. _class_Vector2_constant_UP:
.. rst-class:: classref-constant
**UP** = ``Vector2(0, -1)`` :ref:`🔗<class_Vector2_constant_UP>`
Vector de la unidad superior. Y está abajo en 2D, por lo que este vector apunta -Y.
.. _class_Vector2_constant_DOWN:
.. rst-class:: classref-constant
**DOWN** = ``Vector2(0, 1)`` :ref:`🔗<class_Vector2_constant_DOWN>`
Vector de la unidad de descenso. Y está abajo en 2D, así que este vector apunta a +Y.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descripciones de Propiedades
--------------------------------------------------------
.. _class_Vector2_property_x:
.. rst-class:: classref-property
:ref:`float<class_float>` **x** = ``0.0`` :ref:`🔗<class_Vector2_property_x>`
El componente X del vector. También se puede acceder utilizando la posición del índice ``[0]``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_property_y:
.. rst-class:: classref-property
:ref:`float<class_float>` **y** = ``0.0`` :ref:`🔗<class_Vector2_property_y>`
El componente Y del vector. También se puede acceder usando la posición del índice ``[1]``.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descripciones de Constructores
------------------------------------------------------------
.. _class_Vector2_constructor_Vector2:
.. rst-class:: classref-constructor
:ref:`Vector2<class_Vector2>` **Vector2**\ (\ ) :ref:`🔗<class_Vector2_constructor_Vector2>`
Construye un **Vector2** inicializado por defecto con todos sus componentes a ``0``.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`Vector2<class_Vector2>` **Vector2**\ (\ from\: :ref:`Vector2<class_Vector2>`\ )
Construye un **Vector2** como una copia del **Vector2** dado.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`Vector2<class_Vector2>` **Vector2**\ (\ from\: :ref:`Vector2i<class_Vector2i>`\ )
Construye un nuevo **Vector2** a partir de :ref:`Vector2i<class_Vector2i>`.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`Vector2<class_Vector2>` **Vector2**\ (\ x\: :ref:`float<class_float>`, y\: :ref:`float<class_float>`\ )
Construye un nuevo **Vector2** a partir de los ``x`` y ``y`` dados.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descripciones de Métodos
------------------------------------------------
.. _class_Vector2_method_abs:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **abs**\ (\ ) |const| :ref:`🔗<class_Vector2_method_abs>`
Devuelve un nuevo vector con todos los componentes en valores absolutos (es decir, positivos).
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_angle:
.. rst-class:: classref-method
:ref:`float<class_float>` **angle**\ (\ ) |const| :ref:`🔗<class_Vector2_method_angle>`
Devuelve el ángulo de este vector con respecto al eje X positivo, o vector ``(1, 0)``, en radianes.
Por ejemplo, ``Vector2.RIGHT.angle()`` devolverá cero, ``Vector2.DOWN.angle()`` devolverá ``PI / 2`` (un cuarto de vuelta, o 90 grados), y ``Vector2(1, -1).angle()`` devolverá ``-PI / 4`` (un octavo de vuelta negativo, o -45 grados).
\ `Ilustración del ángulo devuelto. <https://raw.githubusercontent.com/godotengine/godot-docs/master/img/vector2_angle.png>`__\
Equivalente al resultado de :ref:`@GlobalScope.atan2()<class_@GlobalScope_method_atan2>` cuando se llama con el :ref:`y<class_Vector2_property_y>` e :ref:`x<class_Vector2_property_x>` del vector como parámetros: ``atan2(y, x)``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_angle_to:
.. rst-class:: classref-method
:ref:`float<class_float>` **angle_to**\ (\ to\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_angle_to>`
Devuelve el ángulo con signo al vector dado, en radianes.
\ `Ilustración del ángulo devuelto. <https://raw.githubusercontent.com/godotengine/godot-docs/master/img/vector2_angle_to.png>`__
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_angle_to_point:
.. rst-class:: classref-method
:ref:`float<class_float>` **angle_to_point**\ (\ to\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_angle_to_point>`
Devuelve el ángulo entre la línea que conecta los dos puntos y el eje X, en radianes.
\ ``a.angle_to_point(b)`` es equivalente a hacer ``(b - a).angle()``.
\ `Ilustración del ángulo devuelto. <https://raw.githubusercontent.com/godotengine/godot-docs/master/img/vector2_angle_to_point.png>`__
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_aspect:
.. rst-class:: classref-method
:ref:`float<class_float>` **aspect**\ (\ ) |const| :ref:`🔗<class_Vector2_method_aspect>`
Devuelve la relación de aspecto de este vector, la relación de :ref:`x<class_Vector2_property_x>` a :ref:`y<class_Vector2_property_y>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_bezier_derivative:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **bezier_derivative**\ (\ control_1\: :ref:`Vector2<class_Vector2>`, control_2\: :ref:`Vector2<class_Vector2>`, end\: :ref:`Vector2<class_Vector2>`, t\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_bezier_derivative>`
Devuelve la derivada en el ``t`` dado en la `curva de Bézier <https://en.wikipedia.org/wiki/B%C3%A9zier_curve>`__ definida por este vector y los puntos ``control_1``, ``control_2`` y ``end`` dados.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_bezier_interpolate:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **bezier_interpolate**\ (\ control_1\: :ref:`Vector2<class_Vector2>`, control_2\: :ref:`Vector2<class_Vector2>`, end\: :ref:`Vector2<class_Vector2>`, t\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_bezier_interpolate>`
Devuelve el punto en el ``t`` dado en la `curva de Bézier <https://en.wikipedia.org/wiki/B%C3%A9zier_curve>`__ definida por este vector y los puntos ``control_1``, ``control_2`` y ``end`` dados.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_bounce:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **bounce**\ (\ n\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_bounce>`
Devuelve el vector "rebotado" de una línea definida por la normal ``n`` dada perpendicular a la línea.
\ **Nota:** :ref:`bounce()<class_Vector2_method_bounce>` realiza la operación que la mayoría de los motores y frameworks llaman ``reflect()``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_ceil:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **ceil**\ (\ ) |const| :ref:`🔗<class_Vector2_method_ceil>`
Devuelve un nuevo vector con todos los componentes redondeados hacia arriba (hacia el infinito positivo).
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_clamp:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **clamp**\ (\ min\: :ref:`Vector2<class_Vector2>`, max\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_clamp>`
Devuelve un nuevo vector con todos los componentes limitados entre los componentes de ``min`` y ``max``, ejecutando :ref:`@GlobalScope.clamp()<class_@GlobalScope_method_clamp>` en cada componente.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_clampf:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **clampf**\ (\ min\: :ref:`float<class_float>`, max\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_clampf>`
Devuelve un nuevo vector con todos los componentes restringidos entre ``min`` y ``max``, ejecutando :ref:`@GlobalScope.clamp()<class_@GlobalScope_method_clamp>` en cada componente.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_cross:
.. rst-class:: classref-method
:ref:`float<class_float>` **cross**\ (\ with\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_cross>`
Devuelve el análogo 2D del producto cruz para este vector y ``with``.
Esta es el área con signo del paralelogramo formado por los dos vectores. Si el segundo vector está en el sentido de las agujas del reloj desde el primer vector, entonces el producto cruz es el área positiva. Si es en sentido contrario a las agujas del reloj, el producto cruz es el área negativa. Si los dos vectores son paralelos, esto devuelve cero, lo que lo hace útil para probar si dos vectores son paralelos.
\ **Nota:** El producto cruz no se define en 2D matemáticamente. Este método incrusta los vectores 2D en el plano XY del espacio 3D y utiliza el componente Z de su producto cruz como análogo.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_cubic_interpolate:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **cubic_interpolate**\ (\ b\: :ref:`Vector2<class_Vector2>`, pre_a\: :ref:`Vector2<class_Vector2>`, post_b\: :ref:`Vector2<class_Vector2>`, weight\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_cubic_interpolate>`
Realiza una interpolación cúbica entre este vector y ``b`` usando ``pre_a`` y ``post_b`` como manejadores, y devuelve el resultado en la posición ``weight``. ``weight`` está en el rango de 0.0 a 1.0, representando la cantidad de interpolación.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_cubic_interpolate_in_time:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **cubic_interpolate_in_time**\ (\ b\: :ref:`Vector2<class_Vector2>`, pre_a\: :ref:`Vector2<class_Vector2>`, post_b\: :ref:`Vector2<class_Vector2>`, weight\: :ref:`float<class_float>`, b_t\: :ref:`float<class_float>`, pre_a_t\: :ref:`float<class_float>`, post_b_t\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_cubic_interpolate_in_time>`
Realiza una interpolación cúbica entre este vector y ``b`` usando ``pre_a`` y ``post_b`` como manejadores, y devuelve el resultado en la posición ``weight``. ``weight`` está en el rango de 0.0 a 1.0, representando la cantidad de interpolación.
Puede realizar una interpolación más suave que :ref:`cubic_interpolate()<class_Vector2_method_cubic_interpolate>` por los valores de tiempo.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_direction_to:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **direction_to**\ (\ to\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_direction_to>`
Devuelve el vector normalizado que apunta desde este vector a ``to``. Esto es equivalente a usar ``(to - self).normalized()``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_distance_squared_to:
.. rst-class:: classref-method
:ref:`float<class_float>` **distance_squared_to**\ (\ to\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_distance_squared_to>`
Devuelve la distancia al cuadrado entre este vector y ``to``.
Este método se ejecuta más rápido que :ref:`distance_to()<class_Vector2_method_distance_to>`, así que es preferible si necesitas comparar vectores o necesitas la distancia al cuadrado para alguna fórmula.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_distance_to:
.. rst-class:: classref-method
:ref:`float<class_float>` **distance_to**\ (\ to\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_distance_to>`
Devuelve la distancia entre este vector y ``to``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_dot:
.. rst-class:: classref-method
:ref:`float<class_float>` **dot**\ (\ with\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_dot>`
Devuelve el producto escalar de este vector y ``with``. Esto puede ser usado para comparar el ángulo entre dos vectores. Por ejemplo, esto puede ser usado para determinar si un enemigo está de cara al jugador.
El producto escalar será ``0`` para un ángulo recto (90 grados), mayor que 0 para ángulos más estrechos que 90 grados y menor que 0 para ángulos más anchos que 90 grados.
Cuando se utilizan vectores unitarios (normalizados), el resultado siempre estará entre ``-1.0`` (ángulo de 180 grados) cuando los vectores estén orientados en direcciones opuestas, y ``1.0`` (ángulo de 0 grados) cuando los vectores estén alineados.
\ **Nota:** ``a.dot(b)`` es equivalente a ``b.dot(a)``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_floor:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **floor**\ (\ ) |const| :ref:`🔗<class_Vector2_method_floor>`
Devuelve un nuevo vector con todos los componentes redondeados hacia abajo (hacia el infinito negativo).
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_from_angle:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **from_angle**\ (\ angle\: :ref:`float<class_float>`\ ) |static| :ref:`🔗<class_Vector2_method_from_angle>`
Crea un **Vector2** rotado al ``angle`` dado en radianes. Esto es equivalente a hacer ``Vector2(cos(angle), sin(angle))`` o ``Vector2.RIGHT.rotated(angle)``.
::
print(Vector2.from_angle(0)) # Imprime (1.0, 0.0)
print(Vector2(1, 0).angle()) # Imprime 0.0, que es el ángulo usado arriba.
print(Vector2.from_angle(PI / 2)) # Imprime (0.0, 1.0)
\ **Nota:** La longitud del **Vector2** devuelto es *aproximadamente* ``1.0``, pero no se garantiza que sea exactamente ``1.0`` debido a problemas de precisión de punto flotante. Llama a :ref:`normalized()<class_Vector2_method_normalized>` en el **Vector2** devuelto si requieres un vector unitario.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_is_equal_approx:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_equal_approx**\ (\ to\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_is_equal_approx>`
Devuelve ``true`` si este vector y ``to`` son aproximadamente iguales, ejecutando :ref:`@GlobalScope.is_equal_approx()<class_@GlobalScope_method_is_equal_approx>` en cada componente.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_is_finite:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_finite**\ (\ ) |const| :ref:`🔗<class_Vector2_method_is_finite>`
Devuelve ``true`` si este vector es finito, llamando a :ref:`@GlobalScope.is_finite()<class_@GlobalScope_method_is_finite>` en cada componente.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_is_normalized:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_normalized**\ (\ ) |const| :ref:`🔗<class_Vector2_method_is_normalized>`
Devuelve ``true`` si el vector está normalizado, es decir, si su longitud es aproximadamente igual a 1.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_is_zero_approx:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_zero_approx**\ (\ ) |const| :ref:`🔗<class_Vector2_method_is_zero_approx>`
Devuelve ``true`` si los valores de este vector son aproximadamente cero, ejecutando :ref:`@GlobalScope.is_zero_approx()<class_@GlobalScope_method_is_zero_approx>` en cada componente.
Este método es más rápido que usar :ref:`is_equal_approx()<class_Vector2_method_is_equal_approx>` con un valor como un vector cero.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_length:
.. rst-class:: classref-method
:ref:`float<class_float>` **length**\ (\ ) |const| :ref:`🔗<class_Vector2_method_length>`
Devuelve la longitud (magnitud) de este vector.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_length_squared:
.. rst-class:: classref-method
:ref:`float<class_float>` **length_squared**\ (\ ) |const| :ref:`🔗<class_Vector2_method_length_squared>`
Devuelve la longitud cuadrada (magnitud cuadrada) de este vector.
Este método funciona más rápido que el :ref:`length()<class_Vector2_method_length>`, por lo que es preferible si necesitas comparar vectores o necesitas la distancia al cuadrado para alguna fórmula.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_lerp:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **lerp**\ (\ to\: :ref:`Vector2<class_Vector2>`, weight\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_lerp>`
Devuelve el resultado de la interpolación lineal entre este vector y ``to`` por la cantidad ``weight``. ``weight`` está en el rango de ``0.0`` a ``1.0``, representando la cantidad de interpolación.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_limit_length:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **limit_length**\ (\ length\: :ref:`float<class_float>` = 1.0\ ) |const| :ref:`🔗<class_Vector2_method_limit_length>`
Devuelve el vector con una longitud máxima limitando su longitud a ``length``. Si el vector no es finito, el resultado no está definido.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_max:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **max**\ (\ with\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_max>`
Devuelve el máximo componente a componente de este y ``with``, equivalente a ``Vector2(maxf(x, with.x), maxf(y, with.y))``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_max_axis_index:
.. rst-class:: classref-method
:ref:`int<class_int>` **max_axis_index**\ (\ ) |const| :ref:`🔗<class_Vector2_method_max_axis_index>`
Devuelve el eje del valor más alto del vector. Consulta las constantes ``AXIS_*``. Si todos los componentes son iguales, este método devuelve :ref:`AXIS_X<class_Vector2_constant_AXIS_X>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_maxf:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **maxf**\ (\ with\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_maxf>`
Devuelve el máximo componente a componente de este y ``with``, equivalente a ``Vector2(maxf(x, with), maxf(y, with))``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_min:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **min**\ (\ with\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_min>`
Devuelve el mínimo componente a componente de este y ``with``, equivalente a ``Vector2(minf(x, with.x), minf(y, with.y))``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_min_axis_index:
.. rst-class:: classref-method
:ref:`int<class_int>` **min_axis_index**\ (\ ) |const| :ref:`🔗<class_Vector2_method_min_axis_index>`
Devuelve el eje del valor más bajo del vector. Consulta las constantes ``AXIS_*``. Si todos los componentes son iguales, este método devuelve :ref:`AXIS_Y<class_Vector2_constant_AXIS_Y>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_minf:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **minf**\ (\ with\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_minf>`
Devuelve el mínimo componente a componente de este y ``with``, equivalente a ``Vector2(minf(x, with), minf(y, with))``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_move_toward:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **move_toward**\ (\ to\: :ref:`Vector2<class_Vector2>`, delta\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_move_toward>`
Devuelve un nuevo vector movido hacia ``to`` por la cantidad fija de ``delta``. No pasará del valor final.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_normalized:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **normalized**\ (\ ) |const| :ref:`🔗<class_Vector2_method_normalized>`
Devuelve el resultado de escalar el vector a la longitud de la unidad. Equivalente a ``v / v.length()``. Devuelve ``(0, 0)`` si ``v.length() == 0``. Véase también :ref:`is_normalized()<class_Vector2_method_is_normalized>`.
\ **Nota:** Esta función puede devolver valores incorrectos si la longitud del vector de entrada es cercana a cero.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_orthogonal:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **orthogonal**\ (\ ) |const| :ref:`🔗<class_Vector2_method_orthogonal>`
Devuelve un vector perpendicular girado 90 grados en sentido contrario a las agujas del reloj en comparación con el original, con la misma longitud.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_posmod:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **posmod**\ (\ mod\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_posmod>`
Devuelve un vector compuesto por el :ref:`@GlobalScope.fposmod()<class_@GlobalScope_method_fposmod>` de los componentes de este vector y ``mod``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_posmodv:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **posmodv**\ (\ modv\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_posmodv>`
Devuelve un vector compuesto por el :ref:`@GlobalScope.fposmod()<class_@GlobalScope_method_fposmod>` de los componentes de este vector y los componentes de ``modv``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_project:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **project**\ (\ b\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_project>`
Devuelve un nuevo vector resultante de proyectar este vector sobre el vector ``b`` dado. El nuevo vector resultante es paralelo a ``b``. Ver también :ref:`slide()<class_Vector2_method_slide>`.
\ **Nota:** Si el vector ``b`` es un vector cero, los componentes del nuevo vector resultante serán :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_reflect:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **reflect**\ (\ line\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_reflect>`
Devuelve el resultado de reflejar el vector desde una línea definida por el vector de dirección ``line`` dado.
\ **Nota:** :ref:`reflect()<class_Vector2_method_reflect>` difiere de lo que otros motores y frameworks llaman ``reflect()``. En otros motores, ``reflect()`` toma una dirección normal que es una dirección perpendicular a la línea. En Godot, se especifica la dirección de la línea directamente. Véase también :ref:`bounce()<class_Vector2_method_bounce>` que hace lo que la mayoría de los motores llaman ``reflect()``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_rotated:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **rotated**\ (\ angle\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_rotated>`
Devuelve el resultado de rotar este vector por ``angle`` (en radianes). Véase también :ref:`@GlobalScope.deg_to_rad()<class_@GlobalScope_method_deg_to_rad>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_round:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **round**\ (\ ) |const| :ref:`🔗<class_Vector2_method_round>`
Devuelve un nuevo vector con todos los componentes redondeados al entero más cercano, con los casos intermedios redondeados desde cero.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_sign:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **sign**\ (\ ) |const| :ref:`🔗<class_Vector2_method_sign>`
Devuelve un nuevo vector con cada componente establecido a ``1.0`` si es positivo, ``-1.0`` si es negativo y ``0.0`` si es cero. El resultado es idéntico a llamar a :ref:`@GlobalScope.sign()<class_@GlobalScope_method_sign>` en cada componente.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_slerp:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **slerp**\ (\ to\: :ref:`Vector2<class_Vector2>`, weight\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_slerp>`
Devuelve el resultado de la interpolación lineal esférica entre este vector y ``to``, por la cantidad ``weight``. ``weight`` está en el rango de 0.0 a 1.0, representando la cantidad de interpolación.
Este método también gestiona la interpolación de las longitudes si los vectores de entrada tienen longitudes diferentes. Para el caso especial de que uno o ambos vectores de entrada tengan longitud cero, este método se comporta como :ref:`lerp()<class_Vector2_method_lerp>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_slide:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **slide**\ (\ n\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_slide>`
Devuelve un nuevo vector resultante de deslizar este vector a lo largo de una línea con la normal ``n``. El nuevo vector resultante es perpendicular a ``n``, y es equivalente a este vector menos su proyección sobre ``n``. Véase también :ref:`project()<class_Vector2_method_project>`.
\ **Nota:** El vector ``n`` debe ser normalizado. Véase también :ref:`normalized()<class_Vector2_method_normalized>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_snapped:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **snapped**\ (\ step\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_snapped>`
Devuelve un nuevo vector con cada componente ajustado al múltiplo más cercano del componente correspondiente en ``step``. Esto también se puede usar para redondear los componentes a un número arbitrario de decimales.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_snappedf:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **snappedf**\ (\ step\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_snappedf>`
Devuelve un nuevo vector con cada componente ajustado al múltiplo más cercano de ``step``. Esto también se puede usar para redondear los componentes a un número arbitrario de decimales.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descripciones de Operadores
------------------------------------------------------
.. _class_Vector2_operator_neq_Vector2:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator !=**\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Vector2_operator_neq_Vector2>`
Devuelve ``true`` si los vectores no son iguales.
\ **Nota:** Debido a errores de precisión en punto flotante, considera usar :ref:`is_equal_approx()<class_Vector2_method_is_equal_approx>` en su lugar, ya que es más fiable.
\ **Nota:** Los vectores con elementos :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` no se comportan igual que otros vectores. Por lo tanto, los resultados de este operador podrían no ser precisos si se incluyen NaN.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_mul_Transform2D:
.. rst-class:: classref-operator
:ref:`Vector2<class_Vector2>` **operator ***\ (\ right\: :ref:`Transform2D<class_Transform2D>`\ ) :ref:`🔗<class_Vector2_operator_mul_Transform2D>`
Transforma inversamente (multiplica) el **Vector2** por la matriz de transformación :ref:`Transform2D<class_Transform2D>` dada, bajo el supuesto de que la base de la transformación es ortonormal (es decir, la rotación/reflexión está bien, el escalado/sesgo no lo está).
\ ``vector * transform`` es equivalente a ``transform.inverse() * vector``. Véase :ref:`Transform2D.inverse()<class_Transform2D_method_inverse>`.
Para transformar por la inversa de una transformación afín (por ejemplo, con escalado) se puede usar ``transform.affine_inverse() * vector`` en su lugar. Véase :ref:`Transform2D.affine_inverse()<class_Transform2D_method_affine_inverse>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_mul_Vector2:
.. rst-class:: classref-operator
:ref:`Vector2<class_Vector2>` **operator ***\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Vector2_operator_mul_Vector2>`
Multiplica cada componente del **Vector2** por los componentes del **Vector2** dado.
::
print(Vector2(10, 20) * Vector2(3, 4)) # Imprime (30.0, 80.0)
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_mul_float:
.. rst-class:: classref-operator
:ref:`Vector2<class_Vector2>` **operator ***\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_Vector2_operator_mul_float>`
Multiplica cada componente del **Vector2** por el :ref:`float<class_float>` dado.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_mul_int:
.. rst-class:: classref-operator
:ref:`Vector2<class_Vector2>` **operator ***\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Vector2_operator_mul_int>`
Multiplica cada componente del **Vector2** por el :ref:`int<class_int>` dado.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_sum_Vector2:
.. rst-class:: classref-operator
:ref:`Vector2<class_Vector2>` **operator +**\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Vector2_operator_sum_Vector2>`
Suma cada componente de **Vector2** con los componentes del **Vector2** dado.
::
print(Vector2(10, 20) + Vector2(3, 4)) # Imprime (13.0, 24.0)
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_dif_Vector2:
.. rst-class:: classref-operator
:ref:`Vector2<class_Vector2>` **operator -**\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Vector2_operator_dif_Vector2>`
Resta cada componente de **Vector2** por los componentes del **Vector2** dado.
::
print(Vector2(10, 20) - Vector2(3, 4)) # Imprime (7.0, 16.0)
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_div_Vector2:
.. rst-class:: classref-operator
:ref:`Vector2<class_Vector2>` **operator /**\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Vector2_operator_div_Vector2>`
Divide cada componente de **Vector2** entre los componentes del **Vector2** dado.
::
print(Vector2(10, 20) / Vector2(2, 5)) # Imprime (5.0, 4.0)
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_div_float:
.. rst-class:: classref-operator
:ref:`Vector2<class_Vector2>` **operator /**\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_Vector2_operator_div_float>`
Divide cada componente del **Vector2** por el :ref:`float<class_float>` dado.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_div_int:
.. rst-class:: classref-operator
:ref:`Vector2<class_Vector2>` **operator /**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Vector2_operator_div_int>`
Divide cada componente del **Vector2** por el :ref:`int<class_int>` dado.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_lt_Vector2:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator <**\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Vector2_operator_lt_Vector2>`
Compara dos vectores **Vector2** comprobando primero si el valor X del vector de la izquierda es menor que el valor X del vector ``right``. Si los valores X son exactamente iguales, entonces repite esta comprobación con los valores Y de los dos vectores. Este operador es útil para ordenar vectores.
\ **Nota:** Los vectores con elementos :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` no se comportan igual que otros vectores. Por lo tanto, los resultados de este operador pueden no ser precisos si se incluyen NaN.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_lte_Vector2:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator <=**\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Vector2_operator_lte_Vector2>`
Compara dos vectores **Vector2** comprobando primero si el valor X del vector de la izquierda es menor o igual que el valor X del vector ``right``. Si los valores X son exactamente iguales, entonces repite esta comprobación con los valores Y de los dos vectores. Este operador es útil para ordenar vectores.
\ **Nota:** Los vectores con elementos :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` no se comportan igual que otros vectores. Por lo tanto, los resultados de este operador pueden no ser precisos si se incluyen NaN.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_eq_Vector2:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator ==**\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Vector2_operator_eq_Vector2>`
Devuelve ``true`` si los vectores son exactamente iguales.
\ **Nota:** Debido a errores de precisión en punto flotante, considera usar :ref:`is_equal_approx()<class_Vector2_method_is_equal_approx>` en su lugar, ya que es más fiable.
\ **Nota:** Los vectores con elementos :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` no se comportan igual que otros vectores. Por lo tanto, los resultados de este operador podrían no ser precisos si se incluyen NaN.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_gt_Vector2:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator >**\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Vector2_operator_gt_Vector2>`
Compara dos vectores **Vector2** comprobando primero si el valor X del vector de la izquierda es mayor que el valor X del vector ``right``. Si los valores X son exactamente iguales, entonces repite esta comprobación con los valores Y de los dos vectores. Este operador es útil para ordenar vectores.
\ **Nota:** Los vectores con elementos :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` no se comportan igual que otros vectores. Por lo tanto, los resultados de este operador pueden no ser precisos si se incluyen NaN.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_gte_Vector2:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator >=**\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Vector2_operator_gte_Vector2>`
Compara dos vectores **Vector2** comprobando primero si el valor X del vector de la izquierda es mayor o igual que el valor X del vector ``right``. Si los valores X son exactamente iguales, entonces repite esta comprobación con los valores Y de los dos vectores. Este operador es útil para ordenar vectores.
\ **Nota:** Los vectores con elementos :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` no se comportan igual que otros vectores. Por lo tanto, los resultados de este operador pueden no ser precisos si se incluyen NaN.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_idx_int:
.. rst-class:: classref-operator
:ref:`float<class_float>` **operator []**\ (\ index\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Vector2_operator_idx_int>`
Accede a los componentes del vector utilizando su ``index``. ``v[0]`` es equivalente a ``v.x``, y ``v[1]`` es equivalente a ``v.y``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_unplus:
.. rst-class:: classref-operator
:ref:`Vector2<class_Vector2>` **operator unary+**\ (\ ) :ref:`🔗<class_Vector2_operator_unplus>`
Devuelve el mismo valor como si el ``+`` no estuviera ahí. El ``+`` unario no hace nada, pero a veces puede hacer que tu código sea más legible.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_unminus:
.. rst-class:: classref-operator
:ref:`Vector2<class_Vector2>` **operator unary-**\ (\ ) :ref:`🔗<class_Vector2_operator_unminus>`
Devuelve el valor negativo del **Vector2**. Esto es lo mismo que escribir ``Vector2(-v.x, -v.y)``. Esta operación invierte la dirección del vector manteniendo la misma magnitud. Con los floats, el número cero puede ser positivo o negativo.
.. |virtual| replace:: :abbr:`virtual (Normalmente, este método debería ser sobreescrito por el usuario para que tenga algún efecto.)`
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
.. |const| replace:: :abbr:`const (Este método no tiene efectos secundarios. No modifica ninguna de las variables miembro de la instancia.)`
.. |vararg| replace:: :abbr:`vararg (Este método permite agregar cualquier número de argumentos después de los descritos aquí.)`
.. |constructor| replace:: :abbr:`constructor (Este método se utiliza para construir un tipo.)`
.. |static| replace:: :abbr:`static (Este método no necesita una instancia para ser llamado, por lo que puede llamarse directamente utilizando el nombre de la clase.)`
.. |operator| replace:: :abbr:`operator (Este método describe un operador válido para usar con este tipo como operando izquierdo.)`
.. |bitfield| replace:: :abbr:`BitField (Este valor es un entero compuesto como una máscara de bits de las siguientes banderas.)`
.. |void| replace:: :abbr:`void (Sin valor de retorno.)`
Reference in New Issue View Git Blame Copy Permalink