This shows you the differences between the selected revision and the current
version of the page.
es:wmebook:ch2 2013/04/07 17:33 | es:wmebook:ch2 2013/04/08 00:19 current | ||
---|---|---|---|
Line 1: | Line 1: | ||
- | =====2. Guía para el sobreviviente de WME scripting===== | + | =====2. Guía para sobrevivir a la creación de scripts con WME===== |
Line 250: | Line 250: | ||
Hemos visto lo básico de las variables, hay mucho mas sobre ellas, pero lo iremos viendo | Hemos visto lo básico de las variables, hay mucho mas sobre ellas, pero lo iremos viendo | ||
conforme vayamos avanzando. | conforme vayamos avanzando. | ||
+ | |||
+ | |||
+ | =====2.1 Arrays mágicos===== | ||
+ | |||
+ | Antes de empezar a hablar de los arrays, vamos a ver un ejemplo que se podría dar en un | ||
+ | juego real. Imagina que tienes una puerta protegida con un panel de código. Tienes que pulsar | ||
+ | cuatro números correctos y entonces las puertas se abren. Hay varias formas de hacer esto, | ||
+ | veamos un par de ellas. | ||
+ | |||
+ | **Mala elección** | ||
+ | |||
+ | Con lo visto en el capítulo anterior, probablemente, lo harías creando 4 variables( por ejemplo | ||
+ | codigo1, codigo2, codigo3, codigo4) y les distes el valor de los números a pulsar para la | ||
+ | combinación correcta. Entonces tendrás que comprobar una a una para ver si coinciden. | ||
+ | Parece buena idea, pero esto se hace tedioso y es preferible usar otras alternativas. | ||
+ | |||
+ | **Elección complicada** | ||
+ | |||
+ | Esta es la forma optima de hacerlo, pero es mas complicada.Puedes usar solo una variable y | ||
+ | mediante operaciones matemáticas construir el número a comparar con el que se requiera para | ||
+ | abrir la puerta. | ||
+ | |||
+ | Bueno es complicada porque no todos somos buenos en matemáticas o ingeniosos para crear | ||
+ | las funciones. ;) | ||
+ | |||
+ | **Elección acertada** | ||
+ | |||
+ | Usa un array. | ||
+ | |||
+ | Un array es una variable pero en la que puedes guardar mas de un dato. | ||
+ | |||
+ | Imagina un mueble con varios cajones, y en cada cajón se puede guardar un calcetín, pues en | ||
+ | el primer cajón guardamos un calcetín rojo, en el segundo uno verde, en el tercero uno | ||
+ | amarillo, y así... Cuando queramos el calcetín rojo, iremos al cajón 1 del mueble. Pues esto es | ||
+ | una analogía con lo que es un array. | ||
+ | |||
+ | En términos técnicos y siguiendo la traducción, imagina un array como un grupo de variables. | ||
+ | Puedes hacer referencia a estas variables indexando la posición en la variable que declaramos | ||
+ | como array. Con un ejemplo lo veremos mejor. Bien, definamos una variable miArray y 3 casillas. | ||
+ | |||
+ | <code script> | ||
+ | var miArray; | ||
+ | miArray[0]=”hola mundo”; | ||
+ | miArray[1]=”este es mi primer array”; | ||
+ | miArray[3]=”weeeee!!”; | ||
+ | |||
+ | Game.Msg(miArray[0]); // imprime hola mundo | ||
+ | |||
+ | Game.Msg(miArray[1]); // imprime este es mi primer array | ||
+ | |||
+ | Game.Msg(miArray[2]); // imprime weeeee!! | ||
+ | </code> | ||
+ | |||
+ | Otro ejemplo de acceso al array mediante una variable: | ||
+ | |||
+ | <code script> | ||
+ | var a=1; | ||
+ | Game.Msg(miArray[a]); // imprime por pantalla este es mi primer array | ||
+ | </code> | ||
+ | |||
+ | **Cuarta regla de sintaxis** | ||
+ | |||
+ | Para acceder al array lo haremos accediendo a sus posiciones poniendo la posición a la que | ||
+ | queremos acceder entre corchetes, precedido del nombre del array. | ||
+ | |||
+ | <code script> | ||
+ | nombreArray[posicionRequerida]; | ||
+ | </code> | ||
+ | |||
+ | Volvamos al ejemplo del código de la puerta, fácilmente podemos almacenar todo el código en | ||
+ | una sola variable, con los valores correctos que el jugador debe pulsar para que la puerta se | ||
+ | abra. | ||
+ | |||
+ | Por ejemplo: | ||
+ | |||
+ | <code script> | ||
+ | var codigo;//declaramos la variable | ||
+ | codigo[0]=5;//guardamos un 5 en la posición 0 | ||
+ | codigo[1]=3;//guardamos un 3 en la posición 1 | ||
+ | codigo[2]=1;//guardamos un 1 en la posición 2 | ||
+ | codigo[3]=0;//guardamos un 0 en la posición 3 | ||
+ | </code> | ||
+ | |||
+ | De esta manera, tenemos varios valores en la misma variable. Y la óptima pero como ya | ||
+ | comentamos, era mediante operaciones podría ser del siguiente modo: | ||
+ | |||
+ | <code script> | ||
+ | var codigo=5;//asignamos 5 a la variable código | ||
+ | codigo=codigo-2;// 5-2 = 3 | ||
+ | codigo=codigo-2;// 3-2 = 1 | ||
+ | codigo=codigo-1;// 1-1 = 0 | ||
+ | </code> | ||
+ | |||
+ | De esta manera también obtendríamos el código 5310 pero es mas intrincado. Como veis para | ||
+ | facilitarnos las cosas, los arrays son muy útiles. | ||
+ | |||
+ | Por supuesto, si puedes y eres capaz, puedes usar códigos para la puerta mucho mas | ||
+ | complejos, estos solo son ejemplos simples, por ejemplo, puedes hacer que el código cambie | ||
+ | según algún evento del la hora que hay en un reloj de la pared, ya es cosa de imaginación. | ||
+ | |||
+ | Conforme vallas programando, encontraras muchos usos diferentes para los arrays, la fuerza | ||
+ | de los arrays reside en la indexación. Puedes acceder a cualquier valor del array durante la | ||
+ | programación, pero lo veremos con un ejemplo. | ||
+ | |||
+ | Quizá hayas visto juegos, en los que obtienes distintas respuestas para una misma acción sino | ||
+ | fuera así, seria muy aburrido. Bien veamos como solucionarlo usando un array. Incorporaremos | ||
+ | una nueva instrucción llamada Ramdom. | ||
+ | |||
+ | **Ramdom** es una función que devuelve un número aleatorio dentro de un rango. | ||
+ | Hablaremos sobre las funciones mas adelante, por el momento no te preocupes si algo no se | ||
+ | entiende, mas adelante se entenderá. | ||
+ | |||
+ | <code script> | ||
+ | var arrayRespuestas; | ||
+ | arrayRespuestas[0]=”esta bloqueado”; | ||
+ | arrayRespuestas[1]=”no puedo moverlo”; | ||
+ | arrayRespuestas[2]=”no hay nada que hacer”; | ||
+ | var respuesta = Random(0,2); //número aleatorio entre 0 y 2 | ||
+ | Game.Msg(arrayRespuestas[respuesta]); | ||
+ | </code> | ||
+ | |||
+ | Este script básicamente, lo que hace es que cuando realizamos una acción sobre algo, nos | ||
+ | devuelva una respuesta aleatoria desde 3 posibles. | ||
+ | |||
+ | Bueno ya hemos visto lo básico de los arrays, mas adelante haremos referencias a ellos para ir | ||
+ | viendo las funcionalidades de los scripts en WME. | ||
+ | |||
+ | |||
+ | |||
+ | |||
+ | |||
+ | |||
+ | =====2.2 Condiciones ===== | ||
+ | |||
+ | A menudo necesitamos saber que esta pasando, volvamos al ejemplo de la puerta que se abre | ||
+ | con un botón, necesitamos saber si el botón esta presionado o no. pero ¿como lo | ||
+ | comprobamos? | ||
+ | |||
+ | Pues tenemos una instrucción condicional( if ) que nos facilitará el trabajo. Lo mejor un | ||
+ | ejemplo: | ||
+ | |||
+ | <code script> | ||
+ | var a=1; | ||
+ | if( a == 1 ) Game.Msg(“A es igual a 1”); | ||
+ | </code> | ||
+ | |||
+ | Esto pregunta ¿a es igual a 1?, como le dimos ese valor, la condición se cumple y se muestra en | ||
+ | pantalla el mensaje A es igual a 1. | ||
+ | |||
+ | En el ejemplo anterior, podemos ver perfectamente como funciona las condiciones. | ||
+ | |||
+ | Como puedes ver, la condición va entre paréntesis. | ||
+ | |||
+ | <code script> | ||
+ | if( aquí va la condición) acción a realizar si se cumple la condición; | ||
+ | </code> | ||
+ | |||
+ | Veamos los operadores condicionales posible: | ||
+ | |||
+ | 1.- Si quieres saber si una variable es igual a otra, o a un valor. | ||
+ | |||
+ | <code script> | ||
+ | if(variable o valor == variable o valor) acción; | ||
+ | </code> | ||
+ | |||
+ | Ejemplo: | ||
+ | |||
+ | <code script> | ||
+ | if( a == 1) acción; | ||
+ | </code> | ||
+ | |||
+ | 2.- Si quieres saber si una variable es distinta de otra o de un valor. | ||
+ | |||
+ | <code script> | ||
+ | if(variable o valor != variable o valor) accion; | ||
+ | </code> | ||
+ | |||
+ | Ejemplo: | ||
+ | |||
+ | <code script> | ||
+ | if(a != 1) accion; | ||
+ | </code> | ||
+ | |||
+ | 3.- Si quieres saber si algo es mayor que un valor. | ||
+ | |||
+ | <code script> | ||
+ | if(variable o valor > variable o valor) accion; | ||
+ | </code> | ||
+ | |||
+ | Ejemplo: | ||
+ | |||
+ | <code script> | ||
+ | if(a > 5) accion; | ||
+ | </code> | ||
+ | |||
+ | 4.- Si quieres saber si algo es menor que algún valor. | ||
+ | |||
+ | <code script> | ||
+ | if(variable o valor < variable o valor) accion; | ||
+ | </code> | ||
+ | |||
+ | Ejemplo: | ||
+ | |||
+ | <code script> | ||
+ | if(5 < a) accion; | ||
+ | </code> | ||
+ | |||
+ | 5.- Si quieres saber si algo es mayor o igual que algún valor. | ||
+ | |||
+ | <code script> | ||
+ | if(variable o valor >= variable o valor) acción; | ||
+ | </code> | ||
+ | |||
+ | Ejemplo: | ||
+ | |||
+ | <code script> | ||
+ | if(5 >= a) acción; | ||
+ | </code> | ||
+ | |||
+ | 6.- Si quieres saber si algo es menor o igual que algún valor. | ||
+ | |||
+ | <code script> | ||
+ | if(variable o valor <= variable o valor) acción; | ||
+ | </code> | ||
+ | |||
+ | Ejemplo: | ||
+ | |||
+ | <code script> | ||
+ | if(5 >= a) acción; | ||
+ | </code> | ||
+ | |||
+ | Como vimos al principio, hablamos de las variables booleanas, eran variables que solo podían | ||
+ | tomar el valor verdadero o falso. | ||
+ | |||
+ | Pues una condición no es mas que uno de estos valores. Un ejemplo: | ||
+ | |||
+ | <code script> | ||
+ | var a=5; | ||
+ | if(a==5) acción; | ||
+ | </code> | ||
+ | |||
+ | La condición funciona de la siguiente manera, tiene a el mismo valor que 5, como le dimos ese | ||
+ | valor esta condición sera verdadera es decir, true, uno de los valores que se puede usar en las | ||
+ | condiciones. | ||
+ | |||
+ | Para variables booleanas(true o false), podemos hacerlo mediante un atajo: | ||
+ | |||
+ | <code script> | ||
+ | a=true; | ||
+ | if(a) acción; //la acción se ejecuta, ya que a = true | ||
+ | </code> | ||
+ | |||
+ | Veamos si es falsa | ||
+ | |||
+ | <code script> | ||
+ | a=false; | ||
+ | if(a) acción; // la acción no se ejecuta, ya que a=false | ||
+ | </code> | ||
+ | |||
+ | Pero la diversión no acaba aquí, podemos generar condiciones mucho mas complicadas, pero | ||
+ | para entenderlo, volvamos al principio, nuestra condicion “if(a == 1)” si asignamos el valor 1 | ||
+ | a la variable “a”, la condición podría leerse como ¿es 1 igual a 1? esta condición es verdadera | ||
+ | y la acción es ejecutada. | ||
+ | |||
+ | Si asignamos el valor 2 a la variable “a”, la condición se leería como, ¿es 2 igual a 1? en este | ||
+ | caso, la condición es falsa y la acción no se ejecutará. | ||
+ | |||
+ | Esta lógica condicional es muy habitual en la programación de ordenadores. Los programas | ||
+ | están cargados de estas condiciones, y son fundamentales para la programación, y es | ||
+ | necesario aprenderlo bien para usarlo correctamente. | ||
+ | |||
+ | WME lee la condición y realiza una evaluación, si la condición es verdadera, se ejecuta la | ||
+ | instrucción, y si la condición es falsa, la instrucción no se ejecuta y el programa sigue | ||
+ | adelante. Veamos como: | ||
+ | |||
+ | Volviendo a nuestro ejemplo real del botón que abre la puerta cuando es pulsado, debemos | ||
+ | usar un script para controlar si el botón esta pulsado o no: | ||
+ | |||
+ | <code script> | ||
+ | global botonPulsado=true; | ||
+ | </code> | ||
+ | |||
+ | Esta linea se encontrará en el script del botón, o de la escena donde este el botón. | ||
+ | |||
+ | <code script> | ||
+ | global botonPulsado; | ||
+ | if(botonPulsado) acción que abre la puerta; | ||
+ | </code> | ||
+ | |||
+ | Estas lineas estarán ubicadas en el script de la puerta, o de la escena donde se encuentre la | ||
+ | puerta. | ||
+ | |||
+ | Ya que hemos visto lo básico de las condiciones, podemos unir varias condiciones y evaluar | ||
+ | mas de una misma cosa al mismo tiempo en una condición. | ||
+ | |||
+ | **1.- Operador &&** | ||
+ | |||
+ | Sirve para enlazar condiciones verdaderas, este operador hace la función del Y lógico, el Y | ||
+ | lógico lo usamos cuando queremos que se cumplan varias condiciones al mismo tiempo para | ||
+ | que se realice la acción: | ||
+ | |||
+ | <code script> | ||
+ | if( a > 1 && a < 10) acción; | ||
+ | </code> | ||
+ | |||
+ | En esta condición podemos ver el uso del &&, la condición se leería de la siguiente manera, es | ||
+ | “a” mayor que 1 y “a” menor que 10, si ambas condiciones se cumplen la acción es ejecutada, | ||
+ | si alguna de las dos condiciones es falsa, la acción no es ejecutada. | ||
+ | |||
+ | **2.- Operador ||** | ||
+ | |||
+ | Este operador hace la función lógica O, esta la usamos cuando tenemos varias condiciones, | ||
+ | pero con que se cumpla una de ellas, la acción es ejecutada: | ||
+ | |||
+ | <code script> | ||
+ | if( a == “jhon” || b == 10 ) acción; | ||
+ | </code> | ||
+ | |||
+ | Esta condición se leería de la siguiente manera es “a” igual a jhon o “b” igual a 10, con que una | ||
+ | de las dos condiciones anteriores se cumpliera, la acción se ejecutaría. | ||
+ | |||
+ | Si queremos agrupar condiciones, podemos usar paréntesis para la precedencia, o para tener | ||
+ | claridad, por ejemplo: | ||
+ | |||
+ | <code script> | ||
+ | if ( ( a > 1 && a < 10 ) || (b ==”jhon” ) ) accion; | ||
+ | </code> | ||
+ | |||
+ | Como veis podemos crear condiciones bastantes complejas, en este caso la acción se ejecutará | ||
+ | si “a” es mayor que 1 y “a” menor que 10 o “b” es igual a jhon, de esta manera enlazamos | ||
+ | condiciones para asegurarnos que se cumplen los requisitos que requerimos para que una | ||
+ | serie de instrucciones se ejecuten. Si se cumplieran las dos, es decir que “a” esta entre 1 y 10 y | ||
+ | la “b” es igual a jhon, la acción también se ejecutaría. En este caso solo sería falsa si ambos | ||
+ | operandos de la condición son falsos. | ||
+ | |||
+ | **Un consejo:** Es posible generar condiciones muy complejas. Es cuestión de trabajarlas, y | ||
+ | siempre preguntarse ¿que tiene que ocurrir para que pase esto? De esta manera se nos | ||
+ | facilitará la creación de nuestras propias condiciones. | ||
+ | |||
+ | Por ejemplo ¿que tiene que ocurrir para que se abra la puerta? Pues tiene que ocurrir que el | ||
+ | botón este pulsado, pues ya sabemos que en la condición debemos introducir algo que nos diga | ||
+ | si el botón esta pulsado o no. | ||
+ | |||
+ | **Quinta regla de sintaxis** | ||
+ | |||
+ | Si quieres ejecutar múltiples comandos cuando se cumple una condición, encerraremos la | ||
+ | acciones entre llaves: | ||
+ | |||
+ | <code script> | ||
+ | if(a == 2) | ||
+ | { | ||
+ | Game.Msg(“hola!”); | ||
+ | Game.Msg(“hola otra vez”); | ||
+ | } | ||
+ | </code> | ||
+ | |||
+ | En este caso, si la condición a == 2 se cumple, se ejecutan las dos acciones que se encuentran | ||
+ | encerrada entre las llaves. | ||
+ | |||
+ | Ahora imagina que tienes una condición que cuando se cumple se ejecuta una acción, pero | ||
+ | imagina que también quieres que se ejecute algo cuando la condición es falsa, pues bien, en | ||
+ | este caso usamos la palabra reservada else. Veamos un script de ejemplo: | ||
+ | |||
+ | <code script> | ||
+ | var a=1; | ||
+ | if( a == 0) | ||
+ | { | ||
+ | Game.Msg(“este texto sale en pantalla si la condición es verdadera”); | ||
+ | a = 10; | ||
+ | } | ||
+ | else | ||
+ | { | ||
+ | Game.Msg(“este texto sale en pantalla si la condición es falsa”); | ||
+ | } | ||
+ | </code> | ||
+ | |||
+ | Esto es una sentencia condicional(if) totalmente definida, ya que es capaz de responder a cualquier estado | ||
+ | de la condición, si es verdadera se ejecuta el primer bloque de instrucciones, y si es falsa, se | ||
+ | ejecuta el segundo bloque. | ||
+ | |||
+ | Cuando tratemos con que la condición puede llevar varios estados, es decir si por ejemplo | ||
+ | tenemos una variable numérica, y queremos que por ejemplo para el valor 1 haga una cosa, | ||
+ | para el valor 2 haga otra diferente, para el valor 3 otra acción, etc pues se usa la sentencia | ||
+ | “switch” Veamos un ejemplo con un script: | ||
+ | |||
+ | <code script> | ||
+ | var a= Random(0,3); //almacenamos en a un numero aleatorio entre 0 y 3. | ||
+ | var b=””; //declaramos variable b con una cadena vacia. | ||
+ | switch(a) | ||
+ | { | ||
+ | case 0: | ||
+ | Game.Msg(“primera opcion”); | ||
+ | b=”hola”; | ||
+ | break; | ||
+ | case 1: | ||
+ | Game.Msg(“segunda opcion”); | ||
+ | b=”adios”; | ||
+ | break; | ||
+ | default: | ||
+ | Game.Msg(“cualquier opcion que no sea ni 1 ni 2”); | ||
+ | b=”¿que hago?”; | ||
+ | } | ||
+ | </code> | ||
+ | |||
+ | Bien aquí hay muchas cosas que analizar. Lo primero es que como vemos, la variable “a” | ||
+ | puede tomar un valor entre 0 y 3( debido a la función Random ). Si a es igual a 0, se ejecutan | ||
+ | las tres sentencias que se encuentran tras el “case 0:” | ||
+ | |||
+ | La palabra default, indica que ese bloque se ejecutará en caso de que el valor de la variable | ||
+ | sea diferente a las de los case anteriores. | ||
+ | |||
+ | La palabra reservada break sirve para decirle a wintermute que termine de evaluar el valor | ||
+ | de “a”, ya que si no lo ponemos wme seguiría ejecutando los demás casos. | ||
+ | |||
+ | Poniendo esta palabra, hacemos que cuando wme encuentra el bloque que tiene ejecutar y lo ejecute, | ||
+ | termine, y no siga evaluando, ya que esto relentiza el programa, y ademas para que evaluarlo, | ||
+ | si ya sabemos lo que valía la variable, y hemos ejecutado lo que nos interesa, por eso usamos | ||
+ | la palabra reservada “break”, para finalizar la evaluación del bloque switch. | ||
+ | |||
+ | Cada opción se define con la palabra reservada “case”. Se usa la palabra case y después se | ||
+ | pone el valor que puede tomar la variable que estábamos evaluando, en nuestro caso era la | ||
+ | “a” y se termina añadiendo dos puntos(:) | ||
+ | |||
+ | <code script> | ||
+ | case 1: | ||
+ | accion 1; | ||
+ | accion 2; | ||
+ | break; | ||
+ | </code> | ||
+ | |||
+ | En este caso cuando la variable que estamos evaluando tiene el valor 1, se ejecutan la acción 1 | ||
+ | y la acción 2, y con break termina el flujo de la instrucción, ya que como ya tenemos lo que | ||
+ | queríamos no hace falta seguir evaluando el switch. | ||
+ | |||
+ | También es posible usar usar el switch para evaluar variables de cadenas de texto(String). | ||
+ | |||
+ | <code script> | ||
+ | case “espada”: | ||
+ | accion1; | ||
+ | accion2; | ||
+ | break; | ||
+ | </code> | ||
+ | |||
+ | **Error:** No usar bucles en los switch, no funcionan. Si lo necesitas, se hace mediante la | ||
+ | definición de una función que contiene el bucle, pero esto lo veremos mas adelante. Solo | ||
+ | comentarlo, no se pueden usar bucles en los switch. | ||
+ | |||
+ | |||
+ | |||
+ | |||
+ | |||
+ | ===== 2.3 Bucles ===== | ||
+ | |||
+ | Hay veces en las que es necesario repetir una acción o serie de acciones mas de una vez. WME | ||
+ | proporciona varias formas de implementar esto. | ||
+ | |||
+ | **Bucle for** | ||
+ | |||
+ | Empezaremos con la primera forma mediante el comando for, este comando es útil si sabemos | ||
+ | exactamente el número de repeticiones que queremos realizar, veamos como imprimir por | ||
+ | pantalla 10 veces el mensaje infierno: | ||
+ | |||
+ | <code script> | ||
+ | for( var a=0; a < 10; a= a+1) | ||
+ | { | ||
+ | Game.Msg(“infierno"); | ||
+ | } | ||
+ | </code> | ||
+ | |||
+ | Analicemos estas lineas, el comando for se divide en 3 partes separadas por punto y coma. | ||
+ | La primera parte “var a=0” en esta linea definimos e iniciamos la variable que se usará para | ||
+ | recorrer el bucle, en este caso hemos definido una variable a y le hemos dado el valor 0. | ||
+ | |||
+ | En la segunda parte “ a < 10 “ es la condición de fin, lo que indica es cuando terminará el | ||
+ | bucle, en este caso le hemos puesto menor que 10, luego el bucle se ejecutara mientras a sea | ||
+ | menor que 10. | ||
+ | |||
+ | y la ultima parte “ a= a + 1” lo que indica es que la variable “a” del bucle se incrementara en | ||
+ | 1 cada vez que ejecutan las instrucciones encerradas entre llaves, en este caso, | ||
+ | Game.Msg(“infierno”). | ||
+ | |||
+ | En esta ultima parte, la de como se modifica la variable del bucle, se puede usar cualquier | ||
+ | operación, suma, resta, multiplicación, etc, y cualquier valor, es decir no es necesario que vaya | ||
+ | de 1 en 1, puede ir de 2 en 2, también es posible usar atajos, con a++ “a” se incrementará en | ||
+ | 1, y con a-- “a” se decrementará en 1. Por ejemplo: | ||
+ | |||
+ | <code script> | ||
+ | for( var a=0; a<10; a=a+2) | ||
+ | { | ||
+ | acciones; | ||
+ | } | ||
+ | </code> | ||
+ | |||
+ | De esta forma, el bucle solo se ejecutaría 5 veces, ya que la variable del bucle se va | ||
+ | incrementando en 2 unidades cada vez que se ejecutan las acciones. | ||
+ | |||
+ | <code script> | ||
+ | for( var a=10; a == 0; a= a--) | ||
+ | { | ||
+ | acciones; | ||
+ | } | ||
+ | </code> | ||
+ | |||
+ | Como vemos en este en lugar de ir del 0 hacia arriba, vamos desde un valor hacia abajo, y | ||
+ | cuando la variable cumpla la condición de fin es decir cuando “a” sea igual que 0, el bucle | ||
+ | termina. | ||
+ | |||
+ | Una cosa importante, es el número de veces que se ejecutará el bucle, porque dependiendo de | ||
+ | la condición de fin y de la variación de la variable del bucle, el bucle se nos ejecutará ese | ||
+ | número de veces. Lo mejor es trabajar con ellos para coger soltura en el numero de | ||
+ | repeticiones que requerimos. | ||
+ | |||
+ | Pero veamos algunos ejemplos útiles, ¿recordáis los arrays? Pues los bucles son geniales para | ||
+ | recorrerlos, y no tener que ir uno a uno obteniendo los valores del array. | ||
+ | Veamos un script de ejemplo: | ||
+ | |||
+ | <code script> | ||
+ | var miArray; | ||
+ | miArray[0]=”hola”; | ||
+ | miArray[1]=”¿que tal?”; | ||
+ | miArray[2]=”Adios”; | ||
+ | |||
+ | for( var a=0; a < 3;a= a + 1) | ||
+ | { | ||
+ | Game.Msg( miArray[a] ); | ||
+ | } | ||
+ | </code> | ||
+ | |||
+ | Como puedes ver es fácil imprimir por pantalla todos los elementos de un array. Espero que | ||
+ | estéis entendiendo su uso. Trabajando con ellos veréis que es una herramienta imprescindible | ||
+ | en programación. | ||
+ | |||
+ | **Bucle while** | ||
+ | |||
+ | Otro tipo de bucle es el llamado while. Este bucle es usado cuando no sabemos exactamente | ||
+ | cuantas veces se tendrán que ejecutarse las ordenes incluidas en el bucle. Veamos un ejemplo: | ||
+ | |||
+ | <code script> | ||
+ | var a =0; | ||
+ | |||
+ | while( a != 5) | ||
+ | { | ||
+ | a= Random(0,5); | ||
+ | Sleep(1); | ||
+ | } | ||
+ | </code> | ||
+ | |||
+ | Como vemos, en el script anterior declaramos una variable a inicializada a 0, después tenemos | ||
+ | nuestro bucle while( condición). While significa mientras, luego mientras la condición que se | ||
+ | encierra entre paréntesis, sea verdadera, estaremos ejecutando el bucle. | ||
+ | |||
+ | ¿Cuando terminará el bucle? Pues terminará cuando la función Random(0,5) que esta dentro | ||
+ | del cuerpo del bucle asigne a nuestra variable “a” el valor 5, ya que en la condición | ||
+ | impusimos que el bucle se ejecutara mientras “a” fuera distinto de 5. | ||
+ | |||
+ | En este caso, la declaración y la definición de la variable del bucle, se realiza antes del bucle, | ||
+ | la condición se encuentra entre paréntesis tras la palabra reservada while, y la modificación | ||
+ | de la variable, se realiza dentro del cuerpo del bucle, así, dependiendo de lo que pase dentro | ||
+ | del bucle, este se ejecutara un número de veces, que a priori no conocíamos. | ||
+ | |||
+ | Importante: quizás te estés preguntando que es eso de sleep(1), simplemente es una función | ||
+ | que lo que hace es desactivar el juego durante el tiempo que se le ponga entre paréntesis, en | ||
+ | este caso 1 mili-segundo, esto es para evitar, que el bucle se coma todo el procesador y no deje | ||
+ | paso a los demás procesos del equipo, lo que hace que todo se relentice y pueda dar | ||
+ | problemas, es muy habitual usarlo en programación, pero hablaremos de el mas adelante. | ||
+ | |||
+ | **Bucles infinitos** | ||
+ | |||
+ | ejemplo: | ||
+ | |||
+ | <code script> | ||
+ | while(true) | ||
+ | { | ||
+ | acciones; | ||
+ | Sleep(1); | ||
+ | } | ||
+ | </code> | ||
+ | |||
+ | Este es un bucle en el que la condición siempre es verdadera, por lo que siempre estará | ||
+ | ejecutándose, es muy común usar estos bucles en procesos de fondos, por ejemplo para la | ||
+ | musica, usas en el while una condición que compruebe si la música se esta reproduciendo o si | ||
+ | esta parada, si esta en play no hace nada, pero si no lo esta, podremos volver a reproducir la | ||
+ | misma, u otra canción. Para cosas como esta se usan los bucles infinitos. | ||
+ | |||
+ | |||
+ | |||
+ | |||
+ | ===== 2.4 Funciones ===== | ||
+ | |||
+ | Como ya hemos visto en el caso de Sleep() y Random(), hay una serie de herramientas | ||
+ | llamadas funciones. Con las funciones tenemos una buena forma de ahorrar tiempo, ya que si | ||
+ | tenemos que hacer algo varias veces a lo largo del juego, es tedioso tener que escribir el mismo | ||
+ | código varias veces. | ||
+ | |||
+ | Imagina el siguiente ejemplo: Se quiere imprimir 10 veces la palabra hola, pero quieres que | ||
+ | esto pase varias veces seguidas, sería tedioso hacer: | ||
+ | |||
+ | <code script> | ||
+ | for(var a=0; a < 10; a=a+1) Game.Msg(“hola”); | ||
+ | for(var a=0; a < 10; a=a+1) Game.Msg(“hola”); | ||
+ | for(var a=0; a < 10; a=a+1) Game.Msg(“hola”); | ||
+ | …. | ||
+ | </code> | ||
+ | |||
+ | Para esto podríamos crear una función: | ||
+ | |||
+ | <code script> | ||
+ | function hola() | ||
+ | { | ||
+ | for(var a =0; a<10;a++) | ||
+ | { | ||
+ | Game.Msg(“hola”); | ||
+ | } | ||
+ | return ; | ||
+ | } | ||
+ | hola();//imprime 10 veces en pantalla el mensaje hola | ||
+ | hola();//imprime 10 veces en pantalla el mensaje hola | ||
+ | hola();//imprime 10 veces en pantalla el mensaje hola | ||
+ | </code> | ||
+ | |||
+ | ¿Veis? esto simplifica el código. Una función es una pieza de código reutilizable, se define | ||
+ | como sigue: | ||
+ | |||
+ | <code script> | ||
+ | function nombre_de_la_funcion(parametros) | ||
+ | { | ||
+ | codigo de la funcion | ||
+ | } | ||
+ | </code> | ||
+ | |||
+ | El fin de la función es cuando se encuentra la palabra reservada return que en ciertos casos | ||
+ | podrá devolver algún dato que utilizaremos para controlar el programa. | ||
+ | |||
+ | Pero una función como la del ejemplo anterior no tiene mucha funcionalidad, la funcionalidad | ||
+ | se amplia cuando empezamos a hacer uso de los parámetros. Por ejemplo una modificación | ||
+ | del ejemplo anterior con mayor funcionalidad es el siguiente: | ||
+ | |||
+ | <code script> | ||
+ | function escribeTexto(texto, contador) | ||
+ | { | ||
+ | for( var a=0; a< contador; a++) | ||
+ | { | ||
+ | Game.Msg(texto); | ||
+ | } | ||
+ | } | ||
+ | |||
+ | escribeTexto(“hola”,10); // se muestra 10 veces hola en pantalla | ||
+ | var b=5; | ||
+ | escribeTexto(“ring! Ring!” , b); // se muestra 5 veces por pantalla ring! Ring! | ||
+ | </code> | ||
+ | |||
+ | Como veis, mediante los dos parámetros texto y contador, le damos mucha funcionalidad a | ||
+ | nuestra función, ya que cuando queramos imprimir en alguna parte del juego un texto | ||
+ | repetidas veces en la pantalla podremos hacer uso de esta función, y no tener que hacer un | ||
+ | bucle cada vez que queramos realizar dicho propósito. | ||
+ | |||
+ | En la función escribeTexto(texto, contador), las variables texto y contador solo serán validas | ||
+ | dentro del cuerpo de la función, por lo que solo podremos usarlos dentro de la función, y no | ||
+ | fuera. | ||
+ | |||
+ | Bueno hemos visto como pasar datos a la función para que trabaje, pero ¿como hacemos para | ||
+ | que la función nos devuelva un valor con el que poder trabajar? | ||
+ | |||
+ | Por ejemplo en la función Random(a,b) la función nos devuelve un valor comprendido entre | ||
+ | “a” y “b”, Esto se realiza con la palabra return que indica que es lo que nos devolverá la | ||
+ | función, veamos un ejemplo: | ||
+ | |||
+ | <code script> | ||
+ | function esMayor(number1,number2) | ||
+ | { | ||
+ | var mayor=false; | ||
+ | if(number1>number2) | ||
+ | { | ||
+ | mayor=true; | ||
+ | } | ||
+ | return mayor; | ||
+ | } | ||
+ | |||
+ | esMayor(5,1);//esta funcion devuelve un true | ||
+ | esMayor(2565,5678); //esta funcion devuelve un false | ||
+ | </code> | ||
+ | |||
+ | Como podemos intuir,, esta función comprueba el si el number1 pasado como parámetro, es | ||
+ | mayor que el number2, si esto es cierto, entonces cambia el valor de la variable a true, | ||
+ | mientras que si no es cierta, el valor de la variable mayor sera false como le dimos al | ||
+ | declararla, una vez que ha ejecutado todas las sentencias y llega a la palabra return, la | ||
+ | función, coge el valor que tiene la variable mayor y nos lo devuelve, este valor podríamos | ||
+ | almacenarlo en una variable, y trabajar posteriormente con el. | ||
+ | |||
+ | En este caso al tratarse de un valor booleano lo que devuelve la función, podríamos por | ||
+ | ejemplo emplearlo en condiciones directamente, veamos un ejemplo: | ||
+ | |||
+ | <code script> | ||
+ | if( esMayor(5,1) ) | ||
+ | { | ||
+ | Game.Msg(“el numero es mayor”); | ||
+ | } | ||
+ | else | ||
+ | { | ||
+ | Game.Msg(“el numero es menor”); | ||
+ | } | ||
+ | </code> | ||
+ | |||
+ | Como veis hemos metido una función que devuelve un valor booleano dentro de una condición, | ||
+ | conforme practiquéis, aprenderéis rápidamente como usar funciones con bucles, condiciones, | ||
+ | parámetros, arrays, etc. Llegará un momento en que aprenderéis a enlazar unas cosas con otras | ||
+ | y crear buenos trozos de código. | ||
+ | |||
+ | **Sexta regla de sintaxis** | ||
+ | |||
+ | Los nombres de funciones, solo pueden contener caracteres alfanuméricos, y sin espacios entre | ||
+ | caracteres. Ejemplos de nombres: | ||
+ | |||
+ | <code script> | ||
+ | escribirNumero() // correcta | ||
+ | reproducirSonido5() // correcta | ||
+ | escribir_Numero() // correcta | ||
+ | reproducir_Sonido() // correcta | ||
+ | escribir Numero() // incorrecta | ||
+ | reproducir*Sonido() // incorrecta | ||
+ | </code> | ||
+ | |||
+ | Debemos tener todo claro hasta este punto, si no es así, por favor revisa los capítulos | ||
+ | anteriores y podrás continuar sin problemas. Si algo no queda muy claro preguntad en foro | ||
+ | oficial y se contestará o se intentará modificar para aclararlo. | ||
+ | |||
+ | |||
+ | ===== 2.5 Clausula include ===== | ||
+ | |||
+ | Como hemos visto, las funciones ofrecen mucha potencia al programa, pero como no existe | ||
+ | ninguna manera de declarar una función global, como hacíamos con las variables, hay de | ||
+ | hacer que las funciones que están en un script, se puedan usar en otros scripts, para ello hay | ||
+ | dos maneras de hacerlo, mediante la palabra reservada includes, o mediante objetos. Pero | ||
+ | primero veamos como se usa include. | ||
+ | |||
+ | Si has echado un ojo a la demo de WME abras visto que cada script comienza con la linea: | ||
+ | |||
+ | <code script> | ||
+ | #include “scripts\base.inc” | ||
+ | </code> | ||
+ | |||
+ | Con esta linea, lo que estamos haciendo, es decir que queremos incluir este archivo de scripts | ||
+ | en el script donde estamos trabajando, en este caso estamos incluyendo el archivo base.inc que | ||
+ | tendrá una serie de funciones, variables, o trozos de código que podremos usar también en el | ||
+ | script donde lo incluyamos. Por ejemplo, si no quieres declarar tus variables globales cada vez | ||
+ | que las necesitas, puedes crear un fichero inc donde estén todas las variables globales | ||
+ | definidas, y ya con solo incluir este fichero con la palabra include, no tenemos que andar | ||
+ | escribiendo la declaración de las variables globales cada vez que vayamos a usarlas. También | ||
+ | es posible hacer esto con funciones, creas un fichero inc con las funciones, y después lo | ||
+ | incluiremos con la palabra reservada #include “ruta_y_nombre_del_archivo.inc”. | ||
+ | |||
+ | Así no tendremos que copiar el código de la función en cada script donde queramos usarlo. | ||
+ | |||
+ | **Nota:** fíjate que la linea #include “scripts/base.inc” no lleva punto y coma al final, y el nombre | ||
+ | y la ruta del archivo van entre comillas. | ||
+ | |||
+ | Importante: no inicialices nunca las variables en el fichero a incluir, ya que si haces eso, estas | ||
+ | se inicializarán cada vez que hagas una llamada a un script que incluya ese fichero. | ||
+ | |||
+ | |||
+ | |||
+ | ===== 2.6 Objetos ===== | ||
+ | |||
+ | Veamos ahora lo que aporta la mayor funcionalidad a WME, los objetos, bien, empecemos | ||
+ | despacio, imagina que tienes un objeto de la vida real, por ejemplo, una mesa. Pero claro el | ||
+ | termino mesa no nos dice nada, es abstracto, ya que la mesa puede estar echa de plástico, de | ||
+ | madera, de metal, puede tener distintos colores, puede ser cara o barata, etc tiene muchas | ||
+ | propiedades, quizá nos convendría tener todas estas propiedades juntas para una mesa. | ||
+ | |||
+ | <code script> | ||
+ | var mesa; | ||
+ | mesa.material=”madera”; | ||
+ | mesa.color=”negro”; | ||
+ | mesa.precio=100; | ||
+ | Game.Msg(mesa.precio); //se imprimirá el precio de la mesa por pantalla. | ||
+ | </code> | ||
+ | |||
+ | Bien, lo que hemos echo aquí, es definir una variable pero en lugar de acceder a esta variable | ||
+ | directamente, hemos agregado una serie de atributos a la variable, ya no usamos la variable | ||
+ | como un contenedor de un valor, sino que lo usamos para almacenar varias cosas, es muy | ||
+ | parecido a los arrays pero en lugar de acceder por la posición, accedemos por un nombre de | ||
+ | atributo. En el ejemplo anterior accedimos al atributo precio del objeto mesa. | ||
+ | |||
+ | <code script> | ||
+ | Game.Msg(mesa.precio); | ||
+ | </code> | ||
+ | |||
+ | Seguro que estarás pensando esto es fantástico y maravilloso, pero si quiero crear 10 mesas, | ||
+ | ¿necesito declarar 10 variables como esta? No, Seria muy tedioso. | ||
+ | Bien, la magia de los objetos no solo reside en sus atributos, sino que también se pueden | ||
+ | definir funciones para los objetos, todo el tiempo hemos estado trabajando con un objeto, | ||
+ | Game.Msg() y ahora acabas de descubrir que este método, es un método del objeto Game. | ||
+ | |||
+ | WME trabaja mucho con objetos, y conforme te adentres en su funcionamiento, más te darás | ||
+ | cuenta de lo importantes y útiles que son. | ||
+ | |||
+ | Bien, veamos como definir un objeto para algo mas de utilidad que para almacenar atributos. | ||
+ | |||
+ | Bien primero crearemos un fichero donde definiremos un objeto, le llamaremos por ejemplo | ||
+ | mesa.script | ||
+ | |||
+ | <code script> | ||
+ | #include “scripts\base.inc” | ||
+ | method initialize(material, color, precio) | ||
+ | { | ||
+ | this.material=material; | ||
+ | this.color=color; | ||
+ | this.precio=precio; | ||
+ | } | ||
+ | </code> | ||
+ | |||
+ | **Septima regla de sintaxis** | ||
+ | |||
+ | Si quieres acceder al atributo o funcion de un objeto, usamos un punto como hemos visto en | ||
+ | los ejemplos anteriores. | ||
+ | |||
+ | Usamos la palabra this, ya que como no sabemos a priori como le llamaremos al objeto, pues | ||
+ | this, es una palabra reservada para referirse al objeto el cual estamos creando. | ||
+ | |||
+ | Esta es la manera correcta de definir la inicialización de un objeto. | ||
+ | |||
+ | Veamos ahora una vez que hemos definido el objeto mesa.script como crear un objeto de este | ||
+ | tipo. | ||
+ | |||
+ | <code script> | ||
+ | Var mesa1 = new Object(“mesa.script”); | ||
+ | </code> | ||
+ | |||
+ | De esta manera creamos un objeto de tipo mesa, ahora podemos definir sus propiedades | ||
+ | llamando al método iniciar que creamos en el archivo mesa.script de la siguiente manera: | ||
+ | |||
+ | <code script> | ||
+ | mesa1.iniciar(“madera”,”negra”,100); | ||
+ | </code> | ||
+ | |||
+ | De esta manera en nuestra mesa ya quedarán definidos sus tres atributos, pudiendo acceder a | ||
+ | ellos con el nombre_del_objeto.nombre_del_atributo: | ||
+ | |||
+ | <code script> | ||
+ | mesa1.material: | ||
+ | mesa1.color; | ||
+ | mesa1.precio; | ||
+ | </code> | ||
+ | |||
+ | Podemos ir mas allá, veamos por ejemplo como crear 10 objetos de tipo mesa usando un bucle: | ||
+ | |||
+ | <code script> | ||
+ | for( var a=0;a <10;a++) | ||
+ | { | ||
+ | mesas[a]= new Object(“mesa.script”); | ||
+ | } | ||
+ | </code> | ||
+ | |||
+ | Aquí tenemos que tener cuidado, ya que no podemos hacer mesas[a].iniciar(material,color,precio); | ||
+ | ya que WME no soporta esto, para solucionarlo debemos hacer uso de una variable temporal, que | ||
+ | almacene cada objeto, lo inicialice y después lo vuelva a almacenar en el array. | ||
+ | |||
+ | <code script> | ||
+ | var temp = mesas[a]; | ||
+ | temp.iniciar(“madera”,”negra”,100); | ||
+ | mesas[a]=temp; | ||
+ | </code> | ||
+ | |||
+ | Con estas tres lineas, obtenemos una de las mesas del array, la iniciamos, y después la | ||
+ | volvemos a guardar en el array, esto es necesario ya que como hemos dicho wme no soporta el | ||
+ | acceso a los atributos o métodos de los objetos guardados en un array. | ||
+ | Y ya solo se trata de practicar por unos mismo, y seguir con el tutorial que a partir de aquí | ||
+ | creo que con esto no tendrás problemas para entender lo siguiente. | ||
+ | |||
+ | También es posible crear mas métodos para el objeto mesa, simplemente, en el fichero mesa.script | ||
+ | que habíamos creado, podemos añadir un método por ejemplo para cambiar el color de la mesa. Pues | ||
+ | añadiremos en el fichero del objeto mesa el siguiente método: | ||
+ | |||
+ | <code script> | ||
+ | method cambiarColor(color) | ||
+ | { | ||
+ | this.color=color; | ||
+ | } | ||
+ | </code> | ||
+ | |||
+ | Y cuando creemos un objeto de tipo mesa, podremos cambiar el color de la mesa usando este método. | ||
+ | |||
+ | <code script> | ||
+ | var mesa = new Object("mesa.script");//creamos el objeto | ||
+ | mesa.iniciar("metal","roja",300);// iniciamos sus valores | ||
+ | Game.Msg(mesa.color);//se imprimirá en pantalla roja | ||
+ | mesa.cambiarColor("azul");//cambiamos el color | ||
+ | Game.Msg(mesa.color);//se imprimirá en pantalla azul | ||
+ | </code> | ||
+ | |||
+ | De esta manera podemos crear métodos para los objetos. | ||
+ | |||
+ | **Nota:** Método y función vienen a ser prácticamente lo mismo, con la diferencia principalmente de | ||
+ | que las funciones tienen funcionalidad por si solas, y los métodos siempre actúan sobre algún objeto. | ||
+ | |||
+ | |||
+ | |||
+ | |||
+ | |||
+ | |||
+ |