hola jente. este hilo es para aquellos que, pese a que se les dijo en inumerables ocasiones que bgt es malo, que no deberían intentarlo (aclaro que no estoy totalmente deacuerdo con eso) aún persisten en aprenderlo.
la forma será sencilla. yo iré traduciendo el manual paso a paso y, según vallan las cosas (si las dudas son demasiadas o no se comprende por el manual) iré dando clases a los que me lo pidan por privado. así uqe para comenzar, en el siguiente post por mi parte ya tendrán la primera parte del manual traducida. espero que esta temática dure y la gente que de verdad quiere aprender lo haga.
así, que vallamos con la primera parte del tutorial. voy a empezar traduciendo el primer apartado de help.chm\languaje tutorial.
advertencia: los primeros apartados se centran en el compilador, en la forma de sintaxis y muchas cosas que desde mi punto de vista son inservibles. yo pasaré a traducir directamente el primer programa y demás.
Una de las primeras cosas por las que se suele empezar cuando se aprende un nuevo código es imprimir algún texto en la pantalla. Es lo más sencillo que se puede hacer, pero de todos modos ha demostrado ser un método muy eficaz para familiarizarse con la sintaxis de un lenguaje y su estilo de funcionamiento. Ya hemos dicho bastante, ¡vamos a imprimir!
void main()
{
alert("hola", "¡soy un script de bgt!");
}
El código anterior puede parecer algo confuso a primera vista, pero en realidad no lo es. Vamos a diseccionarlo pieza por pieza.
void main()
Esto le dice al compilador que estamos usando la función principal, que es el primer bloque de código que se ejecuta cuando se inicia un script. Cubriremos las funciones más adelante, pero es esencial que recuerdes crear esta función cuando hagas un script.
{
todo código en bgt va encerrado entre llaves.

alert(
Este es el nombre de una función proporcionada por el motor BGT, que muestra un simple mensaje en la pantalla con un título y algo de texto. La función de alerta tiene dos parámetros, el primero es el título y el segundo es el mensaje que se va a mostrar. Cuando se llama a una función siempre se especifican sus parámetros (si los hay) entre un paréntesis izquierdo y otro derecho, y se separan los parámetros con una coma.
"Hola",
Es el primer parámetro que se da a la función alert, un trozo de texto que será el título del mensaje.
"¡soy un script de bgt!");
Se trata de otro trozo de texto escrito entre comillas, el segundo parámetro de la función alert que especifica el texto real que debe mostrarse. Este es también el último parámetro de la función, que puede verse por el paréntesis derecho que indica el final de una llamada a la función. El punto y coma después del paréntesis indica el final de la declaración.

}

Esto le indica al compilador que ya hemos terminado nuestra función principal.

Cuando se escribe un texto como este, siempre hay que rodearlo con comillas. Esto es para hacer las cosas más fáciles para el intérprete del script, ya que de otra manera podría confundir su texto con el código BGT real.

Mire el script una vez más, y tenga en cuenta las explicaciones que acaba de leer.
void main()
{
alert("Hello", "I am a BGT script!");
}
Esperemos que las cosas estén un poco más claras ahora. Si todavía no lo tienes claro, vuelve a leer los párrafos anteriores un par de veces antes de seguir adelante para asegurarte de que has comprendido el concepto fundamental.

este fue el primer trozo del manual traducido. dudas al privado

que bien que se cre'o este hilo, que malo que no tengo bgt en esta computadora... pero igual quiero aprender.

me alegra que te guste amigo.

yo comencé hace un tiempo con bgt pero no pude continuar porque se rompió mi computadora donde tenía el bgt y no pude copiarlo para esta que tengo ahora que por cierto es una computadora muy vieja y a veces no le sirven las cosas pero bueno trataré de aprender igual. por lo menos la teoría xd.

el bgt es igual antiguo, así que quizá funcione. deja te busco un link de descarga...
aquí está. solo busca el link download blast bay game toolkit y listo
https://blindhelp.net/software/blastbay-game-toolkit-bgt

ya, lo guardo.

bueno chicos. aquí tienen el segundo cap (las variables) es un enórme capítulo, así que cópienlo a un bloc de notas o algo por que de verdad, es muy grande y con varios sub apartados dentro. sin mas que decir, os dejo con la traducción del manual.
Si estuviste lo suficientemente despierto en las clases de matemáticas como para comprender los fundamentos de las ecuaciones, entender las variables debería ser pan comido. Pero para los que se quedaron dormidos o, como yo, decidieron que era mucho más entretenido jugar al ahorcado en el fondo de la clase, he aquí una sencilla explicación que debería resolver el misterio.

En pocas palabras, una variable es como una cesta que contiene algo. Una variable puede indicar la salud de un jugador en un juego de acción, el precio actual del pescado o que el significado de la vida es 42. Básicamente, puede contener cualquier valor que le des, y puedes recuperar y jugar con ese valor tanto como quieras. BGT soporta cinco tipos básicos de variables, dos de los cuales experimentaremos en este capítulo. Los tipos soportados son variables integrales, variables de punto flotante, variables de cadena, variables booleanas y variables de objeto. Pero antes de pasar a aprender sobre todos estos tipos diferentes, hay una cosa que tendremos que cubrir.
5.2. Declarar y asignar variables
Para establecer una variable, primero tiene que decirle a BGT qué tipo de variable está buscando usar, seguido de un nombre que usará para referirse a su variable la próxima vez que venga a cambiar o leer de ella.
Todas las variables deben tener un nombre. No hay excepciones. Un nombre de variable puede contener letras de la a a la z, incluidas las mayúsculas, los números del 1 al 0 y los subrayados. Sin embargo, el nombre de una variable nunca debe comenzar con un número, aunque es perfectamente legal tener números en cualquier otra parte del nombre.

