mirror of
https://github.com/godotengine/godot-docs-l10n.git
synced 2025-12-31 09:49:22 +03:00
cf78697eea
Currently including `zh_CN` and `es` which both have very high completion ratios. Others will be added once they reach a significant percentage too. These RST files will be used by godot-docs in place of its `classes` folder after we sync with https://github.com/godotengine/godot-docs/pull/5458. The update workflow is manual for now (example for `zh_CN`): - Build `godotengine/godot` in the branch we currently track (now `3.x`) - Run `godot --doctool -l zh_CN` - Run `cd doc && make rst LANGARG=zh_CN` - Copy `doc/_build/rst/*` to `classes/zh_CN/` here - Make sure to have `classes/zh_CN/index.rst` copied from `docs/classes`
1672 lines
101 KiB
ReStructuredText
1672 lines
101 KiB
ReStructuredText
:github_url: hide
|
|
|
|
.. Generated automatically by doc/tools/make_rst.py in Godot's source tree.
|
|
.. DO NOT EDIT THIS FILE, but the @GDScript.xml source instead.
|
|
.. The source is found in doc/classes or modules/<name>/doc_classes.
|
|
|
|
.. _class_@GDScript:
|
|
|
|
@GDScript
|
|
=========
|
|
|
|
Funciones GDScript Incorporadas.
|
|
|
|
Descripción
|
|
----------------------
|
|
|
|
Lista de funciones primordiales e incorporadas de GDScript. Funciones matemáticas y otras utilidades. Todo lo demás está proporcionado por objetos. (Palabras clave: incorporado, includido, funciones globales.)
|
|
|
|
Métodos
|
|
--------------
|
|
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Color<class_Color>` | :ref:`Color8<class_@GDScript_method_Color8>` **(** :ref:`int<class_int>` r8, :ref:`int<class_int>` g8, :ref:`int<class_int>` b8, :ref:`int<class_int>` a8=255 **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Color<class_Color>` | :ref:`ColorN<class_@GDScript_method_ColorN>` **(** :ref:`String<class_String>` name, :ref:`float<class_float>` alpha=1.0 **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`abs<class_@GDScript_method_abs>` **(** :ref:`float<class_float>` s **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`acos<class_@GDScript_method_acos>` **(** :ref:`float<class_float>` s **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`asin<class_@GDScript_method_asin>` **(** :ref:`float<class_float>` s **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| void | :ref:`assert<class_@GDScript_method_assert>` **(** :ref:`bool<class_bool>` condition, :ref:`String<class_String>` message="" **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`atan<class_@GDScript_method_atan>` **(** :ref:`float<class_float>` s **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`atan2<class_@GDScript_method_atan2>` **(** :ref:`float<class_float>` y, :ref:`float<class_float>` x **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Variant<class_Variant>` | :ref:`bytes2var<class_@GDScript_method_bytes2var>` **(** :ref:`PoolByteArray<class_PoolByteArray>` bytes, :ref:`bool<class_bool>` allow_objects=false **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Vector2<class_Vector2>` | :ref:`cartesian2polar<class_@GDScript_method_cartesian2polar>` **(** :ref:`float<class_float>` x, :ref:`float<class_float>` y **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`ceil<class_@GDScript_method_ceil>` **(** :ref:`float<class_float>` s **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`String<class_String>` | :ref:`char<class_@GDScript_method_char>` **(** :ref:`int<class_int>` code **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`clamp<class_@GDScript_method_clamp>` **(** :ref:`float<class_float>` value, :ref:`float<class_float>` min, :ref:`float<class_float>` max **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Variant<class_Variant>` | :ref:`convert<class_@GDScript_method_convert>` **(** :ref:`Variant<class_Variant>` what, :ref:`int<class_int>` type **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`cos<class_@GDScript_method_cos>` **(** :ref:`float<class_float>` s **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`cosh<class_@GDScript_method_cosh>` **(** :ref:`float<class_float>` s **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`db2linear<class_@GDScript_method_db2linear>` **(** :ref:`float<class_float>` db **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`int<class_int>` | :ref:`decimals<class_@GDScript_method_decimals>` **(** :ref:`float<class_float>` step **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`dectime<class_@GDScript_method_dectime>` **(** :ref:`float<class_float>` value, :ref:`float<class_float>` amount, :ref:`float<class_float>` step **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`bool<class_bool>` | :ref:`deep_equal<class_@GDScript_method_deep_equal>` **(** :ref:`Variant<class_Variant>` a, :ref:`Variant<class_Variant>` b **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`deg2rad<class_@GDScript_method_deg2rad>` **(** :ref:`float<class_float>` deg **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Object<class_Object>` | :ref:`dict2inst<class_@GDScript_method_dict2inst>` **(** :ref:`Dictionary<class_Dictionary>` dict **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`ease<class_@GDScript_method_ease>` **(** :ref:`float<class_float>` s, :ref:`float<class_float>` curve **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`exp<class_@GDScript_method_exp>` **(** :ref:`float<class_float>` s **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`floor<class_@GDScript_method_floor>` **(** :ref:`float<class_float>` s **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`fmod<class_@GDScript_method_fmod>` **(** :ref:`float<class_float>` a, :ref:`float<class_float>` b **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`fposmod<class_@GDScript_method_fposmod>` **(** :ref:`float<class_float>` a, :ref:`float<class_float>` b **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`FuncRef<class_FuncRef>` | :ref:`funcref<class_@GDScript_method_funcref>` **(** :ref:`Object<class_Object>` instance, :ref:`String<class_String>` funcname **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Array<class_Array>` | :ref:`get_stack<class_@GDScript_method_get_stack>` **(** **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`int<class_int>` | :ref:`hash<class_@GDScript_method_hash>` **(** :ref:`Variant<class_Variant>` var **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Dictionary<class_Dictionary>` | :ref:`inst2dict<class_@GDScript_method_inst2dict>` **(** :ref:`Object<class_Object>` inst **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Object<class_Object>` | :ref:`instance_from_id<class_@GDScript_method_instance_from_id>` **(** :ref:`int<class_int>` instance_id **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`inverse_lerp<class_@GDScript_method_inverse_lerp>` **(** :ref:`float<class_float>` from, :ref:`float<class_float>` to, :ref:`float<class_float>` weight **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`bool<class_bool>` | :ref:`is_equal_approx<class_@GDScript_method_is_equal_approx>` **(** :ref:`float<class_float>` a, :ref:`float<class_float>` b **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`bool<class_bool>` | :ref:`is_inf<class_@GDScript_method_is_inf>` **(** :ref:`float<class_float>` s **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`bool<class_bool>` | :ref:`is_instance_valid<class_@GDScript_method_is_instance_valid>` **(** :ref:`Object<class_Object>` instance **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`bool<class_bool>` | :ref:`is_nan<class_@GDScript_method_is_nan>` **(** :ref:`float<class_float>` s **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`bool<class_bool>` | :ref:`is_zero_approx<class_@GDScript_method_is_zero_approx>` **(** :ref:`float<class_float>` s **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`int<class_int>` | :ref:`len<class_@GDScript_method_len>` **(** :ref:`Variant<class_Variant>` var **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Variant<class_Variant>` | :ref:`lerp<class_@GDScript_method_lerp>` **(** :ref:`Variant<class_Variant>` from, :ref:`Variant<class_Variant>` to, :ref:`float<class_float>` weight **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`lerp_angle<class_@GDScript_method_lerp_angle>` **(** :ref:`float<class_float>` from, :ref:`float<class_float>` to, :ref:`float<class_float>` weight **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`linear2db<class_@GDScript_method_linear2db>` **(** :ref:`float<class_float>` nrg **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Resource<class_Resource>` | :ref:`load<class_@GDScript_method_load>` **(** :ref:`String<class_String>` path **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`log<class_@GDScript_method_log>` **(** :ref:`float<class_float>` s **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`max<class_@GDScript_method_max>` **(** :ref:`float<class_float>` a, :ref:`float<class_float>` b **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`min<class_@GDScript_method_min>` **(** :ref:`float<class_float>` a, :ref:`float<class_float>` b **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`move_toward<class_@GDScript_method_move_toward>` **(** :ref:`float<class_float>` from, :ref:`float<class_float>` to, :ref:`float<class_float>` delta **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`int<class_int>` | :ref:`nearest_po2<class_@GDScript_method_nearest_po2>` **(** :ref:`int<class_int>` value **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`int<class_int>` | :ref:`ord<class_@GDScript_method_ord>` **(** :ref:`String<class_String>` char **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Variant<class_Variant>` | :ref:`parse_json<class_@GDScript_method_parse_json>` **(** :ref:`String<class_String>` json **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Vector2<class_Vector2>` | :ref:`polar2cartesian<class_@GDScript_method_polar2cartesian>` **(** :ref:`float<class_float>` r, :ref:`float<class_float>` th **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`int<class_int>` | :ref:`posmod<class_@GDScript_method_posmod>` **(** :ref:`int<class_int>` a, :ref:`int<class_int>` b **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`pow<class_@GDScript_method_pow>` **(** :ref:`float<class_float>` base, :ref:`float<class_float>` exp **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Resource<class_Resource>` | :ref:`preload<class_@GDScript_method_preload>` **(** :ref:`String<class_String>` path **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| void | :ref:`print<class_@GDScript_method_print>` **(** ... **)** |vararg| |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| void | :ref:`print_debug<class_@GDScript_method_print_debug>` **(** ... **)** |vararg| |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| void | :ref:`print_stack<class_@GDScript_method_print_stack>` **(** **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| void | :ref:`printerr<class_@GDScript_method_printerr>` **(** ... **)** |vararg| |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| void | :ref:`printraw<class_@GDScript_method_printraw>` **(** ... **)** |vararg| |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| void | :ref:`prints<class_@GDScript_method_prints>` **(** ... **)** |vararg| |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| void | :ref:`printt<class_@GDScript_method_printt>` **(** ... **)** |vararg| |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| void | :ref:`push_error<class_@GDScript_method_push_error>` **(** :ref:`String<class_String>` message **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| void | :ref:`push_warning<class_@GDScript_method_push_warning>` **(** :ref:`String<class_String>` message **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`rad2deg<class_@GDScript_method_rad2deg>` **(** :ref:`float<class_float>` rad **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`rand_range<class_@GDScript_method_rand_range>` **(** :ref:`float<class_float>` from, :ref:`float<class_float>` to **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Array<class_Array>` | :ref:`rand_seed<class_@GDScript_method_rand_seed>` **(** :ref:`int<class_int>` seed **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`randf<class_@GDScript_method_randf>` **(** **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`int<class_int>` | :ref:`randi<class_@GDScript_method_randi>` **(** **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| void | :ref:`randomize<class_@GDScript_method_randomize>` **(** **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Array<class_Array>` | :ref:`range<class_@GDScript_method_range>` **(** ... **)** |vararg| |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`range_lerp<class_@GDScript_method_range_lerp>` **(** :ref:`float<class_float>` value, :ref:`float<class_float>` istart, :ref:`float<class_float>` istop, :ref:`float<class_float>` ostart, :ref:`float<class_float>` ostop **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`round<class_@GDScript_method_round>` **(** :ref:`float<class_float>` s **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| void | :ref:`seed<class_@GDScript_method_seed>` **(** :ref:`int<class_int>` seed **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`sign<class_@GDScript_method_sign>` **(** :ref:`float<class_float>` s **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`sin<class_@GDScript_method_sin>` **(** :ref:`float<class_float>` s **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`sinh<class_@GDScript_method_sinh>` **(** :ref:`float<class_float>` s **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`smoothstep<class_@GDScript_method_smoothstep>` **(** :ref:`float<class_float>` from, :ref:`float<class_float>` to, :ref:`float<class_float>` s **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`sqrt<class_@GDScript_method_sqrt>` **(** :ref:`float<class_float>` s **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`int<class_int>` | :ref:`step_decimals<class_@GDScript_method_step_decimals>` **(** :ref:`float<class_float>` step **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`stepify<class_@GDScript_method_stepify>` **(** :ref:`float<class_float>` s, :ref:`float<class_float>` step **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`String<class_String>` | :ref:`str<class_@GDScript_method_str>` **(** ... **)** |vararg| |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Variant<class_Variant>` | :ref:`str2var<class_@GDScript_method_str2var>` **(** :ref:`String<class_String>` string **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`tan<class_@GDScript_method_tan>` **(** :ref:`float<class_float>` s **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`tanh<class_@GDScript_method_tanh>` **(** :ref:`float<class_float>` s **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`String<class_String>` | :ref:`to_json<class_@GDScript_method_to_json>` **(** :ref:`Variant<class_Variant>` var **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`bool<class_bool>` | :ref:`type_exists<class_@GDScript_method_type_exists>` **(** :ref:`String<class_String>` type **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`int<class_int>` | :ref:`typeof<class_@GDScript_method_typeof>` **(** :ref:`Variant<class_Variant>` what **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`String<class_String>` | :ref:`validate_json<class_@GDScript_method_validate_json>` **(** :ref:`String<class_String>` json **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`PoolByteArray<class_PoolByteArray>` | :ref:`var2bytes<class_@GDScript_method_var2bytes>` **(** :ref:`Variant<class_Variant>` var, :ref:`bool<class_bool>` full_objects=false **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`String<class_String>` | :ref:`var2str<class_@GDScript_method_var2str>` **(** :ref:`Variant<class_Variant>` var **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`WeakRef<class_WeakRef>` | :ref:`weakref<class_@GDScript_method_weakref>` **(** :ref:`Object<class_Object>` obj **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`wrapf<class_@GDScript_method_wrapf>` **(** :ref:`float<class_float>` value, :ref:`float<class_float>` min, :ref:`float<class_float>` max **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`int<class_int>` | :ref:`wrapi<class_@GDScript_method_wrapi>` **(** :ref:`int<class_int>` value, :ref:`int<class_int>` min, :ref:`int<class_int>` max **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`GDScriptFunctionState<class_GDScriptFunctionState>` | :ref:`yield<class_@GDScript_method_yield>` **(** :ref:`Object<class_Object>` object=null, :ref:`String<class_String>` signal="" **)** |
|
|
+-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
|
|
Constantes
|
|
--------------------
|
|
|
|
.. _class_@GDScript_constant_PI:
|
|
|
|
.. _class_@GDScript_constant_TAU:
|
|
|
|
.. _class_@GDScript_constant_INF:
|
|
|
|
.. _class_@GDScript_constant_NAN:
|
|
|
|
- **PI** = **3.141593** --- Constante que representa cuántas veces el diámetro de un círculo se encuentra contenido en su perímetro.Esto equivale a ``TAU / 2``.
|
|
|
|
- **TAU** = **6.283185** --- The circle constant, the circumference of the unit circle in radians. This is equivalent to ``PI * 2``, or 360 degrees in rotations.
|
|
|
|
- **INF** = **inf** --- Positive floating-point infinity. This is the result of floating-point division when the divisor is ``0.0``. For negative infinity, use ``-INF``. Dividing by ``-0.0`` will result in negative infinity if the numerator is positive, so dividing by ``0.0`` is not the same as dividing by ``-0.0`` (despite ``0.0 == -0.0`` returning ``true``).
|
|
|
|
\ **Note:** Numeric infinity is only a concept with floating-point numbers, and has no equivalent for integers. Dividing an integer number by ``0`` will not result in :ref:`INF<class_@GDScript_constant_INF>` and will result in a run-time error instead.
|
|
|
|
- **NAN** = **nan** --- "Not a Number", an invalid floating-point value. :ref:`NAN<class_@GDScript_constant_NAN>` has special properties, including that it is not equal to itself (``NAN == NAN`` returns ``false``). It is output by some invalid operations, such as dividing floating-point ``0.0`` by ``0.0``.
|
|
|
|
\ **Note:** "Not a Number" is only a concept with floating-point numbers, and has no equivalent for integers. Dividing an integer ``0`` by ``0`` will not result in :ref:`NAN<class_@GDScript_constant_NAN>` and will result in a run-time error instead.
|
|
|
|
Descripciones de Métodos
|
|
------------------------------------------------
|
|
|
|
.. _class_@GDScript_method_Color8:
|
|
|
|
- :ref:`Color<class_Color>` **Color8** **(** :ref:`int<class_int>` r8, :ref:`int<class_int>` g8, :ref:`int<class_int>` b8, :ref:`int<class_int>` a8=255 **)**
|
|
|
|
Devuelve un color construido con los enteros positivos de los canales rojo, verde, azul y alfa. Cada canal tiene 8 bits de informacion con un rango entre 0 y 255.
|
|
|
|
\ ``r8`` canal rojo
|
|
|
|
\ ``g8`` canal verde
|
|
|
|
\ ``b8`` canal azul
|
|
|
|
\ ``a8`` canal alfa
|
|
|
|
::
|
|
|
|
rojo = Color8(255, 0, 0)
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_ColorN:
|
|
|
|
- :ref:`Color<class_Color>` **ColorN** **(** :ref:`String<class_String>` name, :ref:`float<class_float>` alpha=1.0 **)**
|
|
|
|
Devuelve un color según el ``name`` estandarizado con el ``alpha`` que va de 0 a 1.
|
|
|
|
::
|
|
|
|
rojo = ColorN("red", 1)
|
|
|
|
Los nombres de los colores soportados son los mismos que las constantes definidas en :ref:`Color<class_Color>`.
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_abs:
|
|
|
|
- :ref:`float<class_float>` **abs** **(** :ref:`float<class_float>` s **)**
|
|
|
|
Devuelve el valor absoluto del parámetro ``s`` (es decir, un valor positivo).
|
|
|
|
::
|
|
|
|
a = abs(-1) # a es 1
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_acos:
|
|
|
|
- :ref:`float<class_float>` **acos** **(** :ref:`float<class_float>` s **)**
|
|
|
|
Devuelve el arco coseno de ``s`` en radianes. Se usa para obtener el ángulo del coseno de ``s``. ``s`` debe estar entre ``-1.0`` y ``1.0`` (inclusive), en otro caso, :ref:`acos<class_@GDScript_method_acos>` devolverá :ref:`NAN<class_@GDScript_constant_NAN>`.
|
|
|
|
::
|
|
|
|
# c es 0.523599 o 30 grados si se convierte con rad2deg(s)
|
|
c = acos(0.866025)
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_asin:
|
|
|
|
- :ref:`float<class_float>` **asin** **(** :ref:`float<class_float>` s **)**
|
|
|
|
Devuelve el arcoseno de ``s`` en radianes. Se usa para obtener el ángulo del seno de ``s``. ``s`` debe estar entre ``-1.0`` y ``1.0`` (inclusive), en otro caso, :ref:`asin<class_@GDScript_method_asin>` devolverá :ref:`NAN<class_@GDScript_constant_NAN>`.
|
|
|
|
::
|
|
|
|
# s es 0.523599 o 30 grados si se convierte conrad2deg(s)
|
|
s = asin(0.5)
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_assert:
|
|
|
|
- void **assert** **(** :ref:`bool<class_bool>` condition, :ref:`String<class_String>` message="" **)**
|
|
|
|
Afirma que la condición ``condition`` es ``true``. Si la condición ``condition`` es ``false``, se genera un error. Cuando se ejecuta desde el editor, el proyecto en ejecución también se pausará hasta que lo reanude. Esto se puede utilizar como una forma más restrictiva de :ref:`push_error<class_@GDScript_method_push_error>` para informar errores a los desarrolladores de proyectos o usuarios de complementos.
|
|
|
|
\ **Nota:** Por razones de rendimiento, el código dentro de :ref:`assert<class_@GDScript_method_assert>` solo se ejecuta en compilaciones de depuración o cuando se ejecuta el proyecto desde el editor. No incluya código que tenga efectos secundarios en una llamada a :ref:`assert<class_@GDScript_method_assert>`. En otro caso, el proyecto se comportará de manera diferente cuando se exporta en modo de lanzamiento.
|
|
|
|
El argumento opcional ``message``, si es dado, se muestra además del mensaje genérico "Assertion failed". Puede usar esto para proporcionar detalles adicionales sobre por qué la afirmación falló.
|
|
|
|
::
|
|
|
|
# Imagine que siempre quisiéramos que la velocidad (speed) esté entre 0 y 20
|
|
var speed = -10
|
|
assert(speed < 20) # Verdadero, el programa continuará
|
|
assert(speed >= 0) # Falso, el programa se detendrá
|
|
assert(speed >= 0 and speed < 20) # También puedes combinar las dos declaraciones condicionales en un sola comprobación
|
|
assert(speed < 20, "speed = %f, pero el límite de velocidad es 20" % speed) # Muestra un mensaje detallado
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_atan:
|
|
|
|
- :ref:`float<class_float>` **atan** **(** :ref:`float<class_float>` s **)**
|
|
|
|
Devuelve el arco tangente de ``s`` en radianes. Úsalo para obtener el ángulo de la tangente de un ángulo en trigonometría: ``atan(tan(angle)) == angle``.
|
|
|
|
El método no puede saber en qué cuadrante el ángulo se encuentra. Vea :ref:`atan2<class_@GDScript_method_atan2>` si tienes tanto ``y`` como ``x``\
|
|
|
|
::
|
|
|
|
a = atan(0.5) # a is 0.463648
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_atan2:
|
|
|
|
- :ref:`float<class_float>` **atan2** **(** :ref:`float<class_float>` y, :ref:`float<class_float>` x **)**
|
|
|
|
Devuelve la arcotangente de ``y/x`` en radianes. Usalo para obtener el angulo de la tangente ``y/x``. Para obtener el valor, el metodo tiene en cuenta el signo de ambos argumentos para determinar el cuadrante.
|
|
|
|
Nota importante: La coordenada Y es la primera, por convención.
|
|
|
|
::
|
|
|
|
a = atan2(0, -1) # a is 3.141593
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_bytes2var:
|
|
|
|
- :ref:`Variant<class_Variant>` **bytes2var** **(** :ref:`PoolByteArray<class_PoolByteArray>` bytes, :ref:`bool<class_bool>` allow_objects=false **)**
|
|
|
|
Decodifica una array de bytes a un valor. Cuando ``allow_objects`` es ``true`` se permite la decodificación de objetos.
|
|
|
|
\ **Aviso**\ El objeto deserializado puede contener código que se pueda ejecutar. No utilice esta opción si el objeto serializado proviene de fuentes en las que no confie para evitar posibles amenazas a la seguridad (ejecución remota de código).
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_cartesian2polar:
|
|
|
|
- :ref:`Vector2<class_Vector2>` **cartesian2polar** **(** :ref:`float<class_float>` x, :ref:`float<class_float>` y **)**
|
|
|
|
Convierte un punto 2D expresado en el sistema de coordenadas cartesianas (ejes X e Y) en el sistema de coordenadas polares (una distancia del origen y un ángulo).
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_ceil:
|
|
|
|
- :ref:`float<class_float>` **ceil** **(** :ref:`float<class_float>` s **)**
|
|
|
|
Redondea ``s`` por encima, devolviendo el valor entero más pequeño que no es menor que ``s``.
|
|
|
|
::
|
|
|
|
a = ceil(1.45) # a es 2
|
|
a = ceil(1.001) # a es 2
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_char:
|
|
|
|
- :ref:`String<class_String>` **char** **(** :ref:`int<class_int>` code **)**
|
|
|
|
Devuelve un carácter como una cadena de tipo Unicode (el cual es compatible con el código ASCII).
|
|
|
|
::
|
|
|
|
a = char(65) # a es "A"
|
|
a = char(65 + 32) # a es "a"
|
|
a = char(8364) # a es "€"
|
|
|
|
Esto es el inverso de :ref:`ord<class_@GDScript_method_ord>`.
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_clamp:
|
|
|
|
- :ref:`float<class_float>` **clamp** **(** :ref:`float<class_float>` value, :ref:`float<class_float>` min, :ref:`float<class_float>` max **)**
|
|
|
|
Acota ``value`` y devuelve un valor que no es menor que ``min`` y no mayor que ``max``\
|
|
|
|
::
|
|
|
|
a = clamp(1000, 1, 20) # a es 20
|
|
a = clamp(-10, 1, 20) # a es 1
|
|
a = clamp(15, 1, 20) # a es 15
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_convert:
|
|
|
|
- :ref:`Variant<class_Variant>` **convert** **(** :ref:`Variant<class_Variant>` what, :ref:`int<class_int>` type **)**
|
|
|
|
Convierte de un tipo a otro de la mejor manera posible. El parámetro ``type`` utiliza los valores de :ref:`Variant.Type<enum_@GlobalScope_Variant.Type>`.
|
|
|
|
::
|
|
|
|
a = Vector2(1, 0)
|
|
# Imprime 1
|
|
print(a.length())
|
|
a = convert(a, TYPE_STRING)
|
|
# Imprime 6 porque "(1, 0)" es una string de 6 caracteres. Nota que hay un espacio entre la , y el 0.
|
|
print(a.length())
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_cos:
|
|
|
|
- :ref:`float<class_float>` **cos** **(** :ref:`float<class_float>` s **)**
|
|
|
|
Devuelve el coseno del ángulo ``s`` en radianes.
|
|
|
|
::
|
|
|
|
a = cos(TAU) # a es 1.0
|
|
a = cos(PI) # a es -1.0
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_cosh:
|
|
|
|
- :ref:`float<class_float>` **cosh** **(** :ref:`float<class_float>` s **)**
|
|
|
|
Devuelve el coseno hiperbólico de ``s`` en radianes.
|
|
|
|
::
|
|
|
|
print(cosh(1)) # Imprime 1.543081
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_db2linear:
|
|
|
|
- :ref:`float<class_float>` **db2linear** **(** :ref:`float<class_float>` db **)**
|
|
|
|
Convierte de decibeles a energía lineal (audio).
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_decimals:
|
|
|
|
- :ref:`int<class_int>` **decimals** **(** :ref:`float<class_float>` step **)**
|
|
|
|
Alias obsoleto del :ref:`step_decimals<class_@GDScript_method_step_decimals>`.
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_dectime:
|
|
|
|
- :ref:`float<class_float>` **dectime** **(** :ref:`float<class_float>` value, :ref:`float<class_float>` amount, :ref:`float<class_float>` step **)**
|
|
|
|
**Nota:** ``dectime`` ha quedado obsoleto y se eliminará en Godot 4.0, por favor utilice :ref:`move_toward<class_@GDScript_method_move_toward>` en su lugar.
|
|
|
|
Devuelve el resultado de ``value`` menos ``step`` \* ``amount``.
|
|
|
|
::
|
|
|
|
a = dectime(60, 10, 0.1)) # a es 59.0
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_deep_equal:
|
|
|
|
- :ref:`bool<class_bool>` **deep_equal** **(** :ref:`Variant<class_Variant>` a, :ref:`Variant<class_Variant>` b **)**
|
|
|
|
Compares two values by checking their actual contents, recursing into any `Array` or `Dictionary` up to its deepest level.
|
|
|
|
This compares to ``==`` in a number of ways:
|
|
|
|
- For ``null``, ``int``, ``float``, ``String``, ``Object`` and ``RID`` both ``deep_equal`` and ``==`` work the same.
|
|
|
|
- For ``Dictionary``, ``==`` considers equality if, and only if, both variables point to the very same ``Dictionary``, with no recursion or awareness of the contents at all.
|
|
|
|
- For ``Array``, ``==`` considers equality if, and only if, each item in the first ``Array`` is equal to its counterpart in the second ``Array``, as told by ``==`` itself. That implies that ``==`` recurses into ``Array``, but not into ``Dictionary``.
|
|
|
|
In short, whenever a ``Dictionary`` is potentially involved, if you want a true content-aware comparison, you have to use ``deep_equal``.
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_deg2rad:
|
|
|
|
- :ref:`float<class_float>` **deg2rad** **(** :ref:`float<class_float>` deg **)**
|
|
|
|
Convierte un ángulo expresado en grados a radianes.
|
|
|
|
::
|
|
|
|
# r es 3.141593
|
|
r = deg2rad(180)
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_dict2inst:
|
|
|
|
- :ref:`Object<class_Object>` **dict2inst** **(** :ref:`Dictionary<class_Dictionary>` dict **)**
|
|
|
|
Convierte un diccionario (que fue creado previamente con :ref:`inst2dict<class_@GDScript_method_inst2dict>`) de nuevo a una instancia. Es útil para deserializar.
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_ease:
|
|
|
|
- :ref:`float<class_float>` **ease** **(** :ref:`float<class_float>` s, :ref:`float<class_float>` curve **)**
|
|
|
|
Returns an "eased" value of ``x`` based on an easing function defined with ``curve``. This easing function is based on an exponent. The ``curve`` can be any floating-point number, with specific values leading to the following behaviors:
|
|
|
|
::
|
|
|
|
- Lower than -1.0 (exclusive): Ease in-out
|
|
- 1.0: Linear
|
|
- Between -1.0 and 0.0 (exclusive): Ease out-in
|
|
- 0.0: Constant
|
|
- Between 0.0 to 1.0 (exclusive): Ease out
|
|
- 1.0: Linear
|
|
- Greater than 1.0 (exclusive): Ease in
|
|
|
|
\ `ease() curve values cheatsheet <https://raw.githubusercontent.com/godotengine/godot-docs/3.4/img/ease_cheatsheet.png>`__\
|
|
|
|
See also :ref:`smoothstep<class_@GDScript_method_smoothstep>`. If you need to perform more advanced transitions, use :ref:`Tween<class_Tween>` or :ref:`AnimationPlayer<class_AnimationPlayer>`.
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_exp:
|
|
|
|
- :ref:`float<class_float>` **exp** **(** :ref:`float<class_float>` s **)**
|
|
|
|
La función exponencial natural. Eleva la constante matemática **e** a la potencia de ``s`` y la devuelve.
|
|
|
|
\ **e** tiene un valor aproximado de 2,71828, y puede obtenerse con ``exp(1)``.
|
|
|
|
Para los exponentes a otras bases se utiliza el método :ref:`pow<class_@GDScript_method_pow>`.
|
|
|
|
::
|
|
|
|
a = exp(2) # Aproximadamente 7.39
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_floor:
|
|
|
|
- :ref:`float<class_float>` **floor** **(** :ref:`float<class_float>` s **)**
|
|
|
|
Redondea ``s`` por debajo, devolviendo el número entero más grande que no es mayor que ``s``.
|
|
|
|
::
|
|
|
|
a = floor(2.45) # a es 2.0
|
|
a = floor(2.99) # a es 2.0
|
|
a = floor(-2.99) # a es -3.0
|
|
|
|
Véase también :ref:`ceil<class_@GDScript_method_ceil>`, :ref:`round<class_@GDScript_method_round>`, :ref:`stepify<class_@GDScript_method_stepify>`, y :ref:`int<class_int>`.
|
|
|
|
\ **Nota:** Este método devuelve un valor en punto flotante. Si necesita uno entero y ``s`` no lo es, use ``int(s)`` directamente.
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_fmod:
|
|
|
|
- :ref:`float<class_float>` **fmod** **(** :ref:`float<class_float>` a, :ref:`float<class_float>` b **)**
|
|
|
|
Devuelve el resto en punto flotante de ``a/b``, manteniendo el signo de ``a``.
|
|
|
|
::
|
|
|
|
r = fmod(7, 5.5) # r es 1.5
|
|
|
|
Para la operación módulo de números enteros, utilice el operador %.
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_fposmod:
|
|
|
|
- :ref:`float<class_float>` **fposmod** **(** :ref:`float<class_float>` a, :ref:`float<class_float>` b **)**
|
|
|
|
Devuelve el módulo en punto flotante de ``a/b`` que envuelve por igual en positivo y en negativo.
|
|
|
|
::
|
|
|
|
for i in 7:
|
|
var x = 0.5 * i - 1.5
|
|
print("%4.1f %4.1f %4.1f" % [x, fmod(x, 1.5), fposmod(x, 1.5)])
|
|
|
|
Produce:
|
|
|
|
::
|
|
|
|
-1.5 -0.0 0.0
|
|
-1.0 -1.0 0.5
|
|
-0.5 -0.5 1.0
|
|
0.0 0.0 0.0
|
|
0.5 0.5 0.5
|
|
1.0 1.0 1.0
|
|
1.5 0.0 0.0
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_funcref:
|
|
|
|
- :ref:`FuncRef<class_FuncRef>` **funcref** **(** :ref:`Object<class_Object>` instance, :ref:`String<class_String>` funcname **)**
|
|
|
|
Devuelve una referencia a la función especificada ``funcname`` en el nodo ``instance``. Como las funciones no son objetos de primera clase en GDscript, usa ``funcref`` para almacenar una :ref:`FuncRef<class_FuncRef>` en una variable y llamarla después.
|
|
|
|
::
|
|
|
|
func foo():
|
|
return("bar")
|
|
|
|
a = funcref(self, "foo")
|
|
print(a.call_func()) # Imprime bar
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_get_stack:
|
|
|
|
- :ref:`Array<class_Array>` **get_stack** **(** **)**
|
|
|
|
Devuelve un conjunto de diccionarios que representan la pila de llamadas actual.
|
|
|
|
::
|
|
|
|
func _ready():
|
|
foo()
|
|
|
|
func foo():
|
|
bar()
|
|
|
|
func bar():
|
|
print(get_stack())
|
|
|
|
# Esto imprimirá
|
|
|
|
::
|
|
|
|
[{function:bar, line:12, source:res://script.gd}, {function:foo, line:9, source:res://script.gd}, {function:_ready, line:6, source:res://script.gd}]
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_hash:
|
|
|
|
- :ref:`int<class_int>` **hash** **(** :ref:`Variant<class_Variant>` var **)**
|
|
|
|
Devuelve el hash entero de la variable pasada.
|
|
|
|
::
|
|
|
|
print(hash("a)) # Imprime 177670
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_inst2dict:
|
|
|
|
- :ref:`Dictionary<class_Dictionary>` **inst2dict** **(** :ref:`Object<class_Object>` inst **)**
|
|
|
|
Devuelve la instancia pasada convertida en un diccionario (útil para serializar).
|
|
|
|
::
|
|
|
|
var foo = "bar"
|
|
func _ready():
|
|
var d = inst2dict(self)
|
|
print(d.keys())
|
|
print(d.values())
|
|
|
|
Imprime:
|
|
|
|
::
|
|
|
|
[@subpath, @path, foo]
|
|
[, res://test.gd, bar]
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_instance_from_id:
|
|
|
|
- :ref:`Object<class_Object>` **instance_from_id** **(** :ref:`int<class_int>` instance_id **)**
|
|
|
|
Devuelve el objeto que corresponde a ``instance_id``. Todos los Objetos tienen un ID de instancia único.
|
|
|
|
::
|
|
|
|
var foo = "bar"
|
|
func _ready():
|
|
var id = get_instance_id()
|
|
var inst = instance_from_id(id)
|
|
print(inst.foo) # Prints bar
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_inverse_lerp:
|
|
|
|
- :ref:`float<class_float>` **inverse_lerp** **(** :ref:`float<class_float>` from, :ref:`float<class_float>` to, :ref:`float<class_float>` weight **)**
|
|
|
|
Devuelve un valor normalizado considerando el rango dado. Esto es lo contrario a :ref:`lerp<class_@GDScript_method_lerp>`.
|
|
|
|
::
|
|
|
|
var mitad = lerp(20, 30, 0.75)
|
|
# `mitad` es ahora 27.5.
|
|
# Ahora, vamos a suponer que hemos olvidado el ratio original y queremos volver a atras.
|
|
var ratio = inverse_lerp(20, 30, 27.5)
|
|
# `ratio` es ahora 0.75.
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_is_equal_approx:
|
|
|
|
- :ref:`bool<class_bool>` **is_equal_approx** **(** :ref:`float<class_float>` a, :ref:`float<class_float>` b **)**
|
|
|
|
Devuelve ``true`` si ``a`` y ``b`` son aproximadamente iguales entre sí.
|
|
|
|
Aquí, aproximadamente igual significa que ``a`` y ``b`` están dentro de una pequeña épsilon interna de cada uno, que escala con la magnitud de los números.
|
|
|
|
Los valores infinitos del mismo signo se consideran iguales.
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_is_inf:
|
|
|
|
- :ref:`bool<class_bool>` **is_inf** **(** :ref:`float<class_float>` s **)**
|
|
|
|
Devuelve si ``s`` es un valor de infinito (positivo o negativo).
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_is_instance_valid:
|
|
|
|
- :ref:`bool<class_bool>` **is_instance_valid** **(** :ref:`Object<class_Object>` instance **)**
|
|
|
|
Devuelve si ``instance`` es un objeto válido (por ejemplo, no ha sido borrado de la memoria).
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_is_nan:
|
|
|
|
- :ref:`bool<class_bool>` **is_nan** **(** :ref:`float<class_float>` s **)**
|
|
|
|
Devuelve si ``s`` es un valor NaN ("Not a Number" o inválido).
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_is_zero_approx:
|
|
|
|
- :ref:`bool<class_bool>` **is_zero_approx** **(** :ref:`float<class_float>` s **)**
|
|
|
|
Devuelve ``true`` si ``s`` es cero o casi cero.
|
|
|
|
Este método es más rápido que el uso de :ref:`is_equal_approx<class_@GDScript_method_is_equal_approx>` con un valor como cero.
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_len:
|
|
|
|
- :ref:`int<class_int>` **len** **(** :ref:`Variant<class_Variant>` var **)**
|
|
|
|
Devuelve la longitud de la variable ``var``. La longitud es el número de caracteres de la cadena, el número de elementos de la matriz, el tamaño del diccionario, etc.
|
|
|
|
\ **Nota:** Genera un error fatal si la variable no puede proporcionar una longitud.
|
|
|
|
::
|
|
|
|
a = [1, 2, 3, 4]
|
|
len(a) # Devuelve 4
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_lerp:
|
|
|
|
- :ref:`Variant<class_Variant>` **lerp** **(** :ref:`Variant<class_Variant>` from, :ref:`Variant<class_Variant>` to, :ref:`float<class_float>` weight **)**
|
|
|
|
Interpola linealmente entre dos valores por un valor normalizado. Esto es la función inversa de :ref:`inverse_lerp<class_@GDScript_method_inverse_lerp>`.
|
|
|
|
Si los argumentos ``from`` y ``to`` son de tipo :ref:`int<class_int>` o :ref:`float<class_float>`, el valor devuelto es un :ref:`float<class_float>`.
|
|
|
|
Si ambos son del mismo tipo de vector (:ref:`Vector2<class_Vector2>`, :ref:`Vector3<class_Vector3>` o :ref:`Color<class_Color>`), el valor devuelto será del mismo tipo ,(``lerp`` entonces llama al método ``linear_interpolate`` del tipo de vector).
|
|
|
|
::
|
|
|
|
lerp(0, 4, 0.75) # Devuelve 3.0
|
|
lerp(Vector2(1, 5), Vector2(3, 2), 0.5) # Devuelve Vector2(2, 3.5)
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_lerp_angle:
|
|
|
|
- :ref:`float<class_float>` **lerp_angle** **(** :ref:`float<class_float>` from, :ref:`float<class_float>` to, :ref:`float<class_float>` weight **)**
|
|
|
|
Interpola linealmente entre dos ángulos (en radianes) por un valor normalizado.
|
|
|
|
Similar al :ref:`lerp<class_@GDScript_method_lerp>`, pero interpola correctamente cuando los ángulos se envuelven alrededor de :ref:`TAU<class_@GDScript_constant_TAU>`.
|
|
|
|
::
|
|
|
|
extends Sprite
|
|
var elapsed = 0.0
|
|
func _process(delta):
|
|
var min_angle = deg2rad(0.0)
|
|
var max_angle = deg2rad(90.0)
|
|
rotation = lerp_angle(min_angle, max_angle, elapsed)
|
|
elapsed += delta
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_linear2db:
|
|
|
|
- :ref:`float<class_float>` **linear2db** **(** :ref:`float<class_float>` nrg **)**
|
|
|
|
Convierte la energia lineal a decibelios (audio). Esto puede ser utilizado para implementar sliders de volumen que se comporten de forma esperada (ya que el volumen no es lineal). Ejemplo:
|
|
|
|
::
|
|
|
|
# "Slider" se refiere a un nodo que hereda Rango de un HSlider o VSlider.
|
|
# Su rango debe ser configurado desde 0 a 1.
|
|
# Cambia el nombre del bus if quieres cambiar el volumen de solo un bus especifico.
|
|
AudioServer.set_bus_volume_db(AudioServer.get_bus_index("Master"), linear2db($Slider.value))
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_load:
|
|
|
|
- :ref:`Resource<class_Resource>` **load** **(** :ref:`String<class_String>` path **)**
|
|
|
|
Carga un recurso del sistema de archivos ubicado en ``path``. El recurso es cargado en la llamada al método (a menos que ya esté referenciado en otro lugar, por ejemplo, en otro script o en la escena), lo que puede causar un ligero retraso, especialmente al cargar escenas. Para evitar retrasos innecesarios al cargar algo varias veces, almacena el recurso en una variable o utiliza :ref:`preload<class_@GDScript_method_preload>`.
|
|
|
|
\ **Nota:** Las rutas de los recursos pueden obtenerse haciendo clic derecho sobre un recurso en la pestaña FileSystem y eligiendo "Copy Path" o arrastrando el archivo de la pestaña FileSystem al script.
|
|
|
|
::
|
|
|
|
# Carga una escena llamada main localizada en la raíz del directorio del proyecto y la almacena en caché en una variable.
|
|
var main = load("res://main.tscn") # main contendrá un recurso PackedScene.
|
|
|
|
\ **Importante:** La ruta debe ser absoluta, una ruta local solo devolverá ``null``.
|
|
|
|
Este método es una versión simplificada de :ref:`ResourceLoader.load<class_ResourceLoader_method_load>`, el cual puede ser usado en escenarios más avanzados
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_log:
|
|
|
|
- :ref:`float<class_float>` **log** **(** :ref:`float<class_float>` s **)**
|
|
|
|
Logaritmo natural. La cantidad de tiempo necesaria para alcanzar un cierto nivel de crecimiento continuo.
|
|
|
|
\ **Nota:** Esto no es lo mismo que la función "log" de la mayoría de las calculadoras, que utiliza un logaritmo de base 10.
|
|
|
|
::
|
|
|
|
log(10) # Devuelve 2.302585
|
|
|
|
\ **Nota:** El logaritmo de ``0`` devuelve ``-inf``, mientras que los valores negativos devuelven ``-nan``.
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_max:
|
|
|
|
- :ref:`float<class_float>` **max** **(** :ref:`float<class_float>` a, :ref:`float<class_float>` b **)**
|
|
|
|
Devuelve el máximo de dos valores.
|
|
|
|
::
|
|
|
|
max(1, 2) # Devuelve 2
|
|
max(-3.99, -4) # Devuelve -3.99
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_min:
|
|
|
|
- :ref:`float<class_float>` **min** **(** :ref:`float<class_float>` a, :ref:`float<class_float>` b **)**
|
|
|
|
Devuelve el mínimo de dos valores.
|
|
|
|
::
|
|
|
|
min(1, 2) # Devuelve 1
|
|
min(-3.99, -4) # Devuelve -4
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_move_toward:
|
|
|
|
- :ref:`float<class_float>` **move_toward** **(** :ref:`float<class_float>` from, :ref:`float<class_float>` to, :ref:`float<class_float>` delta **)**
|
|
|
|
Mueve ``from`` hacia ``to`` por el valor ``delta``.
|
|
|
|
Usa un valor negativo de ``delta`` para mover el valor en sentido opuesto.
|
|
|
|
::
|
|
|
|
move_toward(5, 10, 4) # Devuelve 9
|
|
move_toward(10, 5, 4) # Devuelve 6
|
|
move_toward(10, 5, -1.5) # Devuelve 11.5
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_nearest_po2:
|
|
|
|
- :ref:`int<class_int>` **nearest_po2** **(** :ref:`int<class_int>` value **)**
|
|
|
|
Devuelve la potencia igual o mayor de 2 para el entero ``value``.
|
|
|
|
En otras palabras, devuelve el valor más pequeño ``a`` donde ``a = pow(2, n)`` tal que ``value <= a`` para algún entero no negativo ``n``.
|
|
|
|
::
|
|
|
|
nearest_po2(3) # Devuelve 4
|
|
nearest_po2(4) # Devuelve 4
|
|
nearest_po2(5) # Devuelve 8
|
|
|
|
nearest_po2(0) # Devuelve 0 (esto puede no ser lo que esperas)
|
|
nearest_po2(-1) # Devuelve 0 (esto puede no ser lo que esperas)
|
|
|
|
\ **ADVERTENCIA:** Debido a la forma en que se implementa, esta función devuelve ``0`` en lugar de ``1`` para valores no positivos de ``value`` (en realidad, 1 es la potencia entera más pequeña de 2).
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_ord:
|
|
|
|
- :ref:`int<class_int>` **ord** **(** :ref:`String<class_String>` char **)**
|
|
|
|
Devuelve un entero representando el caracter Unicode ``char``\
|
|
|
|
::
|
|
|
|
a = ord("A") # a es 65
|
|
a = ord("a") # a es 97
|
|
a = ord("€") # a es 8364
|
|
|
|
Este es el metodo inverso a :ref:`char<class_@GDScript_method_char>`.
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_parse_json:
|
|
|
|
- :ref:`Variant<class_Variant>` **parse_json** **(** :ref:`String<class_String>` json **)**
|
|
|
|
Parsea el texto de JSON a una variable. (Use :ref:`typeof<class_@GDScript_method_typeof>` para comprobar si el tipo de la variable es el que usted espera.)
|
|
|
|
\ **Nota:** La especificación JSON no define tipos enteros o flotantes, sino sólo un tipo *number*. Por lo tanto, el análisis sintáctico de un texto JSON convertirá todos los valores numéricos a tipo :ref:`float<class_float>`.
|
|
|
|
\ **Nota:** Los objetos JSON no conservan el orden de las claves como los diccionarios Godot, por lo tanto, no se debe confiar en que las claves estén en un cierto orden si se construye un diccionario a partir de JSON. Por el contrario, los conjuntos de JSON conservan el orden de sus elementos:
|
|
|
|
::
|
|
|
|
var p = JSON.parse('["hola", "mundo", "!"]')
|
|
if typeof(p.result) == TYPE_ARRAY:
|
|
print(p.result[0]) # Imprime 'Hola'
|
|
else:
|
|
print("resultados inesperados")
|
|
|
|
Ver también :ref:`JSON<class_JSON>` para una forma alternativa de analizar el texto de JSON.
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_polar2cartesian:
|
|
|
|
- :ref:`Vector2<class_Vector2>` **polar2cartesian** **(** :ref:`float<class_float>` r, :ref:`float<class_float>` th **)**
|
|
|
|
Convierte un punto 2D expresado en el sistema de coordenadas polares (una distancia del origen ``r`` y un ángulo ``th``) en el sistema de coordenadas cartesianas (ejes X e Y).
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_posmod:
|
|
|
|
- :ref:`int<class_int>` **posmod** **(** :ref:`int<class_int>` a, :ref:`int<class_int>` b **)**
|
|
|
|
Devuelve el módulo entero de ``a/b`` que envuelve por igual en positivo y negativo.
|
|
|
|
::
|
|
|
|
for i in range(-3, 4):
|
|
print("%2d %2d %2d" % [i, i % 3, posmod(i, 3)])
|
|
|
|
Produce:
|
|
|
|
::
|
|
|
|
-3 0 0
|
|
-2 -2 1
|
|
-1 -1 2
|
|
0 0 0
|
|
1 1 1
|
|
2 2 2
|
|
3 0 0
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_pow:
|
|
|
|
- :ref:`float<class_float>` **pow** **(** :ref:`float<class_float>` base, :ref:`float<class_float>` exp **)**
|
|
|
|
Devuelve el resultado de ``base`` elevado a la potencia ``exp``.
|
|
|
|
::
|
|
|
|
pow(2, 5) # Devuelve 32.0
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_preload:
|
|
|
|
- :ref:`Resource<class_Resource>` **preload** **(** :ref:`String<class_String>` path **)**
|
|
|
|
Devuelve un :ref:`Resource<class_Resource>` del sistema de archivos ubicado en ``path``. El recurso se carga durante el análisis sintáctico del script, es decir, se carga con el script y :ref:`preload<class_@GDScript_method_preload>` actúa efectivamente como una referencia a ese recurso. Tenga en cuenta que el método requiere una ruta constante. Si desea cargar un recurso de una ruta dinámica/variable, utilice :ref:`load<class_@GDScript_method_load>`.
|
|
|
|
\ **Nota:** Las rutas de los recursos se pueden obtener haciendo clic con el botón derecho del ratón en un recurso del Panel de activos y eligiendo "Copiar ruta" o arrastrando el archivo desde el muelle del Sistema de archivos al script.
|
|
|
|
::
|
|
|
|
# Instancia una escena
|
|
var diamante = preload("res://diamante.tscn").instance()
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_print:
|
|
|
|
- void **print** **(** ... **)** |vararg|
|
|
|
|
convierte uno o mas argumentos de cualquior tipo a una cadena de texto de la mejor manera posible, y los muestra en la consola.
|
|
|
|
::
|
|
|
|
a=[1,2,3]
|
|
print("a,"=",a)#Muestra a=[1,2,3]
|
|
|
|
\ **Note:** considera usar :ref:`push_error<class_@GDScript_method_push_error>` y :ref:`push_warning<class_@GDScript_method_push_warning>` para mostrar errores mensajes de advertencia en vez de :ref:`print<class_@GDScript_method_print>`. esto los distingue de mensajes en la consola usados por motivos de depuración, mientras muestra un trazo de cuando un error o advertencia se muestra.
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_print_debug:
|
|
|
|
- void **print_debug** **(** ... **)** |vararg|
|
|
|
|
Como :ref:`print<class_@GDScript_method_print>`, pero imprime sólo cuando se usa en modo de depuración.
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_print_stack:
|
|
|
|
- void **print_stack** **(** **)**
|
|
|
|
Imprime una registro de la pila en la ubicación del código, sólo funciona cuando se ejecuta con el depurador activado.
|
|
|
|
La salida en la consola se vería algo así:
|
|
|
|
::
|
|
|
|
Frame 0 - res://test.gd:16 in function '_process'
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_printerr:
|
|
|
|
- void **printerr** **(** ... **)** |vararg|
|
|
|
|
Imprime uno o más argumentos a strings de la mejor manera posible a la línea de error estándar.
|
|
|
|
::
|
|
|
|
printerr("Imprime a stderr")
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_printraw:
|
|
|
|
- void **printraw** **(** ... **)** |vararg|
|
|
|
|
Imprime uno o más argumentos a strings de la mejor manera posible a consola . No se añade ninguna línea nueva al final.
|
|
|
|
::
|
|
|
|
printraw("A")
|
|
printraw("B")
|
|
# Imprime AB
|
|
|
|
\ **Nota:** Debido a las limitaciones con la consola incorporada de Godot, esto sólo imprime a la terminal. Si necesita imprimir en el editor, utilice otro método, como :ref:`print<class_@GDScript_method_print>`.
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_prints:
|
|
|
|
- void **prints** **(** ... **)** |vararg|
|
|
|
|
Imprime uno o más argumentos en la consola con un espacio entre cada argumento.
|
|
|
|
::
|
|
|
|
prints("A", "B", "C") # Imprime A B C
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_printt:
|
|
|
|
- void **printt** **(** ... **)** |vararg|
|
|
|
|
Imprime uno o más argumentos en la consola con un tabulador entre cada argumento.
|
|
|
|
::
|
|
|
|
printt("A","B","C") # Imprime A\ B\ C
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_push_error:
|
|
|
|
- void **push_error** **(** :ref:`String<class_String>` message **)**
|
|
|
|
Envía un mensaje de error al depurador incorporado de Godot y al terminal del sistema operativo.
|
|
|
|
::
|
|
|
|
push_error("test error) # Imprime "test error" al depurador y a la terminal como una llamada de error
|
|
|
|
\ **Nota:** Los errores imprimidos de esta manera no pausaran la ejecución del proyecto. Para imprimir un mensaje de error y pausar la ejecución del proyecto en compilaciones de depuración, usa ``assert(false, "test error")`` en su lugar.
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_push_warning:
|
|
|
|
- void **push_warning** **(** :ref:`String<class_String>` message **)**
|
|
|
|
Envía un mensaje de aviso al depurador incorporado de Godot y al terminal del sistema operativo.
|
|
|
|
::
|
|
|
|
push_warning("test warning) # Imprime "test warning" al depurador y a la terminal como una llamada de aviso.
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_rad2deg:
|
|
|
|
- :ref:`float<class_float>` **rad2deg** **(** :ref:`float<class_float>` rad **)**
|
|
|
|
Convierte un ángulo expresado en radianes a grados.
|
|
|
|
::
|
|
|
|
rad2deg(0.523599) # Devuelve 30.0
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_rand_range:
|
|
|
|
- :ref:`float<class_float>` **rand_range** **(** :ref:`float<class_float>` from, :ref:`float<class_float>` to **)**
|
|
|
|
Rango aleatorio de cualquier numero real entre ``from`` y ``to``.
|
|
|
|
::
|
|
|
|
prints(rand_range(0, 1), rand_range(0, 1)) # Imprime dos numeros aleatorios
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_rand_seed:
|
|
|
|
- :ref:`Array<class_Array>` **rand_seed** **(** :ref:`int<class_int>` seed **)**
|
|
|
|
Aleatorio desde la semilla: se pasa una ``semilla``, y se devuelve un array con el número y la nueva semilla. "Semilla" aquí se refiere al estado interno del generador de números pseudo aleatorios. El estado interno de la implementación actual es de 64 bits.
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_randf:
|
|
|
|
- :ref:`float<class_float>` **randf** **(** **)**
|
|
|
|
Devuelve un aleatorio real en el intervalo ``[0, 1]``\
|
|
|
|
::
|
|
|
|
randf() # Devuelve un aleatorio entre 0 y 1 como 0.375671
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_randi:
|
|
|
|
- :ref:`int<class_int>` **randi** **(** **)**
|
|
|
|
Devuelve un entero aleatorio sin signo de 32 bits. Utiliza el resto para obtener un valor aleatorio en el intervalo ``[0, N - 1]`` (donde N es menor que 2^32).
|
|
|
|
::
|
|
|
|
randi() # Devuelve un entero aleatorio entre 0 y 2^32 - 1.
|
|
randi() % 20 # Devuelve un entero aleatorio entre 0 y 19.
|
|
randi() % 100 # Devuelve un entero aleatorio entre 0 y 99.
|
|
randi() % 100 + 1 # Devuelve un entero aleatoria entre 1 y 100
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_randomize:
|
|
|
|
- void **randomize** **(** **)**
|
|
|
|
Aleatoriza la semilla (o el estado interno) del generador de números aleatorios. La implementación actual se realimenta usando un número basado en el tiempo.
|
|
|
|
::
|
|
|
|
func_ready():
|
|
\ randomize()
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_range:
|
|
|
|
- :ref:`Array<class_Array>` **range** **(** ... **)** |vararg|
|
|
|
|
Devuelve una formación con el rango dado. El método ``range()`` puede tener un argumento ``N`` (0 a ``N`` - 1), dos argumentos (``initial``, ``final - 1``) o tres argumentos (``initial``, ``final - 1``, ``increment``). ``increment`` puede ser negativo, y en tal caso, ``final - 1`` llega a ser ``final + 1``. También, el valor incial debe ser mayor que el valor final para que se ejecute la iteración.
|
|
|
|
Devuelve una formación vacía si el rango no es válido (por ejemplo, ``range(2, 5, -1)`` o ``range(5, 5, 1)``).
|
|
|
|
::
|
|
|
|
print(range(4))
|
|
print(range(2, 5))
|
|
print(range(0, 6, 2))
|
|
|
|
Salida:
|
|
|
|
::
|
|
|
|
[0, 1, 2, 3]
|
|
[2, 3, 4]
|
|
[0, 2, 4]
|
|
|
|
Para iterar sobre un :ref:`Array<class_Array>` al revés, utilice:
|
|
|
|
::
|
|
|
|
var array = [3, 6, 9]
|
|
var i := array.size() - 1
|
|
while i >= 0:
|
|
print(array[i])
|
|
i -= 1
|
|
|
|
Salida:
|
|
|
|
::
|
|
|
|
9
|
|
6
|
|
3
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_range_lerp:
|
|
|
|
- :ref:`float<class_float>` **range_lerp** **(** :ref:`float<class_float>` value, :ref:`float<class_float>` istart, :ref:`float<class_float>` istop, :ref:`float<class_float>` ostart, :ref:`float<class_float>` ostop **)**
|
|
|
|
Transforma un ``value`` entre los rangos ``(istart, istop]`` a los rangos ``[ostart, ostop]``.
|
|
|
|
::
|
|
|
|
range_lerp(75, 0, 100, -1, 1) # Devuelve 0.5
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_round:
|
|
|
|
- :ref:`float<class_float>` **round** **(** :ref:`float<class_float>` s **)**
|
|
|
|
Rounds ``s`` to the nearest whole number, with halfway cases rounded away from zero.
|
|
|
|
::
|
|
|
|
a = round(2.49) # a is 2.0
|
|
a = round(2.5) # a is 3.0
|
|
a = round(2.51) # a is 3.0
|
|
|
|
See also :ref:`floor<class_@GDScript_method_floor>`, :ref:`ceil<class_@GDScript_method_ceil>`, :ref:`stepify<class_@GDScript_method_stepify>`, and :ref:`int<class_int>`.
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_seed:
|
|
|
|
- void **seed** **(** :ref:`int<class_int>` seed **)**
|
|
|
|
Establece la semilla para el generador de números aleatorios.
|
|
|
|
::
|
|
|
|
mi_semilla = "Godot Rocks"
|
|
seed(mi_semilla.hash())
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_sign:
|
|
|
|
- :ref:`float<class_float>` **sign** **(** :ref:`float<class_float>` s **)**
|
|
|
|
Devuelve el signo de ``s``: -1 o 1. Devuelve 0 si ``s`` es 0.
|
|
|
|
::
|
|
|
|
sign(-6) # Devuelve -1
|
|
sign(0) # Devuelve 0
|
|
sign(6) # Devuelve 1
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_sin:
|
|
|
|
- :ref:`float<class_float>` **sin** **(** :ref:`float<class_float>` s **)**
|
|
|
|
Devuelve el seno de un angulo ``s`` en radianes.
|
|
|
|
::
|
|
|
|
sin(0.523599) # Devuelve 0.5
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_sinh:
|
|
|
|
- :ref:`float<class_float>` **sinh** **(** :ref:`float<class_float>` s **)**
|
|
|
|
Devuelve el seno hiperbolico de ``s``.
|
|
|
|
::
|
|
|
|
a = log(2.0) # Devuelve 0.693147
|
|
sinh(a) # Devuelve 0.75
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_smoothstep:
|
|
|
|
- :ref:`float<class_float>` **smoothstep** **(** :ref:`float<class_float>` from, :ref:`float<class_float>` to, :ref:`float<class_float>` s **)**
|
|
|
|
Returns the result of smoothly interpolating the value of ``s`` between ``0`` and ``1``, based on the where ``s`` lies with respect to the edges ``from`` and ``to``.
|
|
|
|
The return value is ``0`` if ``s <= from``, and ``1`` if ``s >= to``. If ``s`` lies between ``from`` and ``to``, the returned value follows an S-shaped curve that maps ``s`` between ``0`` and ``1``.
|
|
|
|
This S-shaped curve is the cubic Hermite interpolator, given by ``f(y) = 3*y^2 - 2*y^3`` where ``y = (x-from) / (to-from)``.
|
|
|
|
::
|
|
|
|
smoothstep(0, 2, -5.0) # Returns 0.0
|
|
smoothstep(0, 2, 0.5) # Returns 0.15625
|
|
smoothstep(0, 2, 1.0) # Returns 0.5
|
|
smoothstep(0, 2, 2.0) # Returns 1.0
|
|
|
|
Compared to :ref:`ease<class_@GDScript_method_ease>` with a curve value of ``-1.6521``, :ref:`smoothstep<class_@GDScript_method_smoothstep>` returns the smoothest possible curve with no sudden changes in the derivative. If you need to perform more advanced transitions, use :ref:`Tween<class_Tween>` or :ref:`AnimationPlayer<class_AnimationPlayer>`.
|
|
|
|
\ `Comparison between smoothstep() and ease(x, -1.6521) return values <https://raw.githubusercontent.com/godotengine/godot-docs/3.4/img/smoothstep_ease_comparison.png>`__
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_sqrt:
|
|
|
|
- :ref:`float<class_float>` **sqrt** **(** :ref:`float<class_float>` s **)**
|
|
|
|
Returns the square root of ``s``, where ``s`` is a non-negative number.
|
|
|
|
::
|
|
|
|
sqrt(9) # Returns 3
|
|
|
|
\ **Note:** Negative values of ``s`` return NaN. If you need negative inputs, use ``System.Numerics.Complex`` in C#.
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_step_decimals:
|
|
|
|
- :ref:`int<class_int>` **step_decimals** **(** :ref:`float<class_float>` step **)**
|
|
|
|
Returns the position of the first non-zero digit, after the decimal point. Note that the maximum return value is 10, which is a design decision in the implementation.
|
|
|
|
::
|
|
|
|
n = step_decimals(5) # n is 0
|
|
n = step_decimals(1.0005) # n is 4
|
|
n = step_decimals(0.000000005) # n is 9
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_stepify:
|
|
|
|
- :ref:`float<class_float>` **stepify** **(** :ref:`float<class_float>` s, :ref:`float<class_float>` step **)**
|
|
|
|
Snaps float value ``s`` to a given ``step``. This can also be used to round a floating point number to an arbitrary number of decimals.
|
|
|
|
::
|
|
|
|
stepify(100, 32) # Returns 96.0
|
|
stepify(3.14159, 0.01) # Returns 3.14
|
|
|
|
See also :ref:`ceil<class_@GDScript_method_ceil>`, :ref:`floor<class_@GDScript_method_floor>`, :ref:`round<class_@GDScript_method_round>`, and :ref:`int<class_int>`.
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_str:
|
|
|
|
- :ref:`String<class_String>` **str** **(** ... **)** |vararg|
|
|
|
|
Converts one or more arguments of any type to string in the best way possible.
|
|
|
|
::
|
|
|
|
var a = [10, 20, 30]
|
|
var b = str(a);
|
|
len(a) # Returns 3
|
|
len(b) # Returns 12
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_str2var:
|
|
|
|
- :ref:`Variant<class_Variant>` **str2var** **(** :ref:`String<class_String>` string **)**
|
|
|
|
Convierte una string formateada que fue devuelta por el :ref:`var2str<class_@GDScript_method_var2str>` al valor original.
|
|
|
|
::
|
|
|
|
a = '{ "a": 1, "b": 2 }'
|
|
b = str2var(a)
|
|
print(b["a"]) # Imprime 1
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_tan:
|
|
|
|
- :ref:`float<class_float>` **tan** **(** :ref:`float<class_float>` s **)**
|
|
|
|
Devuelve la tangente del ángulo ``s`` en radianes.
|
|
|
|
::
|
|
|
|
tan(deg2rad(45)) # Devuelve 1
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_tanh:
|
|
|
|
- :ref:`float<class_float>` **tanh** **(** :ref:`float<class_float>` s **)**
|
|
|
|
Returns the hyperbolic tangent of ``s``.
|
|
|
|
::
|
|
|
|
a = log(2.0) # a is 0.693147
|
|
b = tanh(a) # b is 0.6
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_to_json:
|
|
|
|
- :ref:`String<class_String>` **to_json** **(** :ref:`Variant<class_Variant>` var **)**
|
|
|
|
Convierte una :ref:`Variant<class_Variant>` ``var`` en texto JSON y devuelve el resultado. Es útil para serializar datos para almacenarlos o enviarlos a través de la red.
|
|
|
|
::
|
|
|
|
# Los dos números de abajo son números enteros.
|
|
a = { "a": 1, "b": 2 }
|
|
b = to_json(a)
|
|
print(b) # {"a":1, "b":2}
|
|
# Los dos números de arriba son reales, aunque se muestren sin decimales.
|
|
|
|
\ **Nota:** La especificación JSON no define los tipos enteros o de reales, sino sólo un tipo *número*. Por lo tanto, al convertir un texto de :ref:`Variant<class_Variant>` a JSON se convertirán todos los valores numéricos a tipos :ref:`float<class_float>`.
|
|
|
|
Véase también :ref:`JSON<class_JSON>` para una forma alternativa de convertir un texto :ref:`Variant<class_Variant>` a JSON.
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_type_exists:
|
|
|
|
- :ref:`bool<class_bool>` **type_exists** **(** :ref:`String<class_String>` type **)**
|
|
|
|
Returns whether the given class exists in :ref:`ClassDB<class_ClassDB>`.
|
|
|
|
::
|
|
|
|
type_exists("Sprite") # Returns true
|
|
type_exists("Variant") # Returns false
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_typeof:
|
|
|
|
- :ref:`int<class_int>` **typeof** **(** :ref:`Variant<class_Variant>` what **)**
|
|
|
|
Devuelve el tipo interno del objeto variable dado, usando los valores :ref:`Variant.Type<enum_@GlobalScope_Variant.Type>`.
|
|
|
|
::
|
|
|
|
p = parse_json('["a", "b", "c"]')
|
|
if typeof(p) == TYPE_ARRAY:
|
|
print(p[0]) # Imprime a
|
|
else:
|
|
print("resultados inesperados")
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_validate_json:
|
|
|
|
- :ref:`String<class_String>` **validate_json** **(** :ref:`String<class_String>` json **)**
|
|
|
|
Comprueba que ``json`` es un dato JSON válido. Devuelve una string vacía si es válida, o un mensaje de error en caso contrario.
|
|
|
|
::
|
|
|
|
j = to_json([1, 2, 3])
|
|
v = validate_json(j)
|
|
if not v:
|
|
print("JSON válido")
|
|
else:
|
|
prints("JSON inválido", v)
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_var2bytes:
|
|
|
|
- :ref:`PoolByteArray<class_PoolByteArray>` **var2bytes** **(** :ref:`Variant<class_Variant>` var, :ref:`bool<class_bool>` full_objects=false **)**
|
|
|
|
Codifica un valor variable en un array de bytes. Cuando ``full_objects`` es ``true`` se permite la codificación de objetos (y puede potencialmente incluir código).
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_var2str:
|
|
|
|
- :ref:`String<class_String>` **var2str** **(** :ref:`Variant<class_Variant>` var **)**
|
|
|
|
Convierte una variable ``var`` en una cadena formateada que puede ser analizada posteriormente utilizando :ref:`str2var<class_@GDScript_method_str2var>`.
|
|
|
|
::
|
|
|
|
a = { "a": 1, "b": 2 }
|
|
print(var2str(a))
|
|
|
|
prints
|
|
|
|
::
|
|
|
|
{
|
|
"a": 1,
|
|
"b": 2
|
|
}
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_weakref:
|
|
|
|
- :ref:`WeakRef<class_WeakRef>` **weakref** **(** :ref:`Object<class_Object>` obj **)**
|
|
|
|
Devuelve una referencia débil a un objeto.
|
|
|
|
Una referencia débil a un objeto no es suficiente para mantenerlo vivo: cuando las únicas referencias que quedan de un referencia son referencias débiles, el garbage collector es libre para destruir la referencia y reutilizar su memoria para otra cosa. Sin embargo, hasta que el objeto sea realmente destruido la referencia débil puede devolver el objeto aunque no haya referencias fuertes a él.
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_wrapf:
|
|
|
|
- :ref:`float<class_float>` **wrapf** **(** :ref:`float<class_float>` value, :ref:`float<class_float>` min, :ref:`float<class_float>` max **)**
|
|
|
|
Convierte el real ``value`` entre ``min`` y ``max``.
|
|
|
|
Utilizado para crear un comportamiento similar al de un bucle o superficies infinitas.
|
|
|
|
::
|
|
|
|
# Bucle infinito entre 5.0 y 9.9
|
|
valor = wrapf(valor + 0.1, 5.0, 10.0)
|
|
|
|
::
|
|
|
|
# Rotación infinita (en radianes)
|
|
ángulo = wrapf(ángulo + 0.1, 0.0, TAU)
|
|
|
|
::
|
|
|
|
# Rotación infinita (en radianes)
|
|
ángulo = wrapf(ángulo + 0.1, -PI, PI)
|
|
|
|
\ **Nota:** Si ``min`` es ``0``, esto equivale a :ref:`fposmod<class_@GDScript_method_fposmod>`, así que prefiera usar eso en su lugar.
|
|
|
|
\ ``wrapf`` es más flexible que utilizar el enfoque de :ref:`fposmod<class_@GDScript_method_fposmod>`, ya que le da al usuario el control sobre el valor mínimo.
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_wrapi:
|
|
|
|
- :ref:`int<class_int>` **wrapi** **(** :ref:`int<class_int>` value, :ref:`int<class_int>` min, :ref:`int<class_int>` max **)**
|
|
|
|
Convierte el numero entero ``value`` que esta entre ``min`` y ``max``.
|
|
|
|
Usado para crear comportamientos tipo bucle o superficies infinitas.
|
|
|
|
::
|
|
|
|
# Bucle infinito entre 5 y 9
|
|
fotograma = wrapi(fotograma + 1, 5, 10)
|
|
|
|
::
|
|
|
|
# El resultado es -2
|
|
var resultado = wrapi(-6, -5, -1)
|
|
|
|
\ **Nota:** Si ``min`` es ``0``, esto equivale a :ref:`posmod<class_@GDScript_method_posmod>`, así que prefiera usar eso en su lugar.
|
|
|
|
\ ``wrapi`` es más flexible que el enfoque de :ref:`posmod<class_@GDScript_method_posmod>`, ya que le da al usuario el control sobre el valor mínimo.
|
|
|
|
----
|
|
|
|
.. _class_@GDScript_method_yield:
|
|
|
|
- :ref:`GDScriptFunctionState<class_GDScriptFunctionState>` **yield** **(** :ref:`Object<class_Object>` object=null, :ref:`String<class_String>` signal="" **)**
|
|
|
|
Detiene la ejecución de la función y devuelve el estado suspendido actual a la función que lo ha llamado.
|
|
|
|
Desde el llamador, llama :ref:`GDScriptFunctionState.resume<class_GDScriptFunctionState_method_resume>` al estado para reanudar la ejecución. Esto invalida el estado. Dentro de la función reanudada, ``yield()`` devuelve lo que se pasó a la llamada de la función ``resume()``.
|
|
|
|
Si se pasa un objeto y una señal, la ejecución se reanuda cuando el objeto emite la señal dada. En este caso, ``yield()`` devuelve el argumento pasado a ``emit_signal()`` si la señal toma un solo argumento, o un array que contiene todos los argumentos pasados a ``emit_signal()`` si la señal toma múltiples argumentos.
|
|
|
|
También puedes usar ``yield`` para esperar a que una función termine:
|
|
|
|
::
|
|
|
|
func _ready():
|
|
yield(cuentaAtras(), "completed") # esperando por la funcion cuentaAtras() a que termine
|
|
print('Preparado')
|
|
|
|
func cuentaAtras():
|
|
yield(get_tree(), "idle_frame") # devuelve un objeto GDScriptFunctionState a _ready()
|
|
print(3)
|
|
yield(get_tree().create_timer(1.0), "timeout")
|
|
print(2)
|
|
yield(get_tree().create_timer(1.0), "timeout")
|
|
print(1)
|
|
yield(get_tree().create_timer(1.0), "timeout")
|
|
|
|
# prints:
|
|
# 3
|
|
# 2
|
|
# 1
|
|
# Ready
|
|
|
|
Al ceder una función, la señal ``completed`` se emitirá automáticamente cuando la función retorne. Por lo tanto, puede utilizarse como parámetro ``signal`` del método ``yield`` para reanudar.
|
|
|
|
Para ceder una función, la función resultante también debe devolver un ``GDScriptFunctionState``. Observe ``yield(get_tree(), "idle_frame")`` del ejemplo anterior.
|
|
|
|
.. |virtual| replace:: :abbr:`virtual (This method should typically be overridden by the user to have any effect.)`
|
|
.. |const| replace:: :abbr:`const (This method has no side effects. It doesn't modify any of the instance's member variables.)`
|
|
.. |vararg| replace:: :abbr:`vararg (This method accepts any number of arguments after the ones described here.)`
|