i18n: Sync translations with Weblate
This commit is contained in:
Rémi Verschelde
@@ -94,12 +94,13 @@
|
||||
# Valentben <valentinostoby@hotmail.com>, 2024.
|
||||
# Alexander Diego <diegocho2005@gmail.com>, 2024.
|
||||
# José Andrés Urdaneta <urdaneta7834@gmail.com>, 2025.
|
||||
# LuisGFlorez <lgfgcoder@gmail.com>, 2025.
|
||||
msgid ""
|
||||
msgstr ""
|
||||
"Project-Id-Version: Godot Engine class reference\n"
|
||||
"Report-Msgid-Bugs-To: https://github.com/godotengine/godot\n"
|
||||
"PO-Revision-Date: 2025-02-06 23:02+0000\n"
|
||||
"Last-Translator: José Andrés Urdaneta <urdaneta7834@gmail.com>\n"
|
||||
"PO-Revision-Date: 2025-02-10 00:45+0000\n"
|
||||
"Last-Translator: LuisGFlorez <lgfgcoder@gmail.com>\n"
|
||||
"Language-Team: Spanish <https://hosted.weblate.org/projects/godot-engine/"
|
||||
"godot-class-reference/es/>\n"
|
||||
"Language: es\n"
|
||||
@@ -14628,20 +14629,6 @@ msgstr ""
|
||||
"Si [code]true[/code], envía eventos de entrada táctil al hacer clic o "
|
||||
"arrastrar el ratón."
|
||||
|
||||
msgid ""
|
||||
"The locale to fall back to if a translation isn't available in a given "
|
||||
"language. If left empty, [code]en[/code] (English) will be used."
|
||||
msgstr ""
|
||||
"El lugar al que recurrir si una traducción no está disponible en un idioma "
|
||||
"determinado. Si se deja vacío, se usará [code]en[/code] (inglés)."
|
||||
|
||||
msgid ""
|
||||
"If non-empty, this locale will be used when running the project from the "
|
||||
"editor."
|
||||
msgstr ""
|
||||
"Si no está vacío, este lugar se utilizará cuando se ejecute el proyecto desde "
|
||||
"el editor."
|
||||
|
||||
msgid ""
|
||||
"Godot uses a message queue to defer some function calls. If you run out of "
|
||||
"space on it (you will see an error), you can increase the size here."
|
||||
@@ -18363,7 +18350,256 @@ msgid "Memory allocation error."
|
||||
msgstr "Error de asignación de memoria."
|
||||
|
||||
msgid "The most important data type in Godot."
|
||||
msgstr "El tipo de datos más importante de Godot."
|
||||
msgstr "El tipo de dato más importante de Godot."
|
||||
|
||||
msgid ""
|
||||
"In computer programming, a Variant class is a class that is designed to store "
|
||||
"a variety of other types. Dynamic programming languages like PHP, Lua, "
|
||||
"JavaScript and GDScript like to use them to store variables' data on the "
|
||||
"backend. With these Variants, properties are able to change value types "
|
||||
"freely.\n"
|
||||
"[codeblocks]\n"
|
||||
"[gdscript]\n"
|
||||
"var foo = 2 # foo is dynamically an integer\n"
|
||||
"foo = \"Now foo is a string!\"\n"
|
||||
"foo = RefCounted.new() # foo is an Object\n"
|
||||
"var bar: int = 2 # bar is a statically typed integer.\n"
|
||||
"# bar = \"Uh oh! I can't make statically typed variables become a different "
|
||||
"type!\"\n"
|
||||
"[/gdscript]\n"
|
||||
"[csharp]\n"
|
||||
"// C# is statically typed. Once a variable has a type it cannot be changed. "
|
||||
"You can use the `var` keyword to let the compiler infer the type "
|
||||
"automatically.\n"
|
||||
"var foo = 2; // Foo is a 32-bit integer (int). Be cautious, integers in "
|
||||
"GDScript are 64-bit and the direct C# equivalent is `long`.\n"
|
||||
"// foo = \"foo was and will always be an integer. It cannot be turned into a "
|
||||
"string!\";\n"
|
||||
"var boo = \"Boo is a string!\";\n"
|
||||
"var ref = new RefCounted(); // var is especially useful when used together "
|
||||
"with a constructor.\n"
|
||||
"\n"
|
||||
"// Godot also provides a Variant type that works like a union of all the "
|
||||
"Variant-compatible types.\n"
|
||||
"Variant fooVar = 2; // fooVar is dynamically an integer (stored as a `long` "
|
||||
"in the Variant type).\n"
|
||||
"fooVar = \"Now fooVar is a string!\";\n"
|
||||
"fooVar = new RefCounted(); // fooVar is a GodotObject.\n"
|
||||
"[/csharp]\n"
|
||||
"[/codeblocks]\n"
|
||||
"Godot tracks all scripting API variables within Variants. Without even "
|
||||
"realizing it, you use Variants all the time. When a particular language "
|
||||
"enforces its own rules for keeping data typed, then that language is applying "
|
||||
"its own custom logic over the base Variant scripting API.\n"
|
||||
"- GDScript automatically wrap values in them. It keeps all data in plain "
|
||||
"Variants by default and then optionally enforces custom static typing rules "
|
||||
"on variable types.\n"
|
||||
"- C# is statically typed, but uses its own implementation of the Variant type "
|
||||
"in place of Godot's [Variant] class when it needs to represent a dynamic "
|
||||
"value. C# Variant can be assigned any compatible type implicitly but "
|
||||
"converting requires an explicit cast.\n"
|
||||
"The global [method @GlobalScope.typeof] function returns the enumerated value "
|
||||
"of the Variant type stored in the current variable (see [enum Variant."
|
||||
"Type]).\n"
|
||||
"[codeblocks]\n"
|
||||
"[gdscript]\n"
|
||||
"var foo = 2\n"
|
||||
"match typeof(foo):\n"
|
||||
" TYPE_NIL:\n"
|
||||
" print(\"foo is null\")\n"
|
||||
" TYPE_INT:\n"
|
||||
" print(\"foo is an integer\")\n"
|
||||
" TYPE_OBJECT:\n"
|
||||
" # Note that Objects are their own special category.\n"
|
||||
" # To get the name of the underlying Object type, you need the "
|
||||
"`get_class()` method.\n"
|
||||
" print(\"foo is a(n) %s\" % foo.get_class()) # inject the class name "
|
||||
"into a formatted string.\n"
|
||||
" # Note that this does not get the script's `class_name` global "
|
||||
"identifier.\n"
|
||||
" # If the `class_name` is needed, use `foo.get_script()."
|
||||
"get_global_name()` instead.\n"
|
||||
"[/gdscript]\n"
|
||||
"[csharp]\n"
|
||||
"Variant foo = 2;\n"
|
||||
"switch (foo.VariantType)\n"
|
||||
"{\n"
|
||||
" case Variant.Type.Nil:\n"
|
||||
" GD.Print(\"foo is null\");\n"
|
||||
" break;\n"
|
||||
" case Variant.Type.Int:\n"
|
||||
" GD.Print(\"foo is an integer\");\n"
|
||||
" break;\n"
|
||||
" case Variant.Type.Object:\n"
|
||||
" // Note that Objects are their own special category.\n"
|
||||
" // You can convert a Variant to a GodotObject and use reflection to "
|
||||
"get its name.\n"
|
||||
" GD.Print($\"foo is a(n) {foo.AsGodotObject().GetType().Name}\");\n"
|
||||
" break;\n"
|
||||
"}\n"
|
||||
"[/csharp]\n"
|
||||
"[/codeblocks]\n"
|
||||
"A Variant takes up only 20 bytes and can store almost any engine datatype "
|
||||
"inside of it. Variants are rarely used to hold information for long periods "
|
||||
"of time. Instead, they are used mainly for communication, editing, "
|
||||
"serialization and moving data around.\n"
|
||||
"Godot has specifically invested in making its Variant class as flexible as "
|
||||
"possible; so much so that it is used for a multitude of operations to "
|
||||
"facilitate communication between all of Godot's systems.\n"
|
||||
"A Variant:\n"
|
||||
"- Can store almost any datatype.\n"
|
||||
"- Can perform operations between many variants. GDScript uses Variant as its "
|
||||
"atomic/native datatype.\n"
|
||||
"- Can be hashed, so it can be compared quickly to other variants.\n"
|
||||
"- Can be used to convert safely between datatypes.\n"
|
||||
"- Can be used to abstract calling methods and their arguments. Godot exports "
|
||||
"all its functions through variants.\n"
|
||||
"- Can be used to defer calls or move data between threads.\n"
|
||||
"- Can be serialized as binary and stored to disk, or transferred via "
|
||||
"network.\n"
|
||||
"- Can be serialized to text and use it for printing values and editable "
|
||||
"settings.\n"
|
||||
"- Can work as an exported property, so the editor can edit it universally.\n"
|
||||
"- Can be used for dictionaries, arrays, parsers, etc.\n"
|
||||
"[b]Containers (Array and Dictionary):[/b] Both are implemented using "
|
||||
"variants. A [Dictionary] can match any datatype used as key to any other "
|
||||
"datatype. An [Array] just holds an array of Variants. Of course, a Variant "
|
||||
"can also hold a [Dictionary] and an [Array] inside, making it even more "
|
||||
"flexible.\n"
|
||||
"Modifications to a container will modify all references to it. A [Mutex] "
|
||||
"should be created to lock it if multi-threaded access is desired."
|
||||
msgstr ""
|
||||
"En programación de computadoras, una clase Variant (variante en español) es "
|
||||
"una clase que está diseñada para almacenar una variedad de otros tipos. A los "
|
||||
"lenguajes de programación dinámicos como PHP, Lua, JavaScript y GDScript les "
|
||||
"gusta usarlos para almacenar datos de variables en el backend. Con estas "
|
||||
"variantes, las propiedades son capaces de cambiar los tipos de valores "
|
||||
"libremente.\n"
|
||||
"[codeblocks]\n"
|
||||
"[gdscript]\n"
|
||||
"var foo = 2 # foo es dinámicamente un entero\n"
|
||||
"foo = \"¡Ahora foo es una string!\"\n"
|
||||
"foo = Reference.new() # foo es un objeto\n"
|
||||
"var bar: int = 2 # bar es estáticamente un entero.\n"
|
||||
"# bar = \"¡Uh oh, no puedo hacer que las variables estáticamente escritas se "
|
||||
"conviertan en un tipo diferente!\"\n"
|
||||
"[/gdscript]\n"
|
||||
"[csharp]\n"
|
||||
"// C# Es de tipado estático. Una vez que una variable tiene un tipo de datos "
|
||||
"establecido, este no podrá ser cambiado más adelante. Puedes utilizar la "
|
||||
"palabra clave `var` para dejar que el compilador deduzca el tipo de datos de "
|
||||
"la variable automáticamente.\n"
|
||||
"var foo = 2; // foo es un entero (int) de 32 bits. Ten cuidado, los números "
|
||||
"enteros en GDScript son de 64 bits y su equivalente directo en C# es `long`.\n"
|
||||
"// foo = \"foo fue y siempre será un entero, por lo tanto no se puede "
|
||||
"convertir en una string\";\n"
|
||||
"var boo = \"¡boo es una string!\";\n"
|
||||
"var referencia = new RefCounted(); //`var` es especialmente útil cuando se "
|
||||
"utiliza junto con un constructor.\n"
|
||||
"\n"
|
||||
"// Godot también provee un tipo de variante que funciona como una unión para "
|
||||
"todos los tipos de datos que son compatibles con [Variant].\n"
|
||||
"Variant mivariable = 2; // mivariable es dinámicamente un entero (almacenado "
|
||||
"como un `long` dentro de la variante).\n"
|
||||
"mivariable = \"¡Ahora mivariable es una string!\";\n"
|
||||
"mivariable = new RefCounted(); // mivariable es un objeto de tipo "
|
||||
"GodotObject.\n"
|
||||
"[/csharp]\n"
|
||||
"[/codeblocks]\n"
|
||||
"Godot hace un seguimiento de todas las variables de la API de scripting "
|
||||
"dentro de variantes. Sin siquiera darte cuenta, utilizas las variantes todo "
|
||||
"el tiempo. Cuando un determinado lenguaje aplica sus propias reglas para "
|
||||
"mantener los datos escritos, entonces ese lenguaje está aplicando su propia "
|
||||
"lógica personalizada sobre las bases de API de scripting basada en "
|
||||
"variantes.\n"
|
||||
"- GDScript envuelve automáticamente los valores en ellos. Mantiene todos los "
|
||||
"datos de las variables en variantes simples de forma predeterminada y luego, "
|
||||
"opcionalmente, aplica reglas de escritura estática personalizadas en los "
|
||||
"tipos de variables.\n"
|
||||
"- C# es de tipado estático, pero utiliza su propia implementación del tipo "
|
||||
"Variant en lugar de utilizar la clase [Variant] de Godot cuando se necesita "
|
||||
"representar un valor dinámico. A una variante en C# se le puede asignar "
|
||||
"implícitamente cualquier tipo compatible, pero convertirla requiere un cast "
|
||||
"específico.\n"
|
||||
"La función global [method @GDScript.typeof] devuelve el valor enumerado del "
|
||||
"tipo de variante almacenado en la variable actual (véase [enum Variant."
|
||||
"Type]).\n"
|
||||
"[codeblocks]\n"
|
||||
"[gdscript]\n"
|
||||
"var foo = 2\n"
|
||||
"match typeof(foo):\n"
|
||||
" TYPE_NIL:\n"
|
||||
" print(\"foo es nulo (null)\")\n"
|
||||
" TYPE_INTEGER:\n"
|
||||
" print(\"foo es un entero\")\n"
|
||||
" TYPE_OBJECT:\n"
|
||||
" # Tenga en cuenta que los objetos son su propia categoría especial.\n"
|
||||
" # Para obtener el nombre del tipo de objeto subyacente, necesitas el "
|
||||
"método `get_class()`.\n"
|
||||
" print(\"foo es un(a) %s\" % foo.get_class()) # Inyecta el nombre de "
|
||||
"la clase en una string formateada.\n"
|
||||
" # Ten presente que el método `get_class()` no toma en cuenta el valor "
|
||||
"del identificador global`class_name` de un script.\n"
|
||||
" # Si necesitas obtener ese valor debes usar `foo.get_script()."
|
||||
"get_global_name()`\n"
|
||||
"[/gdscript]\n"
|
||||
"[csharp]\n"
|
||||
"Variant foo = 2;\n"
|
||||
"switch (foo.VariantType)\n"
|
||||
"{\n"
|
||||
" case Variant.Type.Nil:\n"
|
||||
" GD.Print(\"foo es nulo (null)\");\n"
|
||||
" break;\n"
|
||||
" case Variant.Type.Int:\n"
|
||||
" GD.Print(\"foo es un entero\");\n"
|
||||
" break;\n"
|
||||
" case Variant.Type.Object:\n"
|
||||
" // Tenga en cuenta que los objetos son su propia categoría especial.\n"
|
||||
" // Puedes convertir una variante a un objeto de tipo GodotObject y "
|
||||
"usar la reflección para obtener su nombre.\n"
|
||||
" GD.Print($\"foo es un(a) {foo.AsGodotObject().GetType().Name}\");\n"
|
||||
" break;\n"
|
||||
"}\n"
|
||||
"[/csharp]\n"
|
||||
"[/codeblocks]\n"
|
||||
"Una variante sólo ocupa 20 bytes y puede almacenar casi cualquier tipo de "
|
||||
"dato del motor en su interior. Las variantes rara vez se utilizan para "
|
||||
"mantener información durante largos períodos de tiempo. En cambio, se "
|
||||
"utilizan principalmente para la comunicación, la edición, la serialización y "
|
||||
"el desplazamiento de datos.\n"
|
||||
"Godot ha invertido específicamente en hacer que su clase Variant sea lo más "
|
||||
"flexible posible; tanto es así que se utiliza para una multitud de "
|
||||
"operaciones para facilitar la comunicación entre todos los sistemas de "
|
||||
"Godot.\n"
|
||||
"Una variante:\n"
|
||||
"- Puede almacenar casi cualquier tipo de datos.\n"
|
||||
"- Puede realizar operaciones entre muchas variantes. GDScript utiliza "
|
||||
"[Variant] como su tipo de dato atómico/nativo.\n"
|
||||
"- Puede ser \"hashed\", por lo que puede ser comparado rápidamente con otras "
|
||||
"variantes.\n"
|
||||
"- Puede ser usado para convertir con seguridad entre tipos de datos.\n"
|
||||
"- Puede ser usado para abstraer métodos que están siendo llamados y sus "
|
||||
"argumentos. Godot exporta todas sus funciones a través de variantes.\n"
|
||||
"- Puede utilizarse para diferir llamadas o mover datos entre hilos.\n"
|
||||
"- Puede ser serializado como binario y ser almacenado en el disco, o "
|
||||
"transferido a través de la red.\n"
|
||||
"- Puede ser serializado como texto y ser usado para imprimir valores y "
|
||||
"configuraciones editables.\n"
|
||||
"- Puede funcionar como una propiedad exportada, de modo que el editor puede "
|
||||
"editarla globalmente.\n"
|
||||
"- Puede ser usado para diccionarios, arrays, parsers, etc.\n"
|
||||
"[b]Los contenedores (Array y Dictionary):[/b] Ambos están implementados "
|
||||
"utilizando variantes. Un [Dictionary] puede hacer coincidir cualquier tipo de "
|
||||
"datos utilizado como clave con cualquier otro tipo de datos. Un [Array] sólo "
|
||||
"contiene una arreglo de variantes. Por supuesto, una variante también puede "
|
||||
"contener un [Dictionary] y un [Array] en su interior, lo que lo hace aún más "
|
||||
"flexible.\n"
|
||||
"Las modificaciones a un contenedor modificarán todas las referencias que "
|
||||
"apuntan hacia él. Debe crearse un [Mutex] para bloquearla si desea un acceso "
|
||||
"multihilo."
|
||||
|
||||
msgid "Variant class introduction"
|
||||
msgstr "Introducción a la clase Variant"
|
||||
|
||||
msgid ""
|
||||
"Returns a new vector with all components in absolute values (i.e. positive)."
|
||||
|
||||
Reference in New Issue
Block a user