Considere el siguiente ejemplo:
string your_name;
Esto le dice a BGT que queremos una variable de tipo cadena, llamada tu_nombre. Cuando vuelva a leer este código, sabrá que su_nombre es probable que contenga el nombre del jugador. De nuevo, tenemos un punto y coma al final para denotar el final de una declaración.

Ahora tenemos una variable en blanco. Para que esta variable sea utilizable necesitamos darle un valor. Podemos hacerlo utilizando uno de los dos métodos. Si ha predeterminado el contenido de la variable, es decir, un mensaje que puede ser mostrado al usuario, puede asignar el valor en la misma línea que la declaración, así:

string winning_message="Congratulations! You have won the game!";
Esto le dice a BGT:

• Crear una variable de tipo cadena. Las cadenas serán tratadas con más detalle en la sección de Variables de cadena.
• Llámela mensaje_ganador.
• Asigne el valor "¡Felicidades! Ha ganado el juego!" a winning_message.
• Fin de la declaración

Se puede asignar un nuevo valor a una variable en cualquier punto del bloque de código actual. Ten en cuenta que si no asignas un valor a una variable, sino que sólo la declaras como

tipo x;

type puede ser cualquier tipo de variable primitiva soportada por BGT (ver más abajo). Los objetos funcionan de forma diferente, pero esto se tratará más adelante. Si tiene una declaración como esta sin un valor inicial dado a la variable, entonces tendrá un valor indefinido. En otras palabras, puede ser cualquier cosa, dependiendo del tipo de la variable. Simplemente contendrá lo que sea que esté almacenado en esa ubicación de memoria en el momento en que la variable fue creada, y por lo tanto nunca debe usar una variable cuando no está aún inicializada con un valor. El compilador de scripts BGT intentará advertirle cuando vea que está haciendo esto, pero no puede hacerlo con precisión en todas las situaciones. Por lo tanto, siempre debe dar a sus variables valores iniciales cuando las cree, a menos que pueda asegurar con un 100% de certeza que la variable recibirá un valor significativo antes de ser utilizada.

Ahora que hemos discutido cómo configurar nuestras variables, podemos aprender sobre los diferentes tipos y sobre cómo cambiarlas y compararlas.
5.3. Variables integrales y melocotones malos
Las variables integrales son aquellas que contienen un entero básico, es decir, un número entero. Estas variables no admiten puntos decimales.
Puede realizar operaciones aritméticas sobre ellas como más, menos, veces y dividido por. BGT también admite funciones matemáticas más complejas, por si alguna vez las necesita. Si tiene curiosidad, aquí viene un ejemplo de cómo se pueden utilizar las variables integrales en el mundo real.

int apples=5;
int bananas=2;
int oranges=8;
int fruit_basket=apples+bananas+oranges;

Aquí se ven cuatro variables. Una llamada manzanas, otra llamada plátanos, una tercera llamada naranjas y finalmente una llamada cesta_frutas. Pero cuando le dimos un valor a cesta_fruta en realidad no especificamos un valor directamente, sino que sumamos los valores de las tres variables de tipo de fruta para obtener el número total de frutas en la cesta. Divirtámonos y veamos una versión ligeramente ampliada de este ejemplo.
int apples=5;
int bananas=2;
int oranges=8;
int fruit_basket=apples+bananas+oranges+1;

¿Por qué puse +1 al final? Porque también había un melocotón, pero se había estropeado, así que no me molesté en darle su propia variable. También demuestra claramente lo fácil que es mezclar variables y números literales en las expresiones, lo que técnicamente te permite escribir fórmulas extremadamente potentes si lo deseas.

Ahora vamos a elaborar un poco más y hacer algunos cálculos más con estas variables. Digamos que queremos averiguar cuántas frutas habría en la cesta si sólo se pusieran la mitad de las naranjas, más el melocotón malo. Podríamos hacer lo siguiente:

int apples=5;
int bananas=2;
int oranges=8;
int fruit_basket=apples+bananas+oranges+1;
int robbed_basket=fruit_basket-(oranges/2);

¿Adivina ahora qué valor tendrá la variable llamada robbed_basket? Así es, 12. La cesta contenía 16 frutas en total, de las cuales 8 eran naranjas. Luego quitamos la mitad de las naranjas, y así terminamos con 12.

Pero mira una vez más la línea donde la variable cesta_robada obtiene su valor. ¿Ves que hemos puesto parte del cálculo entre un paréntesis izquierdo y otro derecho? En este caso no significa que estemos llamando a algún tipo de función, aquí simplemente tiene el mismo propósito que en la aritmética regular que es asegurarse de que la expresión se calcula en el orden correcto. De esta manera, puedes calcular expresiones matemáticas avanzadas y estar seguro de que el resultado es siempre el esperado. Eso suponiendo que hayas escrito la expresión correctamente para empezar, lo cual está un poco fuera del alcance de este tutorial.

Te voy a dar un último ejemplo de cómo se pueden manipular las variables numéricas. Éste no tiene ninguna utilidad práctica; sólo pretende mostrar la flexibilidad de las variables numéricas, y cómo pueden utilizarse para realizar cálculos no permitidos en las matemáticas regulares. Echa un vistazo a lo siguiente...

int x=3;
x=x3;
int y=8;
int z=x/y;
z+=x-1;
x=z+4;
Como puede ver, sólo un montón de cálculos sin sentido que no sirven para nada más que para intentar demostrar algunas de las posibilidades que tiene cuando se trabaja con números en el lenguaje BGT.

