-
-
Notifications
You must be signed in to change notification settings - Fork 21.8k
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
i18n: Sync translations with Weblate
- Loading branch information
Showing
54 changed files
with
76,809 additions
and
6,980 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
|
|
@@ -94,12 +94,13 @@ | |
| # Valentben <[email protected]>, 2024. | ||
| # Alexander Diego <[email protected]>, 2024. | ||
| # José Andrés Urdaneta <[email protected]>, 2025. | ||
| # LuisGFlorez <[email protected]>, 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)." | ||
|
|
||
Oops, something went wrong.