2. Guía para sobrevivir a la creación de scripts con WME [WME Resource Center]

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
=====2. Guía para el sobreviviente de WME scripting=====


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:

<code script>
Game.ChangeScene(“escena.scene”);
</code>

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:

<code script>
var miVariable = “hola mundo”;
</code>

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:

<code script>
Game.Msg(miVariable);
</code>

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:

<code script>
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! ). */


</code>

**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:\\

<code script>
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 */

</code>

**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:

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

o

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

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

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

**test2.script**

<code 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
</code>

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

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

Test2.script

<code 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.
</code>

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.



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