Una cosa nueva que notará, sin embargo, es el uso de += y *=. Esto significa que, en el caso de *= el valor del lado derecho en la expresión matemática debe ser tomado por el valor actual de la variable. Así, por ejemplo:
int x=5;
x*=3;
Ahora x tendrá el valor de 15, ya que 5*3 es 15. Puedes utilizar todos los operadores numéricos, es decir, +, -, * y /, de la misma manera.
Hay un operador aritmético adicional que puedes utilizar, el operador Módulo. Se representa con un signo de porcentaje (%) y también puede utilizarse con el signo =. El Módulo divide dos números y le da el valor restante. Por ejemplo:
int x=11;
x%=3;

En este caso x será el equivalente a 2, ya que 11 dividido entre 3 es igual a 3, y le sobra 2. Ese 2 es el resultado del Módulo.

Hay otros dos operadores que ahorran tiempo y que puedes utilizar. Se conocen como operadores de autoincremento y autodecremento. Estos son ++ y -- (dos signos más, o dos signos menos). Son buenos para los contadores de bucle, etc.
Cuando escribimos la siguiente línea:

x++;

usted como escritor, y acelera el programa. Si está incrementando una variable una vez, puede que no note el cambio. Si, por otro lado, está cambiando constantemente un contador, notará la diferencia. Aunque una variable integral es de un tipo, puede especificar el rango potencial permitido de la variable. Los dos que suelen interesarle son short, un entero de 16 bits (2 bytes) que va de -32768 a 32767, y long, un entero de 32 bits (4 bytes) que va de -2147483648 a 2147483647.
En otras situaciones, aunque más ocasionales, se pueden utilizar enteros sin signo. Se trata de enteros que no admiten números negativos, por lo que duplican el límite máximo.
A continuación se presenta una lista completa de palabras clave relacionadas con los enteros:

• int8: Un entero de 8 bits (1 byte), que va de -128 a 127.
• int16: Un entero de 16 bits (2 bytes), que va de -32768 a 32767.
• int32: Un entero de 32 bits (4 bytes), que va de -2147483648 a 2147483647.
• uint8: Un entero de 8 bits (1 byte) sin signo, que va de 0 a 255.
• uint16: Un entero de 16 bits (2 bytes) sin signo, que va de 0 a 65535.
• uint32: Un entero sin signo de 32 bits (4 bytes), que va de 0 a 4294967295.
• int: Alias de int32.
• short: Alias de int16.
• long: Alias de int32.
• uint: Alias de uint32.
• ushort: Alias de uint16.
• ulong: Alias de uint32.
5.4. Variables de coma flotante
Las variables de punto flotante son muy similares a las variables con las que estás familiarizado si has trabajado con ecuaciones, contienen un número. Ni más ni menos. Las variables de punto flotante pueden ser con o sin decimales.
Todas las variables de punto flotante tienen signo, lo que significa que pueden ser números positivos o negativos.
Los tipos soportados son:

• Float: Punto flotante de 32 bits de precisión simple
• Doble: Doble precisión de 64 bits en coma flotante

Si no sabes qué valores van a ir en tu variable, probablemente sea mejor usar dobles, ya que soportan el rango más amplio, permitiendo números positivos y negativos, y números enteros y reales, es decir, números con decimales.
Otra cosa que hay que mencionar es que, si, por cualquier razón, el valor de una variable numérica intenta ir más allá de su límite, el compilador emitirá una advertencia y la variable se restablecerá al valor mínimo soportado, por lo que es esencial que mantengas un seguimiento de cualquier cambio que se produzca en tus variables.
5.5. Variables de cadena
Las variables de cadena son muy diferentes de las numéricas que acabamos de explorar. Sin embargo, son muy útiles, y pronto veremos por qué. Una variable de cadena puede contener texto, es decir, una cadena de caracteres simples que formarán algo interesante; de ahí el nombre, cadena. Una cadena puede contener el nombre del reproductor, una ruta en el disco duro o el contenido de un archivo, o cualquier otra cosa que desee. Cuando se utilizan valores de cadena siempre hay que rodearlos con comillas, para que el intérprete no se confunda en cuanto a lo que es código BGT y lo que es parte de su cadena. ¿Le suena eso? Así es... La función de alerta que utilizamos en nuestro primer ejemplo funciona con cadenas.

Creo que la mejor manera de entender las cadenas es verlas en acción. Así que aquí vamos...

string my_name="John Doe";
alert("My name is", my_name);
Como ves aquí, el primer parámetro de la función de alerta se sigue dando de la misma manera que lo hicimos en el primer ejemplo, pero la diferencia viene en el segundo parámetro. En lugar de especificar algo entre comillas para que se muestre en el cuadro de mensaje, hemos dado el nombre de la variable de cadena que acabamos de crear. ¿El resultado? Que "Juan Pérez" se imprime en el cuadro de mensajes con el título "Me llamo". Sí, ¡así de sencillo!

Ahora bien, ¿por qué no rodeamos mi_nombre con comillas en el segundo parámetro de la alerta? Porque eso imprimiría "mi_nombre" literalmente en lugar de tomar el valor de una variable llamada mi_nombre, y no queremos eso.

Intentemos hacer algo más elegante con las cadenas de texto, ¿de acuerdo?
string my_name="John Doe";
string message_string="My name is " + my_name + " and don't you ever forget it!";
alert("Important information", message_string);

string my_name="John Doe";
string message_string="My name is " + my_name + " and don't you ever forget it!";
alert("Important information", message_string);
¿Qué? ¿Qué es eso de " + nombre_de_la_variable + "? Bueno, " + nombre_de_la_variable + " simplemente inserta el valor de una variable en una cadena. Así que la impresión en el cuadro de mensajes será:

