Differences

This shows you the differences between the selected revision and the current
version of the page.

--- es:wmebook:ch2 2013/04/07 17:44
+++ 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
 conforme vayamos avanzando.
 =====2.1 Arrays mágicos=====
@@ Line 267: / Line 268: @@
 **Elección complicada**
-Puedes usar solo una variable y mediante operaciones matemáticas construir el número a
+Esta es la forma optima de hacerlo, pero es mas complicada.Puedes usar solo una variable y
-comparar con el que se requiera para abrir la puerta.
+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. ;)
@@ Line 306: / Line 309: @@
 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:
+.- 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>
+.- 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>
+.- 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>
+.- 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>
+.- 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>
+.- 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
+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
+, 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.