Ya hemos visto la primera parte del funcionamiento de WME, hemos mostrado el entorno de
desarrollo, y seguro que estas deseando avanzar. Como habrás comprobado, gran parte de la
funcionalidad de WME, reside en los scripts, pero:

¿ que son los scripts?

Vamos a empezar desde el principio. Toda la funcionalidad de un software reside en su núcleo.
Esto significa que cuando se realiza una acción, el programa debe responder a lo ocurrido.
Las acciones pueden ir desde clicks de ratón, hasta el tiempo que pasa desde un instante a
otro. Luego ¿que es un script? Pues es un programa donde se define que acciones hay que
controlar, y como responder a ellas.

Un juego básico en WME estará constituido por múltiples scripts. Por ejemplo, si haces un
clic con el ratón sobre una puerta, necesitaras un script que haga que tu personaje diga “La
puerta esta cerrada”. A medida que profundicemos en este capítulo, aprenderás muchos
“trucos” sobre WME y algo de programación en general, pero empecemos desde el principio.

El núcleo de la programación en WME, reside en las instrucciones. Las instrucciones en
WME indican como controlar una acción. Tenemos multitud de instrucciones diferentes,
desde simples operaciones matemáticas(suma, resta, multiplicación, etc) hasta instrucciones
complejas como:

Game.ChangeScene(“escena.scene”);

Este comando hace que wintermute cambie de escena, pero eso es simplemente un ejemplo,
mas adelante abordaremos instrucciones como esta.

Empecemos por lo mas básico de la programación(scripting). Empezaremos con algo a lo
que llamamos variable.

¿Que es una variable ?

Una variable es un contenedor donde podemos guardar información. En WME( a diferencia
de C++) puedes almacenar cualquier tipo de información en tu variable( cadenas de texto,
objetos, números,…) muy parecido a como funciona php.

Nota: C++ y php son dos lenguajes de programación. Es más parte de la programación de
WME se basa en C++.

Bien como hemos dicho una variable es un contenedor donde guardaremos algo, veamos un
ejemplo:

var miVariable = “hola mundo”;

La palabra var declara una variable local llamada miVariable que contiene la cadena de texto
hola mundo.

Nota: una cadena de texto(String) es un tipo de datos que no es mas que simplemente una
cadena de caracteres alfa-numéricos encerrados entre comillas dobles “” .

Una vez que hemos creado la variable y le hemos dado un valor(“hola mundo”) podemos
llamar al texto hola mundo por ejemplo usando:

Game.Msg(miVariable);

Esta instrucción lo que hace es mostrar en pantalla el contenido de la variable miVariable,
que en este caso será hola mundo.

Primera regla de sintaxis

Como puedes observar, cada instrucción debe terminar con un punto y coma ( ; ). Excepto en
varios casos que ya veremos mas adelante.

Otra cosa importante, es que WME hace distinción entre mayúsculas y minúsculas,
mivariable no es lo mismo que miVariable, ya que en la primera la v esta en minúsculas, y en
la segunda no. No olvides esto porque suele ser una de las cosas que a veces dan quebraderos
de cabeza.

Otra regla importante, es que las variables se declaran solo una vez en cada script, es decir
solo usaremos la palabra reservada var la primera vez que vayamos a usar o declarar la
variable, las demás veces llamaremos a la variable con su nombre, y nunca poniéndole var
delante.

Veamos algún ejemplo del uso de variables:

var miVariable="hola mundo"; /* esta linea declara una variable llamada mi variable y que 
                                contiene el texto hola mundo. */ 
 
Game.Msg(miVariable); /* esta linea muestra por pantalla el contenido de la variable llamada 
                         miVariable que en este caso, será el texto hola mundo. */ 
 
miVariable=1; /* con esta linea guardamos en la variable el numero 1, el texto hola mundo 
                 desaparece. */ 
 
miVariable = miVariable + 1; /* en esta linea, lo que hacemos es incrementar en 1 el valor de la 
                                variable, es decir, miVariable es igual a lo que valía miVariable 
                                + 1. */ 
 
Game.Msg(miVariable); /* Volvemos a mostrar la variable por pantalla, en este caso veremos 
                         el numero 2, ya que es el valor que tiene la variable en este 
                         momento. */ 
 
miVariable=miVariable * 2; /* Con esta linea lo que hacemos es multiplicar el valor actual de 
                              la variable por dos y guardarlo en miVariable.( en este 
                              momento, la variable contendría el numero 4). */ 
 
miVariable=miVariable / 4; /* Con esta linea lo que hacemos es divir entre cuatro la variable y 
                              la guardamos en ella misma otra vez. ( En este caso la variable 
                              tiene el valor 4 y si la dividimos entre 4 nos dara el valor 1, por 
                              tanto miVariable ahora contendrá el valor 1). */ 
 
miVariable=”el resultado es”+ miVariable+ “!”; /* En este caso estamos almacenando en 
                                                  miVariable la concatenacion( union ) del 
                                                  texto el resultado es, con el valor que tenia la 
                                                  variable hasta ese momento( en este caso era 
                                                  1 ) y un signo de exclamacion al final. ( luego 
                                                  tras esta linea, miVariable contendrá: el 
                                                  resultado es 1! */ 
 
Game.Msg(miVariable); /* Volvemos a mostrar por pantalla el contenido de la variable.( En 
                         este caso veremos: el resultado es 1! ). */