Me llamo Juan Pérez y no lo olvides nunca.

Y como habrás adivinado, la variable entre los dos signos más no tiene que ser necesariamente otra cadena. Ilustremos esto con un ejemplo ampliado...

string my_name="John Doe";
int age=23;
string message_string="My name is " + my_name + ", I'm " + age + " years old and don't you ever forget it!";
alert("Important information", message_string)
¿La impresión? Como probablemente esperas, será simplemente:

Me llamo John Doe, tengo 23 años y ¡no lo olvides nunca!

¿Te has dado cuenta de que también hemos utilizado un número entero?
Cualquier variable con cualquier tipo de datos puede colocarse en una variable de cadena, siempre que el resultado de esa variable pueda convertirse en una cadena.
Por supuesto, puedes construir la cadena de mensajes dentro de la llamada a la función de alerta; no tienes que hacer una variable separada para ella si no quieres. Podría hacer lo siguiente...

string my_name="John Doe";
int age=23;
alert("Important information", "My name is " + my_name + ", I'm " + age + " years old and don't you ever forget it!");
Naturalmente la impresión será la misma, el script es sólo una línea más corta.

Vamos a divertirnos un poco con el código de ejemplo de John Doe, y hagamos que haga algo ligeramente más interesante. Mira el siguiente fragmento y ve si puedes averiguar lo que hace.

string my_name="John Doe";
int age=random(5, 50);
string message_string="My name is " + my_name + ", I'm " + age + " years old and don't you ever forget it!";
alert("Important information", message_string);

Lo has adivinado. La función aleatoria que también proporciona el motor BGT, genera un número aleatorio en un rango que usted especifica. En este caso, solicitamos un número entre 5 y 50, lo que significa que Juan Pérez nos dirá una edad diferente cada vez que le preguntemos. La primera vez que ejecuté esto en mi máquina me dijo que John Doe tenía 25 años, la segunda vez me aseguró que tenía 36 y la tercera vez afirmó que tenía 18... ¡Hablando de un mentiroso patológico!

Dejando a Juan Pérez para que contemple su edad en paz, vamos a ver otro ejemplo de cómo se pueden sumar los hilos.
string string1="I am a ";
string string2="string!";
string string3=string1 + string2;
string string4=string1 + "nice " + string2;

El ejemplo anterior muestra lo sencillo que es sumar cadenas, tanto variables como valores literales. Mientras que la cadena1 y la cadena2 son valores literales almacenados en variables, la cadena3 es el resultado de esas dos variables sumadas y la cadena4 son las dos variables sumadas de nuevo pero con un valor literal en medio. Puede combinar las variables y los valores literales de la forma que desee, lo cual es bastante útil en un gran número de aplicaciones, como sin duda descubrirá si utiliza las cadenas en BGT con frecuencia.

Como vimos en la sección anterior, se podría hacer lo siguiente con una variable numérica:
int x=10;
x+=15;
Lo que por supuesto da a x el valor final de 25. Ahora, te alegrará saber que puedes hacer lo mismo con cadenas. El siguiente código es perfectamente legal:
string my_string="Hello there";
my_string+=" my friend.";

Por supuesto, mi_cadena contendrá ahora el texto "Hola amigo". No puedes, como habrás adivinado, utilizar ninguno de los otros operadores numéricos como -, * y / de la misma manera para las cadenas ya que no llenarían ninguna función en este caso.
También hay otra cosa importante que hay que saber sobre las cadenas. Para poder utilizar caracteres especiales, debemos usar lo que se llama un carácter de escape. Se trata de un carácter designado que indica al compilador que el siguiente carácter no debe ser tratado como un carácter literal, sino como un código para el carácter que debe utilizarse. El carácter de escape utilizado en BGT es una barra invertida.
A continuación se muestra una lista de los caracteres que se deben utilizar después del carácter de escape y lo que realmente representan:

• =
• "="
• n=nueva línea
• r=retorno
• t=tabulación

He aquí algunos ejemplos:
string string1="this\tis\ta\tstring\tusing\ttabs\tinstead\tof\tspaces.";
string string2="this is a\r\nmultiline\r\nstring.";
string string3="My current directory is \"c:\program files\bgt\my_game\my_script.bgt\"";

Observe cómo la cadena multilínea utiliza los caracteres r y n para crear una nueva línea. Esta es la secuencia de caracteres utilizada por Windows.
5.6. Constantes
Una constante es básicamente lo mismo que una variable normal, con una diferencia principal. Una vez que se le asigna un valor a una constante, no puede cambiarse en tiempo de ejecución. Su valor permanece igual durante toda la vida del programa, de ahí el nombre de constante, a diferencia de una variable cuyo valor puede cambiar, es decir, variar, en cualquier momento.
El propósito de una constante es principalmente para la legibilidad, y para ahorrar tiempo.
Se declara una constante de la misma manera que se hace con cualquier variable, añadiendo la palabra clave const antes del tipo de datos.
Tomemos el siguiente ejemplo:
const string snd_ext=".wav";
sound gun;
sound beep;
sound ambience;
sound music;
gun.load("sounds/gun"+snd_ext);
beep.load("sounds/beep"+snd_ext);
ambience.stream("sounds/wind"+snd_ext);
music.stream("sounds/music"+snd_ext);
La ventaja aquí es que, si tu juego se hace mucho más grande y decides convertirlo al formato ogg, simplemente cambias la asignación de la constante snd_ext a ".ogg". Entonces todas tus asignaciones de sonido, si usan la constante, se cambian a ese valor sin tener que ir a cambiar cada sonido individual.
Además, el motor BGT viene con ciertas constantes. En la documentación que acompaña a cada función se menciona cuándo se debe utilizar una determinada constante. La constante se pasa a la función por su nombre, aunque lo que realmente ocurre es que se pasa un determinado valor, como un número o una cadena, entre bastidores. Sólo utilizas el nombre de la constante para facilitarte las cosas, también podrías haber escrito el número en sí mismo y aún así tener un código que funcione. Sin embargo, al abrir un archivo en modo de escritura, por ejemplo, el nombre "archivo_escritura" tiene mucho más sentido que el número 2.
También hay un tipo especial de constante llamada enum. Esta es la abreviatura de enumeración, y por lo tanto sólo puede contener valores numéricos, enteros. Son útiles para agrupar constantes, permitiendo una mejor gestión del código. He aquí un ejemplo:
enum movement
{
left=-1,
right=1
}
enum weapon
{
fist,
club,
slingshot,
gun,
bomb
}

Lo que hemos hecho aquí es crear dos conjuntos de enumeraciones, uno llamado movimiento y otro llamado arma. En cada enumeración hemos proporcionado al intérprete una lista de constantes separadas por comas y, en el caso de nuestro ejemplo de movimiento, sus valores correspondientes. Por ejemplo, hemos asignado el nombre izquierda a -1, y derecha a 1. En el caso de arma, sin embargo, no hemos dado ningún valor. Esto se debe a que el intérprete puede asumir automáticamente nuestros valores. Si no se dan valores, a la primera constante se le asignará el valor 0, y cada una de las siguientes se incrementará en 1. Esto es útil aquí, ya que podemos concentrarnos puramente en decidir qué armas queremos. También tiene la ventaja añadida de que si queremos añadir un arma adicional en el futuro, no hay que hacer malabares con los números.

Tenga en cuenta que los enums tienen que ser definidos globalmente; no pueden ser definidos dentro de una función.
5.7. Resumen
Echemos un vistazo rápido a lo que hemos cubierto en este capítulo, junto con algunos consejos adicionales.

• Las variables son como cestas que pueden contener datos de diferentes tipos.
• Una constante es una variable cuyo valor no puede cambiarse en tiempo de ejecución.
• Las variables integrales pueden contener números positivos o negativos, dependiendo de si las declaras con o sin signo, pero sólo sin decimales.
• Las variables de coma flotante pueden contener números positivos o negativos, con o sin decimales.
• Puedes realizar operaciones aritméticas sobre variables numéricas como 3+5=8, tanto utilizando variables referenciadas por su nombre como valores literales.
• Si no conoce los valores que se almacenarán en una variable numérica, es mejor utilizar un doble.
• Mantenga siempre un registro de sus variables, o puede terminar con resultados inesperados si se excede el límite.
• Las cadenas son una lista de caracteres que forman algo útil.
• Puede ensamblar cadenas para formar otras nuevas combinando variables referenciadas por su nombre, con valores literales entre comillas.
• Sumando dos variables numéricas juntas, ambas con el valor de 1, será 2.
• Si se suman dos variables de cadena, ambas con el valor "1" (fíjate en las comillas), se obtendrá 11.
• Las variables son uno de los fundamentos del desarrollo de juegos, y de la programación en general.
• Las variables y constantes en BGT distinguen entre mayúsculas y minúsculas. Por lo tanto, tienes que referirte a ellas exactamente como las has declarado o como aparecen en la documentación.
Naturalmente la impresión será la misma, el script es sólo una línea más corta.

me lo guardo, hasta que por fin haces algo por la comunidad OK no. ñladsfjk

hola chicos. aquí les traigo la tercera parte de este manual traducida completamente. en esta ocasión, les traigo las funciones .
así que... comenzemos con la teoría xd.
6. Funciones
Ya hemos visto varios ejemplos de llamadas a funciones. En nuestro primer ejemplo llamamos a la función de alerta cuando queríamos imprimir un mensaje en la pantalla. Ahora, creo que es el momento de profundizar un poco más en lo que respecta a las funciones, ya que se utilizan literalmente en todos los juegos del mercado. Una función es un trozo de código al que se puede hacer referencia con un nombre. Por ejemplo, puedes tener una función llamada salto que hace que el jugador, sí, salte. Cada vez que quieras que el jugador salte, llamarás a esta función y se ejecutará el código que contiene. Las funciones son una gran ayuda porque no sólo te permiten estructurar tu programa de una manera más lógica, sino que también te permiten reutilizar la misma sección de código varias veces sin tener que escribirla o pegarla cada vez que quieras que se ejecute.

Todas las funciones que hemos llamado hasta ahora han sido parte del propio motor BGT, pero también puedes hacer tus propias funciones para lograr cosas. De hecho, hay una función que debes crear antes de que el motor acepte tu código. La sección principal de tu código va aquí. Aquí es donde se llaman las funciones adicionales, ya sean funciones del motor BGT, de otros scripts que se incluyen, o de sus propias funciones contenidas en el script actual. Debido a que esta función es donde se almacena todo su código principal, esta función se llama main. Ya vimos brevemente esta función cuando hablamos de imprimir un mensaje en la pantalla.
Como de costumbre, veremos cómo se hace en la práctica antes de que se le duche una vez más con un nuevo gran trozo de jerigonza teórica.
void main()
{
alert("Test", "We are now using the main function.");
}
No es necesario que llame a esta función usted mismo, ya que el motor utiliza esta función como punto de partida.
La palabra "void" indica que una función no tiene tipo de retorno. Discutiremos el retorno más adelante en este capítulo. A continuación, tiene el nombre de la función y, finalmente, una lista de parámetros entre paréntesis. La función principal no toma parámetros, por lo que la lista de parámetros está vacía. Dentro de la función sólo mostramos otro cuadro de alerta y luego le decimos al intérprete BGT que nuestra función ha terminado usando un carácter de corchete derecho. Así de sencillo. Casi...