Segunda regla de sintaxis

Si queremos comentar algo para nuestro entendimiento o el de los demás, podemos usar doble barra
inclunada '/' para comentarios de una sola linea o /* comentario */ para comentarios de varias
lineas. Los comentarios no afectan de ningún modo al programa, solo sirven para dejarnos las cosas
claras a nosotros o a cualquiera que pudiera coger el código en el futuro.

Ejemplos:

var a = 1; // declaramos una variable llamada a igual a 1, esto es un comentario de una linea 
 
/* esto es un 
comentario 
de varias 
lineas */

Recomendación: Siempre intenta llamar a tus variables de una manera que puedas saber lo
que contiene. Es gracioso llamar a una variable pepitoGrillo, pero si la llamas así y dentro de
5 o 6 meses miras el código, te preguntaras ¿que es lo que tenia esta variable? Mientras que si
le pones un nombre descriptivo sabrás de donde salio esa variable. Por ejemplo si quieres
guardar en una variable la hora del día que es en el juego, pues lo más lógico es que llames a
esa variable hora, o time, o algo que la describa.

Otra recomendación es usar siempre una nomenclatura para las variables, me explico, como
WME hace distinción entre mayúsculas y minúsculas hay que tener cuidado con eso, así que
para evitarnos problemas podemos nombrar a las variables de una forma concreta, por
ejemplo:

var MiVariable= 1; // Aquí vemos que Mi y Variable empiezan con mayúsculas.

o

var miVariable= 1; /* Aquí mi la primera palabra va en minúsculas y las siguientes en 
                      mayúsculas */

Esto es recomendable porque cuando volvamos a usar la variable si usamos una estructura,
no habrá que ir hacia atrás en el código para acordarte exactamente como lo escribiste.

Como viste hemos hablado de algo llamado variable local. La palabra local significa, que esa
variable solo es valida en el script donde es declarada.

Por ejemplo, imagina que tienes dos scripts que son ejecutados uno tras otro, llamados
test1.script y test2.script:

test1.script

var a=10; //declaramos la variable a con el valor 10 
Game.Msg(a); // la mostramos por pantalla

test2.script

var a = a +1; //declaramos la variable a con el valor que tenia mas uno. 
Game.Msg(a); // se muestra por pantalla el valor de a

El script test1.script mostrara por pantalla el valor 10.

El script test2.script mostrara por pantalla el valor 1.

Es común pensar que el script test2.script debería mostrar por pantalla el valor 11, pero esto
no es así, debido a que la variable “a” del script test1.script solo se puede usar dentro del
script test1.script. Y la variable “a” del script test2.script solo se podrá usar dentro del
script2.test

Pero entonces, ¿como podemos compartir una variable entre unos script y otros? Para esto
usamos otro tipo de variable llamada variable global. Esta variable es declarada usando la
palabra reservada global y se puede usar en cualquier script de todo el juego.

Tercera regla de sintaxis

En todos los script donde queramos usar una variable global, debemos declarar esta variable
con la palabra reservada global.

Veamos el ejemplo anterior con variables globales.

Test1.scrip

global a=10; //declaramos la vaariable global llamada a con contenido igual a 10. 
Game.Msg(a); // mostramos el valor de a por pantalla.

Test2.script

global a = a+1; // llamamos a la variable global a y le asignamos el valor que tenia mas 1 
Game.Msg(a); // volvemos a mostrar a por pantalla.

En este caso el script test2.script mostraria por pantalla el valor 11, ya que estamos haciendo
uso de variables globales, y en el script test1.script ya le habíamos dado el valor 10.

De esta manera podemos compartir variables entre distintos scripts.

Ojo: si llamamos a una variable global, solo es necesario llamarla una vez, es decir solo
usaremos la palabra global la primera vez que usamos la variable en cada script,
posteriormente, la llamaremos por su nombre.

Veamos un ejemplo que se nos podría dar a la hora de programar un juego, imagina que
tenemos un botón en una escena, y que si lo pulsamos, queremos que se abra una puerta en
otra escena diferente. Pues simplemente, crearemos por ejemplo una variable global llamada
botón, y le daremos el valor false (falso, variables booleanas). Cuando el jugador pulse sobre
el botón, cambiaremos el valor de la variable a true(verdadero). Y en la escena donde
queramos que se abra la puerta, llamaremos a la variable global botón y miraremos que valor
tiene, si tiene un false(falso), la puerta estará cerrada, si la variable botón tiene el valor
true(verdadero), entonces la puerta estará abierta.

Y de esta manera podemos hacer que la puerta no se abra hasta que el jugador encuentre el
botón.

Sobre la variables booleanas, que decir que se usan para algo llamado condiciones que
veremos mas adelante, pero básicamente es una variable, que solo puede contener 2 valores, o
true(verdadero) o false(falso). Pero lo veremos detenidamente mas adelante.

Hemos visto lo básico de las variables, hay mucho mas sobre ellas, pero lo iremos viendo
conforme vayamos avanzando.

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.

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!!

Otro ejemplo de acceso al array mediante una variable:

var a=1; 
Game.Msg(miArray[a]); // imprime por pantalla este es mi primer array

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.

nombreArray[posicionRequerida];

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:

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

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:

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

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á.

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]);

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.