Para ser útiles, muchas funciones necesitan tomar parámetros. La función aleatoria en el motor BGT, por ejemplo, necesita tomar un número mínimo y máximo que se le permite generar. Tus propias funciones también pueden tomar parámetros, y se colocan entre el paréntesis izquierdo y el derecho cuando haces la función. Echemos un vistazo a una función que suma dos números y luego devuelve el valor a quien la llama.
void main()
{
int x=add_numbers(3, 5);
alert("Wow", "3 + 5 is... " + x + "!");
}
int add_numbers(int first, int second)
{
int result=first+second;
return result;
}
Este ejemplo introduce varias cosas nuevas. En primer lugar, muestra cómo puedes recibir parámetros en tus funciones. Lo haces especificando nombres de variables cuando creas la función, en este caso elegí primera y segunda para los dos números. Luego, cada vez que llamas a esta función los dos parámetros que le pasas se colocan en las dos variables correspondientes. Esto significa que la variable llamada first recibe el primer parámetro, y la llamada second recibe el segundo. Por supuesto, puedes nombrar los parámetros de la función como quieras, siempre que sean nombres de variables legales. También vemos cómo una función puede devolver un valor a quien la llama utilizando la sentencia return. La sentencia return interrumpirá la función por completo y devolverá el valor o la variable dada después del espacio, que la persona que llama puede capturar asignando el valor de retorno de la función a una nueva variable como vimos al principio del ejemplo. En nuestro caso utilizamos la variable x para obtener nuestro valor de vuelta de la función, y luego lo imprimimos en un cuadro de alerta normal.
También habrás notado que no comenzamos la declaración de la función con la palabra "void", sino con la palabra "int". La palabra "void" es una palabra clave que sólo se utiliza al comienzo de las funciones para indicar al motor que esta función no devuelve ningún dato, aunque la palabra clave "return" puede utilizarse por sí sola para salir de una función, es decir, para terminar prematuramente su ejecución. Como devolvemos el resultado de una suma, le decimos al motor que queremos devolver un int.
Una declaración de función comienza con el tipo de datos requerido para el retorno, como se cubre en variables, con la palabra clave adicional de void. A continuación, damos un nombre a nuestra función. Justo después, están nuestros parámetros, separados por comas y encerrados entre paréntesis. A continuación se abre un corchete, ya que una función es un bloque de código.
No sólo se pueden devolver variables desde una función, sino también valores literales. Lo mostramos, por supuesto, con otro ejemplo.
void main()
{
string x=string_magic();
alert("Result", "The string given is: " + x + ".");
}
string string_magic()
{
return "wow";
}
Esta, como habrás notado, es una función completamente inútil. No toma parámetros, y sólo devuelve una cadena literal. Sin embargo, es de suma importancia que entiendas completamente el concepto de las funciones antes de empezar a escribir juegos propiamente dichos. Por esta razón, te voy a presentar otro ejemplo. Volvamos a nuestra interesantísima función de suma de números, pero con un pequeño giro.
void main()
{
alert("Wow", "3 + 5 is... " + add_numbers(3, 5) + "!");
}
int add_numbers(int first, int second)
{
return first+second;
}
La salida es exactamente la misma que antes, nuestro script es sólo dos líneas más corto. Lo único que hemos hecho es eliminar dos variables que no eran del todo necesarias pero que probablemente han hecho las cosas un poco más fáciles de seguir. En lugar de asignar el valor de retorno de la función a nuestra variable x lo imprimimos directamente en la llamada a la función de alerta. Así que, como puedes ver, no es un problema tener una llamada a una función dentro de otra llamada a una función. Puedes anidar tantas llamadas a funciones como desees, hasta llegar a 10000 llamadas en cuyo momento el intérprete BGT no estará muy contento contigo. Vamos a ver el ejemplo de la función string_magic una vez más, pero con otro giro. No incluiremos la función main en todos los ejemplos, con tal de que sepas que cualquier código que no pertenezca a otra función va en void main.
//función principal
alert("Result", string_magic() + string_magic() + string_magic());
string string_magic()
{
return "wow";
}
Sí, lo sé, otra vez sin sentido. La salida de este script es "wowwowwow". Sólo muestra otra forma en la que puedes llamar a una función desde dentro de una llamada a otra función y así sucesivamente. También está bien llamar a una función dentro del cuerpo de otra función. Una función puede incluso llamarse a sí misma, pero ten cuidado con esto ya que puede causar el llamado desbordamiento de la pila donde se hacen demasiadas llamadas a funciones anidadas una encima de la otra si escribes tu script incorrectamente. El límite para esto es, como se mencionó anteriormente, 10000 llamadas anidadas.

Todas las variables que se declaran en la parte superior del script antes de que aparezca la primera función, se consideran globales. Se puede acceder a ellas desde dentro de cualquier función a lo largo del script. Sin embargo, las nuevas variables que se declaran dentro de una función son locales sólo para esa función. Esto significa que si tienes una variable local que almacena alguna información y luego la función sale, esa variable se perderá a menos que se utilice como valor de retorno de la función. Por lo tanto, cualquier información a la que desees acceder en más de una función debe ser almacenada en una o más variables públicas, a menos que desees pasarlas como parámetros entre todas tus funciones, lo que generalmente no es recomendable.
Ya deberías saber que cualquier trozo grande de teoría suele ir seguido de un ejemplo, así que allá vamos.
// Hagamos unas cuantas variables globales.
string my_name="John Doe";
int number_of_fingers=5;
void main()
{
my_first_function();
}
void my_first_function()
{
//The variables that we make now are local.
int number_of_hands=2;
int number_of_pets=13;

//Now we are modifying the global variable my_name from inside this function.
my_name="Rodney";
}

Te concedo que este era un ejemplo muy tonto, pero sirve su propósito no obstante. Como has visto, todas las variables que se declararon en la parte superior del script eran accesibles desde dentro de nuestra función, mientras que las declaradas dentro de ella sólo son accesibles desde la propia función. Por lo tanto, no habría sido legal modificar el valor de número_de_mascotas dentro de otra función a menos que, por supuesto, declararas una con el mismo nombre allí.

Una función sólo puede devolver un valor. No tendría sentido hacer lo siguiente:
int my_function()
{
return 3;
return 5;
}

Como se mencionó antes, la palabra clave return devolverá el valor, si lo hay, destruirá todas las variables de la función y no tendrá en cuenta ningún otro código en esa función. Así, la función sólo devolvería 3. Sin embargo, hay una manera de resolver esto en caso de que necesite devolver múltiples valores.
Los parámetros normalmente se pasan a una función por valor. Esto significa que, si pasas una variable como parámetro a tu función, el intérprete leerá el valor de esa variable y lo pasará a la función. Este es un ejemplo.

//función principal
int x=5;
my_function(x);

El intérprete crearía una variable de tipo int llamada x y le asignaría el número 5. A continuación, comprobaría el valor de x, que posteriormente es 5, y llamaría a mi_función, pasando 5 como parámetro.

Sin embargo, los parámetros también se pueden pasar a la función por referencia. En lugar de que el intérprete lea nuestra variable y la pase a la función, se pasará la propia variable. Esto significa que si la función modifica la variable, la modificación también se aplicará a la original. De este modo, podemos devolver fácilmente más de un valor de una función modificando nuestras variables por referencia. Otro ejemplo:

//Variables globales
int x=1;
int y=2;

//Main function
my_function(x, y);

void my_function(int &out first, int &out second)
{
first=5+5;
second=5*5;
}

Quizá te preguntes por qué hemos utilizado void. Esto se debe a que, como hemos explicado antes, estamos devolviendo valores a través de nuestros parámetros, y no la función en sí misma. Si has comprobado el valor de x e y ahora, ya no son 1 y 2, son 10 y 25.
La otra cosa que puede haber notado es que después de los tipos de datos de nuestros parámetros, ponemos &out (el signo ampersand seguido inmediatamente por la palabra out). El ampersand indica al intérprete que estamos a punto de especificar cómo se pasará el parámetro. Si no se encuentra el signo & (ampersand), el intérprete asumirá la bandera &in, lo que significa que estamos pasando los parámetros por valor.
Cuando pasamos parámetros por referencia, se requiere pasar una variable en lugar de una constante. El intérprete no le impedirá pasar una constante, pero emitirá una advertencia indicando que cualquier cambio que se realice se perderá.

Hay que tener en cuenta que no se puede duplicar la declaración de una función, ya que no serviría de nada. Sin embargo, una función puede declararse varias veces siempre que los parámetros sean diferentes en cada declaración. Esto se llama una función sobrecargada, y se muestra con más ejemplos.

//función principal
string text=my_function("Daniel", 5);

int my_function(int first, int second)
{
return first+second;
}
string my_function(string your_name, int number)
{
return "Hello there, "+your_name+". There are "+number+" people waiting for you downstairs.";
}
Como hemos llamado a mi_función con una cadena como primer parámetro, el intérprete llamará a nuestra segunda declaración de mi_función.

También es posible dar a los argumentos de la función valores por defecto. Esto significa simplemente que no tienes que pasar el conjunto completo de parámetros que la función espera, sino que pasas sólo unos pocos y la función entonces es llamada con valores por defecto para los otros opcionales. A continuación, un ejemplo:
void main()
{
print("Hello!", 10, 20, 30);
print("Hello again!", 10);
}

void print(string title, int value1=0, int value2=0, int value3=0)
{
alert(title, "Value 1 is " + value1 + ", value 2 is " + value2 + ", and value 3 is " + value3 + ".");
}
Aquí declaramos una función llamada print, que toma cuatro argumentos. El primero es una cadena que se utiliza para el título del mensaje que mostramos, y este argumento es obligatorio. Lo vemos porque no tiene ningún valor por defecto después del nombre del argumento. Para los otros tres valores, sin embargo, tenemos un signo = después del nombre y luego un valor que será el predeterminado si este argumento no es especificado por la persona que llama. Vemos en nuestro ejemplo que la primera llamada a print especifica los cuatro parámetros, mientras que la segunda llamada sólo especifica dos de ellos. Por lo tanto, en el segundo mensaje que se muestra, los dos últimos enteros se ponen a 0.

Es posible tener tantos parámetros opcionales como se desee en una función determinada. Sin embargo, tenga en cuenta que no es posible tener un parámetro obligatorio después de uno opcional. Todos los parámetros obligatorios deben ir antes del primer parámetro opcional, o de lo contrario el compilador se verá en una situación imposible si pasa muy pocos parámetros cuando quedan los obligatorios.
.
Es muy importante que entiendas bien estos conceptos antes de seguir con este tutorial. En este punto, te sugiero que vayas y estudies algunas de las cosas en la referencia de la función y veas si tienen un sentido completo. Si no lo tienen, es posible que quieras volver a leer este capítulo hasta que todo encaje.

asñlkjdfas alfín que haces algo bueno, amigo. asñkljfdajñslkdf

hum, odio bgt y no creo que a este punto le traiga algo bueno a la comunidad... pero ala, creo que tu idea es buena. ojalá pudieras hacerlo para otros lenguajes más útiles, donde la documentación es abundante, y mayoritariamente en inglés jaja. pero igual, me gusta la idea, aunque el lenguaje no. Está interesante.

gracias amigo,, tras acavar con este pienso ponerme con autoit. pero me gusta hacer una cosa a la vez xd.

creo que autit si está traducido, podrías no sé, python? pero ala, es una sugerencia, igual la idea me parece perfecta jaja.

si yo también recomiendo python jaja

Hola. Tampoco bgt es de mis lenguajes favoritos, pero me gusta el esfuerzo que hacés para traducir el manual. Asumo que es todo a mano, no?
incluso con las limitaciones que bgt pueda llegar a tener, no es un mal lenguaje por si alguien quiere iniciarse en todo esto.

auto IT es un buen lenguaje, pero que cada quien aprenda lo que quiera, solo son sujerencias.

el no lo tradujo, el manual traducido de b g t anda rondando por los pm, pero el tubo la gentileza de publicarlo en un hilo público.

a, es la traducción que había hecho este Oriol Gómez, no? si, pero creo que no está completo.

no, no está.

el manual no está completo, fingwe por favor, me lo podrías pasar para analizarlo si está realmente completo? que yo tengo el manual en inglés

Sigue mejor con las partes que anda pasando de rato en rato, así practican cada parte, se la tienen bien, y además para evitar si el mío tiene alguno que otro error

allí te equivocas fingwe, yo estoy traduciendo este manual desde cero a mano. y no quiero hacer pelea, pero de verdad como jode que alguien se esfuerce y venga otro que no save y diga no, es que este no hizo nada, se está rascando las pelotas cuando me paso oras traduciendo cada parte. si es cierto que oriol tradujo cosas del manual, pero yo no voy a dejar esto a medias. planeo traducir aún que sea todo el manual (no 7 partes) y luego pasar a los references y a los apendix. si tanto quieren darles créditos a otros, denles. yo traduzco para aquellos que como yo necesitaron o necesiten ayuda y no ayan sabido inglés, y quiero hacer algo bueno. pero por gente que desmotiva que quita esfuerzo y trata de menospreciar ha alguien por el simple echo de que? de pensar que está atribulléndose una cosa?
yo trato de ayudar. ahora. si quieren venir a joder háganlo, mi motivación es firme. seguiré traduciendo. que bgt no sea el mejor lenguaje no significa que sea malo, si muchos juegos de los que juegan están en bgt... y luego es su juego favorito... solo lo dejo caer por aquí. luego comienzaré con python, o quizá lo aré en otro ilo de forma alternada, yo que se. pero porfavor, antes de menospreciar el esfuerzo de alguien pregunten. gracias y saludos.
pd: el capítulo de las condicionales estará en breves.

joder, que siempre tiene que haber uno que la cague, perdón por la palabra. amigo @el rompedor. qué decirte? no te desanimes por este tipo de personas. la rompiste tal como lo dice tu nick jaja, alto aporte. Yo no estoy de acuerdo con los que dicen que bgt murió o que no es productivo aprenderlo. Aún se pueden programar juegos en él? si. quedará obsoleto pronto? si, pero basta con tener windows diez para abajo y listo, a seguir jugando. lo detectan los virus? si, pero agregas un juego a la lista de exclusiones del antivirus y solucionado. Y para terminar, los mejores juegos online y offline que tenemos en el mercado inglés, son hechos en bgt. paladin of the sky, manamon1 y 2, en fin, todos los de vg storm. Online? batalla constante amí no me gusta, pero así como está en bgt trae hasta 200 usuarios por día o más. survive the wild, tiene seis años y sigue actualizándose. no se dejen llevar porque gente crea que simplemente no es buena idea aprenderlo porque es antiguo. Es fácil y creo yo que si no va a durar mucho, por lo menos para arrancar con un lenguaje básico, para mi está perfecto. reitero, sigue así@elrompedor, te pasaste jaja. gracias por los manuales. en lo personal sé inglés y pues me gusta mucho aprenderlo así, pero tenía que venir a felicitar al proyecto de todos modos.

va, si: yo le pedí que me pasara el manual... pero es de esa gente que tira la piedra y esconde la mano. perdón por la palabra.

Eso tradúcelo todo porque si falt amucho por traducir, en especial las referencias.
Y aquí està el tutorial para el que lo pedía. Solo está el tutorial del lenguaje, no está las referencias, solo está el lenguaje.
https://www.dropbox.com/s/j2nexetkalxjtq2/tutorial%20del%20lenguaje.txt?dl=1

De igual manera les recomiendo solo bajarlo para aclarar alguna duda que tengan, porque es mejor que el se los pase parte por parte, y para evitar problemas y confuciones de traducción
Y ademmás para que practiquen y no corran en su aprendizaje.

igual, no hay mejor manual que el bgt.chm el cuál se encuentra en el directorio de instalación, y no hay mejor cosa al querer aprender que tener ganas y no querer todo funcionando al 100 recién terminando de escribir code (más siendo principiante).

buena rompedor si que es genial, no sé que exactamente es bgt pero si me permite hacer un manamon 3, 4 y 5 por mi cuenta encantado de aprender, enserio gracias, gracias por traducirlo, y que lo disfruten aquellos que les guste y pues si no les agrada ese sistema o lo que sea que sea exactamente pues que no desanimen al muchacho que desea solo compartir y gratis, no gana nada haciendo esto pero ahí esta haciéndolo aún

si necesitas la historia yo aporto xd

muchas gracias chicos. gracias por seguir motivándome a seguir con esto. saludos. pd: en breves estará disponible la parte de condicionales.

Te felicito @el rompedor, seguí traduciendo que te sigo de cerca.