![ Boundary (Al limite o Frontera): Este evento ocurre cuando la instancia de objeto intercepta o
llega a el limite del cuarto, o nivel de juego pero aún esta en parte dentro del cuarto, o nivel del
juego (room).
Game start (Inicio del juego): Este evento solo se ejecuta en el primero cuarto, o nivel de juego
(Room), cuando el juego inicia. Se ejecuta después del evento (room start) -ver el siguiente
evento- pero antes del evento creación de las instancias del objeto en el cuarto, o nivel de juego.
Este evento es típicamente definido solo en un objeto controlador y es usado por ejemplo para
iniciar alguna música de fondo, inicializar algunas variab les o cargar alguna información (de un
archivo).
Game end (Fin del juego): Ese evento se ejecuta para todas las instancias cuando el juego termina
(o te sales del juego). De nuevo, típicamente se define este evento en un único objeto y es usado
por ejemplo para guardar alguna información en un archivo.
Room start (Inicio de Room) : Este evento se ejecuta para todas las instancias que inicialmente
estén en un cuarto, o nivel de juego (Room), cuando este cuarto, o nivel de juego (Room), se
inicia. Sucede después de los eventos de creación (Creation) de las instancias.
Room end (Fin del Room) : Este evento se ejecuta para todas las instancias existentes cuando el
cuarto, o nivel de juego (Room), termina.
No more lives (No más vidas): Game M aker posee un sistema p redefinido de vidas (lives). Hay
una acción para establecer y cambiar el número de vidas (lives). Cuando sea que el número de
vidas sea menor o igual a cero, este evento es generado. Es típicamente usado para terminar o
reiniciar el juego.
No more health (No más energía): Game M aker posee un sistema predefinido de energía. Hay
una acción para establecer y cambiar la energía. Cuando sea que la energía sea menor o igual a
cero, este evento es generado. Es típicamente usado para reducir el número de vidas o para
reiniciar el juego.
End of animation (Fin de la animación) : Como fue indicado antes, una animación (sprite
animado) consiste en cierto número de imágenes que son mostradas una tras la otra. Luego de que
la última subimagen es mostrada la animación se reinicia desde la primera imagen. Este evento se
genera en ese preciso momento (antes de cambiar la última imagen por la primera). Por ejemplo
esto puede ser usado para cambiar la animación o destruir la instancia.
End of path (Final del camino o trayectoria): Este evento se genera cuando la instancia esta
siguiendo (usando) un camino, o trayectoria (path) y el final del camino o trayectoria es
alcanzado.
User defined (Eventos definidos por el usuario): Hay disponibles ocho de estos eventos. Estos
normalmente no son generados nunca, a menos que tu mismo los ejecutes desde un bloque de
código en lenguaje Game M aker (GM L).
“Draw event” (Evento de dibujo)
Las instancias cuando son visibles, dibujan (Automáticamente) su imagen en cada
paso de juego en la pantalla. Cuando especificas acciones en el evento dibujo
(Drawi), la imagen no es dibujado, pero estas acciones son ejecutadas en su lugar. Esto puede ser usado para dibujar
algo más que la imagen o para antes de dibujar hacer algunos cambios a los parámetros de la imagen. Hay varias
acciones de dibujado que están disponibles para ser usadas especialmente en el evento dibujo (Drawi). Hay que notar
que el evento dibujo (Drawi), es solamente ejecutado si el objeto (más específicamente, si la instancia del objeto) es
visible. Además, nota que, independientemente de lo que dibujes, los eventos de colisión son basados en la imagen
asociada con la instancia (o si la posee en su máscara).
“Key press events” (Evento presionar una tecla)
Este evento es similar al evento keyboard pero este sucede una única vez cuando la
tecla es presionada, en lugar de generarse continuamente. Es útil cuando quieres que
las acciones se ejecuten una única vez, como por ejemplo para que cada que se presiona una tecla haya un disparo por
parte de una nave, o un golpe o patada por parte del personaje que esta interactuando con el jugador.
“Key release events” (Evento soltar/liberar una tecla)
Este evento es similar al evento keyboard pero sucede una vez cuando la tecla es
soltada o liberada en lugar de generarse continuamente.
En algunos casos, es importante comprender el orden en el cual Game M aker procesa los eventos. Este orden es el
siguiente:
1.- Evento de inicio de paso (Begin step event)
2.- Eventos de los relojes de alarma (Alarm events [1-8])
3.- Eventos del teclado ('Keyboard', 'Key press' y 'Key release')
4.- Eventos del M ouse (M ouse events)
5.- Evento paso normal (En este punto, todas las instancias son colocadas en su nueva posición)
6.- Eventos de colisión
29](https://image.slidesharecdn.com/manualgm6-1practico-100619093410-phpapp01/85/Manual-gm6-1-practico-29-320.jpg)
![alarm[#]=10 Indica el tipo de alarma a utilizar [#], y en tiempo se debe de utilizar, en este
ejemplo 10.
lives=3 Esto establece a 3 el numero de vidas que tendrá el jugador, si queremos que
aumenten o disminuyan las vidas se podría poner lives=lives+1, o lives=lives-1.
Y si queremos escribir estás acciones en lenguaje de programación, debemos utilizar la acción “Execute piece of
code” ó “script” (script se explicará luego).
Una vez que agregamos un evento y dentro de este colocamos alguna de estas acciones, es cuando se procede con la
escritura en el lenguaje de programación del Game M aker. Así que no debemos pues tener miedo a comenzar a
utilizar el lenguaje de programación. Una vez que he tratado de convencerte de que cuando manejas las acciones de
Arrastrar y Soltar estás en realidad programando de cierto modo en el lenguaje de programación, te darás cuenta de
que no es tan difícil sino que más que nada hay que saber, para que sirve cada función ó en tal caso como se escribe
una determinada acción con su equivalente en el lenguaje de programación del Game M aker. Para lo cual te
recomiendo un pequeño programa que puedes conseguir en la comunidad del Game M aker previo registro por
supuesto, llamado, ActionDecoder1. El cual es muy fácil de usar y una vez que tú coloques una acción con sus
valores correspondientes te dará la instrucción en el lenguaje de programación del Game M aker, y como verás te
puede ser muy útil para, ir conociendo el lenguaje de programación.
Ahora sí comienza lo interesante. Para manejar con mayor avidez y rapidez el lenguaje se deben aprender
obligatoriamente los siguientes conceptos:
Variable:
Una variable es en realidad un identificador que representa una dirección de la memoria RAM , y como la asignación
de datos (instrucciones) a esta memoria es aleatoria, es esencial saber donde se guardan lo datos, para nosotros saber
el nombre de la variable que es lo mismo. Al programador que recién comienza le interesa saber ¿Para qué sirven?
Bueno, una variable nos sirve para almacenar datos que necesitemos usar con posterioridad, como por ejemplo podría
ser la vida de un enemigo: Vida=10
Donde vida es el nombre de la variable, el signo de igual es la asignación que se le dio, y 10 es el valor o dato que
contiene.
Para utilizar una variable primero debe estar declarada en el evento create. De lo contrario cuando compilemos el
juego es muy posible que nos dé un error.
Existen distintos tipos de variables, sin embargo en GM L no se pueden declarar los tipos así que para simplificar las
cosas los dividiremos en dos grandes grupos: las variables de Números o reales y las de Textos o cadenas.
Las operaciones que se pueden hacer con variables que contengan números son las conocidas por todos (suma, resta,
multiplicación, división, etc.) Continuando con el ejemplo anterior, con la variable vida podríamos hacer, que para
quitarle una vida al enemigo, cuando r ecibe un disparo en un evento de colisión con un objeto llamado bala.
Agregamos la acción y dentro escribimos
vida = vida-1
o también lo podríamos haber escrito así:
vida-=1 para restar 1
vida+=1 para sumar 1
vida*=2 para multiplicar por 2
.... Etc.
Las variables que contengan texto se representan así:
mensaje=‟los textos, a los que daremos el nombre de string, siempre se escriben entre comillas simples (‟) o dobles
(“).
Con los strings el único operador disponible es el signo + que une dos o más textos. En donde se puede hacer.
mensaje+=‟ Seguimos con la explicación‟
El resultado de esta operación será que el nuevo valor de la variable mensaje se cambiara por:
mensaje=‟los textos, a los que daremos el nombre de string, siempre se escriben entre comillas simples o dobles.
Seguimos con la explicación‟.
Fuera de los operadores existen las denominadas “funciones” que extenderán nuestra capacidad para manejar datos,
con ellas podremos lograr que un texto se copie, se le quite una letra, una palabra, calcular la raíz cuadrada de un
número, dibujar un rectángulo con una palabra dentro e infinidad de cosas.
Pero antes de entender que son las funciones, como funcionan y cómo hacerlas nos falta adueñarnos de varios
conceptos.
72](https://image.slidesharecdn.com/manualgm6-1practico-100619093410-phpapp01/85/Manual-gm6-1-practico-72-320.jpg)
![global.puntaje+=5
sprite_index=spr_bonus; // cambiamos el sprite por el que representa, al toma un bonus. Y usaremos una alarma 0
para que en un tiempo de 35 milisegundos se vuelva a poner el sp rite normal.
alarm[0] =35
Evento alarma:
Colocamos en las acciones otra pieza de código
sprite_index=spr_personaje; // Así regresamos al personaje a su estado inicial
Para el Objeto bonus.
Asignamos al objeto el sprite: spr_bonus.
Evento crear:
Colocamos en las acciones otra pieza de código
// Como ya habrás notado, el sprite spr_bonus es una secuencia de imágenes que nada tienen que ver una con la otra,
es decir no corresponden a una animación; sino representan distintos dibujos. Para que el objeto tome como sprite
cualquiera de sus sub imágenes al azar usaremos el siguiente código (code).
image_single=round(random(image_number));
// Donde se lee; que la imagen única será el numero redondeado de un número aleatorio que tiene como máximo el
numero de las subimágenes.
Evento Colisión con el objeto obj_personaje:
Colocamos en las acciones otra pieza de código
// simplemente queremos que si se le toca, se elimine la instancia, y se reproduzca el sonido snd_glup.
instance_destroy();
sound_play(snd_glup);
Para el objeto obj_drawer, (No lleva imagen):
Evento Dibujo (Draw):
Colocamos en las acciones otra pieza de código
// simplemente queremos que escriba en la parte izquierda de la pantalla, el tiempo de juego que nos queda
draw_text(16,32,‟Tiempo: „+string(global.tiempo)) //Donde 16 es el valor de X, y 32 el valor de Y para las
coordenadas donde será dibujada la palabra Tiempo más el valor de la variable global.tiempo
Evento crear :
Colocamos en las acciones otra pieza de código
//creamos dos variables xx, e yy
xx=0
yy=0
//luego queremos crear ocho objetos y lo hacemos con una estructura repetitiva
for (i=0; i<=8;i+=1)// para i=0 hasta i<=8, sumando de uno en uno hacer...
{
xx=random(room_width);//la variable xx toma un valor cualquiera dentro del ancho de la habitación
yy=random(room_height);//la variable yy toma un valor cualquiera dentro del alto de la habitación
while not(place_free(xx,yy)) //mientras xx e yy no estén en un lugar libre
{
xx=random(room_width); // se le deben asignar nuevos valores
yy=random(room_height); // se le deben asignar nuevos valores
}
instance_create(xx,yy,obj_bonus); //crear un bonus en la posición buscada.
}
Por último:
Creamos ahora un cuarto o nivel de juego (room), llamado rm_nivel1, lo definimos del tamaño que queramos y
colocamos los objetos obj_personaje y obj_drawer, en cualquier parte de la pantalla (Debe haber por lo menos un
77](https://image.slidesharecdn.com/manualgm6-1practico-100619093410-phpapp01/85/Manual-gm6-1-practico-77-320.jpg)
![Esto creara una pelota en las coordenadas dadas.
38.9.- Direccionando Variables a otras instancias:
Como se describió antes, puedes establecer variables en la instancia actual utilizando sentencias como:
x = 3;
Pero en un número de casos quizás quieras direccionar variables a otra instancia. Por ejemplo, tal vez quieras detener
el movimiento de todas las pelotas, o tal vez quieras mover al personaje principal a una posición en particular, o, en
caso de una colisión, tal vez quieras establecer la imagen para otra instancia implicada. Esto puede ser logrado
precediendo el nombre de la variable con el nombre de un objeto y un punto. Así que por ejemplo, puedes escribir:
Pelota.speed = 0; Esto cambiará la velocidad de todas las instancias del objeto pelota. Hay un número de palabras
especiales que no puedes utilizar para nombrar tus objetos:
self: La instancia del objeto actual para la que estamos ejecutando la acción.
other: La otra instancia de objeto implicada en un evento de colisión.
all: Todas las instancias del objeto.
noone: Ninguna instancia de objeto (probablemente suena extraño pero si viene útil como veremos
después).
global: No es precisamente una instancia, sino un contenedor que almacena variables globales.
Así que, por ejemplo, puedes usar los siguientes tipos de sentencias:
other.sprite_index = sprite5;
all.speed = 0;
global.message = 'Un buen resultado';
global.x = pelota.x;
Ahora tal vez te preguntes que es lo que hace, la asignación anterior (o sea Pelota.speed = 0;), cuando hay varias
pelotas. Bueno, la primera es tomada y su valor x es asignado al valor global para todas las pelotas. Pero qué si
quieres establecer la velocidad para una pelota en particular, en vez de a todas las pelotas. Esto es ligeramente más
difícil. Cada instancia tiene una identificación única (id de ahora en adelante). Cuando pones instancias en un cuarto,
o nivel de juego mientras estas diseñando el juego, esta id de la instancia es mostrada cuando pones el M ouse sobre
ella. Estos son números más grandes o iguales a 1000000 un millón. Puedes usar dicho número como la parte
izquierda del punto. Pero se cuidadoso. El punto se interpretará como el número decimal en el número. Para evitar
esto, pon paréntesis alrededor del número. Así que por ejemplo, asumiendo que la id de la pelota es 1000032, puedes
escribir: (1000032).speed = 0;
Cuando creas una instancia en el programa, la llamada regresa el identificador id. Así que un programa válido es:
{
nnn = instance_create(100,100,ball);
nnn.speed = 8;
}
Esto crea una pelota (en la posición x=100 y en la posición y=100) y establece su velocidad a 8. Nota que asignamos
el identificador id (representado por las letras n) de la instancia a una variable y utilizamos esta variable como
indicación después del punto (speed). Esto es completamente válido. Vamos a intentar hacer esto más comprensible.
Un punto es en realidad un operador. Este toma un valor como operador izquierdo y una variable (dirección) como
operador derecho, y regresa la dirección de esa variable en particular en el objeto indicado o en la instancia del
objeto. Todos los nombres de objetos, y los objetos especiales indicados abajo simplemente representan valores y
estos pueden ser manejados como cualquier valor. Por ejemplo, el siguiente programa es válido:
{
obj[0] = pelota;
obj[1] = bandera;
obj[0].alarm[4] = 12;
obj[1].id.x = 12;
}
La última sentencia debería ser leída como sigue. Tomamos el identificador id de la primera bandera. Para la
instancia con esa id establecemos la coordenada x=12. Los nombres de objetos, los objetos especiales, y el
identificador id de la instancia, también pueden ser utilizados en un número de funciones. Son en realidad tratados
como constantes en los programas.
106](https://image.slidesharecdn.com/manualgm6-1practico-100619093410-phpapp01/85/Manual-gm6-1-practico-106-320.jpg)
![38.10.- Órdenes (Arrays):
Puedes usar órdenes (Arrays) unidimensionales y bidimensionales en el lenguaje del Game M aker. Simplemente pon
el índice entre corchetes cuadrados “[ ]” para órdenes (arrays) unidimensionales, y los dos índices con una coma entre
ellos para órdenes (arrays) bidimensionales. En el momento en que usas un índice la orden (arrays) es generada. Cada
orden (array) corre desde el índice 0. Ten cuidado usando índices grandes de ordenes porque la memoria para una
orden grande estará reservada. Nunca uses índices valores negativos. El sistema pone un límite de 32000 en cada
índice y 1000000 en el total de tamaño. Como por ejemplo puedes escribir lo siguiente:
{
a[0] = 1;
i = 1;
wh ile (i < 10) { a[i] = 2*a[i-1]; i += 1;}
b[4,6] = 32;
}
38.11.- Sentencia if (si):
Una declaración si (if) tiene la forma:
if (<expresión>) <sentencia>
O también.
if (<expresión>) <sentencia> else <sentencia>
La declaración puede también ser un bloque. La expresión será evaluada. Si el valor (aproximado) es if <=0 (falso) se
ejecuta la declaración sino (else) es ejecutada, de otra forma (cierto) la otra declaración es ejecutada. Es un buen
hábito siempre poner llaves alrededor de las declaraciones en el si (if). M ejor usa:
if (<expresión>)
{
<sentencia>
}
else
{
<sentencia>
}
El siguiente ejemplo mueve el objeto hacia en medio de la pantalla.
{
if (x<200) { x+=4} else { x-=4};
}
38.12.- Sentencia re peat:
repeat (<exp resión>) <sentencia>
La sentencia es repetida el número de veces indicado, por el valor redondeado de la expresión.
Ejemplo:
El siguiente programa crea cinco pelotas en posiciones aleatorias:
{
repeat (5) instance_create(random(400),random(400),pelota);
}
38.13.- Sentencia while:
Una declaración while tiene la forma:
while (<exp resión>) <sentencia>
107](https://image.slidesharecdn.com/manualgm6-1practico-100619093410-phpapp01/85/Manual-gm6-1-practico-107-320.jpg)
![Funcionará mientras la expresión que pude o no estar en un bloque sea verdadera. Sé cuidadoso con tus secuencias
while. Puedes fácilmente hacer que se repita por siempre, en este caso tu juego se bloqueara y no reaccionará a
ninguna petición o acción que el usuario haga.
Ejemplo:
El siguiente programa prueba poner el objeto actual en una posición libre (esto es como la misma acción para mover
un objeto a una posición aleatoria).
{
wh ile (!place_free(x,y))
{
x = random(roo m_width);
y = random(roo m_height);
}
}
38.14.- Sentencia do:
Una sentencia do tiene la forma:
do <sentencia> until (<expresión>)
La sentencia (que puede estar en un bloque) es ejecutada mientras que la expresión es verdadera. La sentencia se
ejecuta por lo menos una vez. Sé cuidadoso con tus secuencias do. Puedes fácilmente hacer que se repita por siempre,
en este caso tu juego se bloqueara y no reaccionará a ninguna petición o acción que el usuario haga.
Ejemplo: El siguiente programa prueba poner el objeto actual en una posición libre (esto es como la misma acción
para mover un objeto a una posición aleatoria):
{
do
{
x = random(roo m_width);
y = random(roo m_height);
}
until (place_free(x,y))
}
38.15.- Sentencia for:
Una declaración for tiene la forma:
for (<sentancia1> ; <expresión> ; <sentencia2>) <sentencia3>
Funciona de la siguiente manera. Primero se ejecuta la sentencia1, entonces se evalúa la expresión, si es verdadera, se
ejecuta la sentencia3, luego entonces la sentencia2 y luego se evalúa nuevamente la expresión; esto continua hasta
que la expresión sea falsa.
Esto puede sonar complicado. Deberías interpretar esto como sigue. La primera declaración inicializa el circuito for.
La expresión prueba si el ciclo debiera de terminar. La sentencia2 es la sentencia de paso hacia la evaluación del
siguiente ciclo. El uso más común en su mayoría de los casos, es para tener un contador corriendo hasta un cierto
valor.
Ejemplo
El siguiente programa inicia un orden de longitud 10 con los valores del 1 al 10.
{
for (i=0; i<=9; i+=1) list[i] = i+1;
}
38.16.- Sentencia s witch:
En un número de situaciones tal vez quieras dejar que tu acción dependa de un valor en particular. Puedes hacer esto
usando un número de sentencias if (si), pero es más sencillo utilizar la sentencia switch (interruptor). Una sentencia
switch tiene la siguiente estructura:
108](https://image.slidesharecdn.com/manualgm6-1practico-100619093410-phpapp01/85/Manual-gm6-1-practico-108-320.jpg)
![Los argumentos de los scripts son los parámetros (opcionales) que le puedes enviar a un script a la hora de ejecución
para indicarle que y como hacerlo.
Por ejemplo, este sencillo script:
{
/*
Script Cuadrado(Número)
//devuelve el cuadrado del número proporcionado
if is_real(argument0)
return argument0*argument0;
else
return 0;
}
OK, para que quede claro este script simplemente devuelve el cuadrado de su argumento 1 (índice 0)
así, en cualquier lugar podrías poner esto;
Variable = Cuadrado(2) y en efecto, eso te devolvería un 4 p or ejemplo.
Se pueden usar hasta 16 argumentos en una función, los cuales se pondrían de la sigu iente manera en la función:
function(argument0,….argument16)
Una función tiene la forma del nombre de una función, seguido por ninguno o más argumentos entre paréntesis,
separados por comas.
Nota que en una función sin argumentos debes necesariamente usar los paréntesis. Algunas funciones regresan
valores y pueden ser usados en expresiones. Otras simplemente ejecutan comandos.
Nota que es imposible usar una función como la parte izquierda de una asignación. Por ejemplo, no puedes escribir
instance_nearest(x,y,obj).speed = 0. Porque lo correcto que deberías de escribir es: (instance_nearest(x,y,obj)).speed
= 0.
40.- Scripts:
Cuando creas un script, querrás tener acceso a los argumentos enviados a él (ya sea cuando uses una acción script, o
cuando llames al script como una función desde un programa u otro, o inclusive desde el mismo script). Estos
argumentos se almacenan en las variables argument0, argument1, …, argument15. Por lo que puede haber como
máximo 16 argumentos. (Nota: Cuando se llama un script desde una acción, sólo se pueden especificar los primeros
5 argumentos). Puedes usar también argument[0], etc.
Los scripts también pueden devolver un valor, por lo que pueden ser empleados en expresiones. Para ello debes
emplear la declaración return:
return (<expresión>)
¡La ejecución del script termina en la sentencia return!
Ejemplo:
Aquí está la definición de un pequeño script que calcula el cuadrado del argumento:
{
return (argu ment0*argument0);
}
Para llamar un script desde una pieza de código, solo hazlo, como cuando se hacen las llamadas a funciones. Esto es,
el nombre del script con sus argumentos entre paréntesis.
41.- Construcciones with:
Como se indicó antes, es posible leer y cambiar el valor de las variables en otras instancias. Pero en ciertos casos
querrás hacer mucho más con esas otras instancias. Por ejemplo, imagina que deseas mover todas las pelotas 8
píxeles hacia abajo. Pudieras pensar que eso se logra con el siguiente código:
pelota.y = pelota.y + 8;
110](https://image.slidesharecdn.com/manualgm6-1practico-100619093410-phpapp01/85/Manual-gm6-1-practico-110-320.jpg)
![Los nombres de variables con [0..n] después de ellos son ordenes (arrays). Y se da el intervalo posible de sus índices.
44.- Haciendo cálculos o Computando cosas:
El Game M aker contiene un gran número de funciones para llevar a cabo diversos cálculos. A continuación se verá
la lista completa.
44.1.-Constantes:
Las siguientes constantes matemáticas están disponibles:
true Igual a 1.
false Igual a 0.
pi Igual a 3.1415…
44.2.- Funci ones basadas en val ores reales (números):
Las siguientes funciones disponibles manejan números reales:
random (x): Devuelve un número real entre 0 y x. El número siempre es menor al valor de x.
choose (val1,val2,val3,…) Devuelve una de los argumentos de forma aleatoria, la función acepta un máximo de 16
argumentos.
abs (x): Devuelve el valor absoluto de x.
sign (x): Devuelve el signo de x (-1 or 1).
round (x): Devuelve x redondeado al entero más cercano.
floor (x): Devuelve x redondeado al entero hacia abajo.
ceil (x): Devuelve x redondeado al entero hacia arriba.
frac (x): Devuelve la parte fraccional de x, es decir, la parte detrás del punto decimal.
sqrt (x): Devuelve la raíz cuadrada de x. El valor de no debe ser negativo.
sqr (x): Devuelve el valor cuadrado de x.
power (x,n): Devuelve x elevado a la potencia n.
exp (x): Devuelve e elevado a la potencia x.
ln (x): Devuelve el logaritmo natural de x.
log2 (x): Devuelve el logaritmo base 2 de x.
log10 (x): Devuelve el logaritmo base 10 de x.
logn (n,x): Devuelve el logaritmo base n de x.
sin (x): Devuelve el seno de x (x en radianes).
cos (x): Devuelve el coseno de x (x en radianes).
tan (x): Devuelve la tangente de x (x en radianes).
arcsin (x): Devuelve el arcoseno de x.
arccos (x): Devuelve el arcocoseno de x.
arctan (x): Devuelve el arcotangente de x.
arctan2 (y, x): Calcula el arcotangente de (Y/X), y devuelve un ángulo en el cuadrante correcto.
degtorad (x): Convierte grados a radianes.
radtodeg (x): Convierte radianes a grados.
min (val1,val2,val3…): Devuelve el menor de los valores, soporta hasta 16 argumentos. Los valores deben ser todos
números reales o cadenas de texto.
max (val1,val2,val3…): Devuelve el mayor de los valores, soporta hasta 16 argumentos. Los valores deben ser todos
números reales o cadenas de texto
min3 (x, y, z): Devuelve el mínimo de los valores x, y y z.
max3 (x, y, z): Devuelve el máximo de los valores x, y y z.
mean (val1, val2, val3…): Devuelve el promedio de los valores, soprta hasta 16 argumentos. Los valores deben de
ser números reales.
M edian(val1, val2, val3…) Devuelve el valor intermedio de los valores o argumentos introducidos (Cuando el
número de argumentos es parejo, el menor de los dos valores intermedios, es el que devuelve la función). Soporta
hasta 16 argumentos, los valores deben de ser números reales.
point_distance (x1, y1, x2, y2): Devuelve la distancia existente entre el punto (x1,y1) hacia el punto (x2,y2).
point_direction (x1, y1, x2, y2): Devuelve la dirección desde el punto (x1,y1) hacia el punto (x2,y2) en grados.
lengthdir_x (len,dir) Devuelve el componente horizontal (x) del vector determinado por la longitud y dirección
indicadas.
lengthdir-y (len,dir) Devuelve el componente vertical de (y) del vector determinado por la longitud y la dirección
indicadas.
is_real (x): Averigua cuando (x) es un valor real. (Diferenciándolo de una cadena de texto)
is_string (x): Averigua cuando (x) es una cadena de texto. (Diferenciándolo de un número real).
112](https://image.slidesharecdn.com/manualgm6-1practico-100619093410-phpapp01/85/Manual-gm6-1-practico-112-320.jpg)
![ygoal el final del mismo, allowdiag indica si los movimientos diagonales están permitidos, o solamente horizontales
y verticales. La función devuelve si encontró el path correctamente.
mp_grid_draw (id): Esta función dibuja la celda (grid) con celdas verdes como libres y rojas como ocupadas. Esta
función es lenta, y debería ser solamente usada a prueba de errores.
46.4.- Verificando colisiones:
Al planear movimientos o decidiendo sobre ciertas acciones, es a menudo importante ver si hay colisiones con otros
objetos en ciertos lugares. Las rutinas siguientes se pueden utilizar para esto. Todos estos tienen tres discusiones en
un campo común: El obj de la discusión puede ser un objeto, la palabra clave all, o la identificación de un caso. La
precisión de la colisión indica si debe ser exacta o basada solamente en la caja de limitación del objeto. La
comprobación exacta se hace solamente cuando el sprite, para el evento tiene la colisión exacta a comprobar del
sistema. El notme de la discusión se puede fijar para verdad para indicar que el caso que llama no debe ser
comprobado. Todas estas funciones vuelven cualquier la identificación de uno de los casos que chocan, o vuelven un
valor negativo cuando no hay colisión.
collision_point (x, y, obj, prec, notme): Verificas con esta función si en el punto (x, y) hay una colisión con las
entidades del obj del objeto.
collision_rectangle (x1, y1, x2, y2, obj, prec, notme): Verificas con esta función si hay una colisión entre el
rectángulo (llenado) con indicado enfrente de esquinas y las entidades del obj del objeto. Por ejemplo, puedes utiliz ar
esto para probar si un área está libre de obstáculos.
collision_circle (xc, yc, radius, obj, prec, notme): Verificas con esta función si hay una colisión entre el círculo
(llenado) centrado en la posición (xc, yc) con el radio y las entidades dados del obj del objeto. Por ejemplo, puedes
utilizar esto para probar si hay un objeto cerca de una localización particular.
collision_ellipse (x1, y1, x2, y2, obj, prec, notme): Verificas con esta función si hay una colisión entre la elipse
(llenada) con indicado enfrente de esquinas y las entidades del obj del objeto.
collision_line (x1, y1, x2, y2, obj, prec, notme): Verificas con esta función del si hay una colisión entre la línea
segmento (x1, y1) (x2, y2) y entidades del obj del objeto. Esta es una función de gran alcance. Puedes por ejemplo
utilizarla para probar si un caso puede considerar otro caso comprobando si la línea segmento entre ellos interseca
una pared.
46.5.- Instancias de objetos:
En el juego, las unidades básicas son las instancias de los diferentes objetos. Durante el juego puedes cambiar varios
aspectos de estas instancias. También puedes crear nuevas instancias y destruir otras. Además de las variables
relacionadas con el movimiento, mostradas arriba y las variables relacionadas con el dibu jo de las instancias que se
tratarán más adelante, cada instancia cuenta con las siguientes variables:
object_index*: Índice del objeto del cual es instancia. Esta variable no puede ser cambiada.
id*: El identificador único para la instancia (>=100000). (Nota: al definir cuartos siempre se muestra el id de la
instancia sobre la que se ponga el cursor, en la esquina inferior izquierda de la pantalla de cuartos.).
mask_index: Índice del sprite empleado como máscara para las colisiones. Da un valor de –1 para que sea igual a
sprite_index.
solid: Indica si la instancia es sólida. Puede cambiarse durante el juego.
persistent: Indica si la instancia es persistente y reaparecerá al moverse a un Nuevo cuarto. Normalmente desactivas
la persistencia en ciertos momentos. (Por ejemplo si vuelves al cuarto anterior).
Sólo hay un problema al manejar instancias, no es fácil identificar instancias individuales. No cuentan con un
nombre. Cuando sólo hay una instancia de un objeto en particular puedes usar el nombre del objeto pero en otros
casos requerirás obtener el id de la instancia. Este es un identificador único para la instancia, puedes emplearlo en las
sentencias with y como identificador de un objeto (el uso de la construcción. se describe en la sección 28.6).
Afortunadamente hay varias variables y rutinas que te ayudan a obtener los id de las instancias.
instance_count*: El número de instancias que existen actualmente en el cuarto.
instance_id[0..n-1]*: El id de la instancia en particular, n es el número de la instancia.
Permíteme darte un ejemplo. Considera que cada unidad en tu juego tiene un poder en particular y quieres encontrar
la más poderosa, pudieras usar el siguiente bloque de código:
{
maxid = -1;
maxpower = 0;
for (i=0; i<instance_count; i+=1)
{
iii = instance_id[i];
if (iii.object_index == unit)
118](https://image.slidesharecdn.com/manualgm6-1practico-100619093410-phpapp01/85/Manual-gm6-1-practico-118-320.jpg)
![instance_activate_all (): Activa todas las instancias en el cuarto.
instance_activate_object (obj): Activa todas las instancias en el cuarto de un objeto dado. También puedes usar todo
lo indicado para que todas las instancias tengan que activarse o la id de una instancia active una instancia individual.
instance_activate_region (left, top, width, height, inside): Activa todas las instancias en la región indicada. Si
inside es falso las instancias completamente fuera de la región son activadas.
Por ejemplo, para desactivar todas las instancias fuera de la vista y activar las que están dentro, puedes colocar el
siguiente código en el evento step del personaje móvil:
{
instance_activate_all();
instance_deactivate_region(view_ xview[0],v iew_yview[0],
view_wv iew[0],view_hview[0],false,true);
}
En la práctica querrás usar una región levemente más grande que la vista.
47.- Timing (Sincronización de tiempos):
Los buenos juegos requirieron de un cuidado especial en el manejo del tiempo, en que las cosas se llevaban a cabo
(timing). Afortunadamente el Game M aker se ocupa de la mayor parte del timing por ti. Se asegura de que las cosas
ocurran con un ritmo constante. Este ritmo es definido al definir los cuartos. Pero puedes cambiarlo usando la
variable global room_speed. Así por ejemplo, puedes incrementar lentamente la velocidad del juego, haciéndolo más
difícil, agregando una muy pequeña cantidad (como 0.001) a room_speed en cada step. Si tu máquina es lenta la
velocidad del juego pudiera no alcanzarse. Esto puede verificarse usando la variable fps que monitorea
constantemente el número actual de cuadros por segundo. Finalmente, para un timing avanzado puedes usar la
variable current_time que te da el número de milisegundos desde que la computadora fue iniciada. Aquí está la
colección completa de variables disponibles (sólo la primera puede ser cambiada):
room_speed: Velocidad del juego en el cuarto actual (en steps por segundo).
fps*: Número de cuadros que son dibujados por segundo.
current_time*: Número de milisegundos que han pasado desde que el sistema fue iniciado.
current_year*: El año actual.
current_month*: El mes actual.
current_day*: El día actual.
current_weekday*: El día actual de la semana (1=domingo, …, 7=sábado).
current_hour*: La hora actual.
current_minute*: El minuto actual.
current_second*: El segundo actual.
Algunas veces querrás detener el juego por un corto periodo. Para esto, usa la función sleep.
sleep (Num): Pausa el juego por cierta cantidad de tiempo especifico en (Num) milisegundos.
Como debes saber, cada instancia tiene 8 alarmas diferentes que puedes configurar. Para cambiar los valores (u
obtener los valores) de las diferentes alarmas usa la siguiente variable:
alarm[0..7]: Valor de la alarma indicada. (Nota: ¡las alarmas solo se actualizan cuando el evento de alarma para el
objeto contiene acciones!)
Hemos visto que para los problemas de un timing complejo puedes usar el recurso de las líneas de tiempo (time
lines). Cada instancia puede tener un recurso time line asociado con ella. Las siguientes variables están relacionadas
con esto:
timeline_index: Índice de la time line asociada con la instancia. Puedes establecerlo a una time line en particular para
usarla. Ponlo en –1 para dejar de usar la time line para la instancia.
timeline_position: Posición actual dentro de la time line. Puedes cambiarla para saltar o repetir ciertas partes.
timeline_speed: Normalmente, en cada step la posición en la time line se incrementa en 1. Puedes cambiar esta
cantidad configurando esta variable a un valor diferente. Puedes usar números reales, p. Ej. 0.5, si el valor es mayor
que uno, varios momentos pueden ocurrir dentro del mismo tiempo del step. Se realizarán en el orden correcto, por lo
que no se saltará ninguna acción.
48.- Variables y Funciones para los cuartos (Rooms):
Los juegos funcionan en cuartos. Cada cuarto tiene un índice que se indica por el nombre del cuarto. El cuarto actual
es almacenado en la variable room. No puedes asumir que los cuartos están numerados en un orden consecutivo. Por
120](https://image.slidesharecdn.com/manualgm6-1practico-100619093410-phpapp01/85/Manual-gm6-1-practico-120-320.jpg)
![background_color: El color de fondo del cuarto
background_showcolor: Indica si despejar la ventana en el color del fondo
background_visible[0..7]: Indica sI la imagen de fondo es visible.
background_foreground[0..7]: Indica si el fondo es una imagen de primer plano.
background_index[0..7]: Índice de la imagen del fondo.
background_x[0..7]: Posición X de la imagen de fondo.
background_y[0…7]: Posición Y de la imagen de fondo.
background_width[0…7]*: Ancho de la imagen de fondo.
background_height[0…7]*: Altura de la imagen de fondo.
background_htiled[0..7]: Indica si el fondo es de mosaico horizontalmente.
background_vtiled[0..7]: Indica si el fondo es de mosaico vertical.
background_hspeed[0..7]: Velocidad de desplazamiento horizontal del fondo (píxeles p or paso).
background_vspeed[0..7]: Velocidad de desplazamiento vertical del fondo (píxeles por paso).
background_alpha[0..7]: Valor de transparencia (alpha) al dibujarse el fondo. Un valor de 1 es el valor normal; un
valor de 0 es completamente transparente. Úsalo con cuidado. Dibujar un fondo parcialmente transparente toma
mucho tiempo y puede hacer lento el juego.
background_blend[0..7]: Color de mezclado para dibujar el background. Solo disponible en la versión registrada.
53.3.- Di bujando fondos y sprites:
Los objetos normalmente poseen un sprite asociado a el. Sin embargo, puedes usar el evento draw para dibujar otras
cosas. Esta sección y la siguiente le darán la información necesaria para lograr esto.
draw_sprite (spr, subimg, x, y): Dibuja el sprite spr en la subimagen subimg en la posición (x, y).
draw_sprite_stretched (sprite, subimg, x, y, w, h): Dibuja el sprite estirado para que entre en la región dada.
draw_sprite_tiled (sprite, subimg, x, y): Dibuja el sprite repetido para que entre en todo el room.
draw_sprite_part (s prite, subimg, left, top, width, height, x, y): Dibuja la parte del sprite en la subimagen, con los
valores dados.
draw_background (back, x, y): Dibuja un background en posición (x, y).
draw_background_stretched (back, x, y, w, h): Dibuja un background estirado en la región indicada.
draw_background_tiled (back, x, y): Dibuja un background repetido para que entre en todo el room.
draw_background_part (back, left, top, width, height, x, y): Dibuja la parte indicada del background.
Las siguientes funciones extienden las funciones indicadas anteriormente. Solo disponibles en la versión registrada:
draw_sprite_ext (sprite, subimg, x, y, xscale, yscale, rot, color, alpha): Dibuja el sprite escalado con los factores
xscale e yscale, rotados anti-horario según rot. Color es el color de mezclado usado (Use c_white para no mezclado)
Y alpha indica la transparencia en la que es dibujado. Un valor de 0 lo hace completamente transparente. Un valor de
1 lo dibuja con la transparencia normal.
draw_sprite_stretched_ext (sprite, subimg, x, y, w, h, color, alpha): Dibuja un sprite estirado para que entre en la
región indicada, color es el color de mezclado y alpha indica la transparencia.
draw_sprite_tiled_ext (sprite, subimg, x, y, xscale, yscale, color, alpha): Dibuja un sprite repetido para que entre
totalmente en el room, pero ahora con escala, color, y transparencia.
draw_sprite_part_ext (sprite, subimg, left, top, width, height, x, y, xscale, yscale, color, alpha): Dibuja la parte
indicada del sprite, pero ahora con escala, color y transparencia.
draw_sprite_general (sprite, subimg, left, top, width, height, x, y, xscale, yscale, rot, c1, c2, c3, c4, alpha): La
función para dibujar sprites más general de todas. Dibuja una parte del sprite, en la subimagen, empezando por left
como borde izquierdo, y top como borde superior. Con el ancho width y altura height, en la posición (x, y). Escalado
horizontalmente por xscale y verticalmente por yscale. Rotado según rot, con los colores de mezclados c1, c2, c3 y
c4. Y con la transparencia alpha.
draw_background_ext (back, x, y, xscale, yscale, rot, color, alpha): Dibuja el background escalado y rotado con
color de mezclado y transparencia.
draw_background_stretched_ext (back, x, y, w, h, color, alpha): Dibuja el background estirado en la región
indicada. Color es el color de mezclado y alpha indica la transparencia.
draw_background_tiled_ext (back, x, y, xscale, yscale, color, alpha): Dibuja el background repetido para que
entre en el room, pero ahora con escala, color y transparencia.
draw_background_part_ext (back, left, top, width, height, x, y, xscale, yscale, color, alpha): Dibuja la parte
indicada del background, pero ahora con escala, color y transparencia.
draw_background_general (back, left, top, width, height, x, y, xscale, yscale, rot, c1, c2, c3, c4, alpha): La
función más general para dibujar backgrounds. Dibuja la parte indicada por top -left (Borde izquierdo y borde
superior) en la posición (x, y) pero con escala, ángulo de rotación, y un color para cada vértice. También un valor de
transparencia (alpha).
128](https://image.slidesharecdn.com/manualgm6-1practico-100619093410-phpapp01/85/Manual-gm6-1-practico-128-320.jpg)
![Puedes controlar las views por medio del GM L. Puedes hacer views visibles e invisibles, modificarles el tamaño y el
lugar, la posición en el room. Puedes modificar el tamaño del espacio horizontal y vertical alrededor del objeto al que
sigue, y puedes indicar a que objeto debe seguir.
Las siguientes variables existen para modificar todos los aspectos de las views.
view_enabled: Si las views están habilitadas o no.
view_current*: La view que está siendo actualmente dibujada. Esto es útil para, por ejemplo, asegurarte de que algo
se dibuje solamente en una view.
view_visible[0..7]: Si una view en particular es visible en la pantalla.
view_xview[0..7]: Posición en x de la view en el room.
view_yview[0..7]: Posición en y de la view en el room.
view_wview[0..7]: Ancho de la view en el room.
view_hview[0..7]: Altura de la view en el room.
view_xport[0..7]: Posición en x del viewport.
view_yport[0..7]: Posición en y del viewport.
view_wport[0..7]: Ancho del viewport.
view_hport[0..7]: Altura del viewport.
view_angle[0..7]: Ángulo de rotación usado por la view en el room. (Especificado en grados y anti-horario)
view_hborder[0..7]: Tamaño horizontal del hborder en píxeles.
view_vborder[0..7]: Tamaño vertical del hborder en píxeles.
view_hspeed[0..7]: Velocidad horizontal de la view.
view_vs peed[0..7]: Velocidad vertical de la view.
view_object[0..7]: El objeto que debe permanecer siempre visible en la view, en otras palabras, el objeto al que la
view sigue.
En el juego puedes necesitar conocer la posición del cursor del M ouse respecto a las views, para lograr esto, existen
las siguientes funciones.
window_view_mouse_get_x (id): Devuelve la posición en x del cursor del M ouse, respecto a la view dada.
window_view_mouse_get_y (id): Devuelve la posición en y del cursor del M ouse, respecto a la view dada.
window_view_mouse_set (id, x, y): M odifica la posición del cursor del M ouse respecto a la view dada.
window_views_mouse_get_x (): Devuelve la posición del M ouse. Lo mismo que la variable mouse_x.
window_views_mouse_get_y (): Devuelve la posición del M ouse. Lo mismo que la variable mouse_y.
window_views_mouse_set (x, y): Modifica la posición del M ouse, respecto a la primer view visible.
53.12.- Transiciones:
Como debes saber cuando te mueves de un room a otro, puedes seleccionar un tipo de transición. M odificando la
variable transition_kind usted puede asignar una transición predefinida con el Game M aker. Un valor de 0 indica sin
transición. Para asignar la transición deseada, puede usar los siguientes valores.
transition_kind Indica la transición que poseerá el siguiente frame. Use los siguientes valores:
0 = Sin efecto 1 = Crear por izquierda. 2 = Crear por derecha.
3 = Crear por arriba. 4 = Crear por debajo. 5 = Crear por el centro.
6 = M over por la izquierda. 7 = M over por la derecha. 8 = M over por arriba.
9 = M over por debajo. 10 = Entrelazar por izquierda. 11 = Entrelazar por derecha.
12 = Entrelazar por arriba. 13 = Entrelazar por debajo.
Tenga en cuenta que es fácil hacer tus propias transiciones usando las diversas funciones de dibujo. Por ejemplo, para
hacer un efecto de oscurecer a negro, puedes dibujar un rectángulo incrementando su alpha.
53.13.-Redi bujando o refrescando la pantalla:
Normalmente al final de cada step, el room es redibujado. Pero en raras ocasiones, necesitas dibujar el room en otros
momentos. Por ejemplo, si quieres mostrar un mensaje, y esperar que el jugador presione una tecla para continuar,
deberás redibujar la pantalla para que el texto se pueda leer.
screen_redraw (): Redibuja el room llamando a todos los eventos Draw.
screen_refresh (): Redibuja la pantalla usando la imagen actual del room. (No llamando a los eventos Draw).
Para entender como funciona la segunda función, deberás saber como funciona el dibujado internamente.
Internamente hay una imagen en donde se dibuja todo. Esta imagen no es visible en la pantalla. Solo al final de cada
step, la imagen de la pantalla es reemplazada por esta imagen interna. (Esto es llamado doble buffering).
136](https://image.slidesharecdn.com/manualgm6-1practico-100619093410-phpapp01/85/Manual-gm6-1-practico-136-320.jpg)
![En raras situaciones puedes necesitar leer datos binarios de los archivos. Existen las siguientes funciones para esto:
file_bin_open (fname, mod): Abre el archivo con el nombre indicado. El modo indica que se puede hacer con el
archivo: 0 = lectura, 1 = escritura, 2 = ambos. La función devuelve el id del archivo que debe ser usado en otras
funciones. Puedes abrir múltiples archivos a la vez, (32 máximo). No olvides cerrarlos una vez que hayas terminado
de trabajar con ellos.
file_bin_rewrite (fileid): Borra el contenido del archivo dado. Nota: No borra el archivo, solo sus datos.
file_bin_close (fileid): Cierra el archivo especificado.
file_bin_size (fileid): Devuelve el tamaño en bytes del archivo especificado.
file_bin_position (fileid): Devuelve la posición actual del archivo dado. (en bytes, 0 es el principio).
file_bin_seek (fileid, pos): M ueve la posición en el archivo a la indicada.
file_bin_write_byte (fileid, byte): Escribe un byte de dato en el archivo especificado.
file_bin_read_byte (fileid): Lee un byte de dato desde el archivo especificado.
Si el jugador ha puesto modo seguro (secure mode) en sus preferencias, unas cuantas de estas funciones no estarán
disponibles.
Las siguientes variables de sólo lectura le pueden resultar útiles.
game_id*: Identificador único del juego.
working_directory*: El directorio en donde se encuentra el juego. Sin incluir la barra final.
temp_directory*: Directorio temporal creado por el juego. Puedes almacenar archivos aquí, que serán eliminados
cuando el juego termine.
58.2.- Registro:
Si deseas guardar una pequeña cantidad de información, puedes usar un mecanismo más simple que usar un archivo.
Puedes usar el registro. El registro es una gran base de datos que Windows mantiene para llevar el rastro de muchas
cosas, generalmente referidas a la configuración de los programas. Un registro posee un nombre y un valor. Puedes
usar ambos tipos, textos o números. Las siguientes funciones existen:
registry_write_string (name, str): Crea una entrada en el registro con el nombre y el texto dado.
registry_write_real (name, x): Crea una entrada en el registro con el nombre y el valor real dado.
registry_read_string (name): Devuelve el texto que el nombre posee. El nombre debe existir, en caso contrario
devuelve un texto vacío.
registry_read_real (name): Devuelve el valor real que el nombre posee. El nombre debe existir, en caso contrario 0
es retornado.
registry_exists (name): Devuelve si el nombre dado existe.
En realidad, los datos en el registro están agrupados dentro de keys. Las funciones anteriores, funcionan en la key que
es creada especialmente para tu juego. El programa puede usar estas funciones para obtener cierta información sobre
el sistema mientras el juego está siendo ejecutado. Incluso puedes leer datos en otras keys. Incluso puedes escribir
datos en otras keys. Pero ten cuidado PUED ES LLEGAR A DAÑ AR TU S IS TEMA. La escritura en el registro no
está permitida en modo seguro.
registry_write_string_ext (key, name, str): Crea una entrada en la key especificada en el registro, con el nombre y
valor de texto.
registry_write_real_ext (key, name, x): Crea una entrada en la key especificada en el registro, con el nombre y
valor real.
registry_read_string_ext (key, name): Devuelve el string que se encuentra con el nombre indicado en la key
indicada.
registry_read_real_ext (key, name): Devuelve el valor real que se encuentra con el nombre indicado en la key
indicada.
registry_exists_ext (key, name): Devuelve si el nombre dado en la key dada, existe.
registry_set_root (root): M odifica la raíz para las otras rutinas. Para key utilice los siguientes valores:
0 = HKEY_CURRENT_USER
1 = HKEY_LOCAL_MACHINE
2 = HKEY_CLASSES_ROOT
3 = HKEY_USERS
58.3.- Archi vos INI:
Para pasar una cierta cantidad de parámetros, a los programas existe el mecanismo estándar, que es el uso de los
archivos INI. Los archivos INI contienen secciones, y en cada sección un número de keys y valores. Por ejemplo, este
es un típico archivo INI:
[Teclas]
149](https://image.slidesharecdn.com/manualgm6-1practico-100619093410-phpapp01/85/Manual-gm6-1-practico-149-320.jpg)
![Right=39
Up=38
Left=37
Down=40
[Juego]
Vidas=2
Energía=50
Nombre=Diego
Este archivo INI contiene 2 secciones (Teclas y Juego). En la sección Teclas hay 4 keys (Right, Up, Left y Down).
Con su valor correspondiente. En la sección Juego hay 3 keys (Vidas, Energía y Nombre). Los archivos INI son muy
fáciles de usar, las siguientes funciones existen:
ini_open (name): Abre un archivo INI con el nombre dado. El archivo debe estar en el mismo directorio que el
juego.
ini_close (): Cierra el archivo INI que se encuentre abierto.
ini_read_string (section, key, default): Lee el valor de texto en la sección indicada, con la key indicada. Cuando la
key, el archivo, o la sección no existan, devolverá el valor especificado en default.
ini_read_real (section, key, default): Igual que la anterior, solo que lee un valor real.
ini_write_string (section, key, value): Escribe un valor de texto en la sección y la key especificada.
ini_write_real (section, key, value): Escribe un valor real en la sección y la key especificada.
ini_key_exists (section, key): Devuelve si la key especificada existe en la sección indicada.
ini_section_exists (section): Devuelve si la sección existe.
ini_key_delete (section, key). Elimina la key de la sección.
ini_section_delete (section): Elimina la sección dada.
58.4.- Ejecutando programas:
Game M aker posee la posibilidad de ejecutar programas externos. Hay 2 funciones disponibles para esto:
execute_program y execute_shell. La función execute_program ejecuta un programa, posiblemente con algunos
argumentos. Puede esp erar a que el programa termine (pausando el juego) o continuar el juego.
execute_program (prog, arg, wait): Ejecuta el programa prog con los argumentos arg. wait indica si el juego debe
pausarse o no.
execute_shell (prog, arg): Ejecuta el programa (o archivo) en el shell.
Ambas funciones no funcionarás si el jugador tiene activado modo seguro en preferencias. Puedes comprobar eso con
la siguiente variable de solo lectura.
secure_mode*: Si el juego está corriendo en modo seguro.
59.- Data Structures (Estructuras de Datos):
Esta funcionalidad está solamente disponible en la versión registrada del Game M aker.
En los juegos muy a menudo necesitas guardar información. Por ejemplo necesitas guardar la lista de objetos que una
persona lleva, o guardar lugares que deben ser visitados. Puedes usar arrays para esto. Pero si quieres hacer
operaciones más complicadas como ordenar, remover, buscar, etc. un objeto en particular, necesitarás escribir largos
códigos en GM L los cuales pueden realentizar el juego en su ejecución.
Para solucionar esto, Game M aker posee cierta cantidad de data structures (Estructuras de datos en español, de ahora
en más serán nombradas siempre data structures, acostúmbrense). Actualmente hay seis tipos de data structures
disponibles: stacks, queues (filas), lists, maps, priority queues y grids. Cada uno con sus funciones y ventajas.
Todas las data structures funcionan globalmente igual. Puedes crear una data structure con una función que devuelve
su id. Luego usas este id para ejecutar ciertas operaciones de las data structures. Una vez que no necesites más la data
structure la puedes eliminar liberando memoria. Puedes usar la cantidad de data structures que quieras al mismo
tiempo, si así lo deseas. Todas las data structures pueden guardar ambos, strings y valores reales.
Tenga en cuenta que toda la información que contengan las data structures no serán guardadas cuando el juego sea
guardado usando las funciones para eso. Si deseas guardar información de las data structures deberá usar su propio
mecanismo de guardar/cargar juego.
Cuando se comparen valores, por ejemplo cuando estés buscando en un mapa, u ordenando una lista, Game M aker
debe decidir que hacer cuando 2 valores son iguales. Para números enteros o textos, esto es claro, pero cuando son
números reales, no lo es debido a los errores de redondeo. Por ejemplo (5/3)*3 no será igual a 5. Para evitar esto, la
precisión es usada. Cuando la diferencia entre 2 números es más pequeña que la precisión usada, estos números se
consideran iguales. La precisión por defecto es 0.0000001. Puedes cambiar la precisión usada con la siguiente
función:
ds_set_precition (prec): Fija la precisión usada para comparaciones en Data Structures.
150](https://image.slidesharecdn.com/manualgm6-1practico-100619093410-phpapp01/85/Manual-gm6-1-practico-150-320.jpg)
![library MyDLL;
uses SysUtils, Classes;
function MyM in(x,y:double):double; cdecl;
begin
if x<y then Result := x else Result := y;
end;
var res : array[0..1024] of char;
function DoubleString(str:PChar):PChar; cdecl;
begin
StrCopy(res,str);
StrCat(res,str);
Result := res;
end;
exports MyM in, DoubleString;
begin
end.
Esta DLL define 2 funciones MyM in que toma 2 argumentos reales y devuelve el mínimo de los 2. Y DoubleString
que dobla el string. Tenga en cuenta tener cuidado con como trata la memoria. management . Una vez que construyas
la DLL en Delphi obtendrás un archivo llamado M yDLL.DLL. Este archivó debe ponerse en el directorio donde se
ejecuta el juego. O en cualquier otro lugar donde Windows pueda encontrarlo.
Para usar la DLL en Game M aker primero debes especificar la función externa que desees usar con los argumentos
que desees tomar. Para esto existen las siguientes funciones en GM L:
external_define (dll, name, calltype, restype, argnumb, arg1type, arg2type, ...): Define una función externa, dll
es el nombre de la dll, name es el nombre de la función, calltype es el modo de llamado usado, usa dll_cdecl o
dll_stdall restype es el tipo de dato devuelvo, use ty_real o ty_string, argnumb es la cantidad de argumentos que
posee la función. Los demás argumentos son los tipos de datos usados para cada argumento en la función, use ty_real
o ty_string
Esta función retorna el id de la función externa, que debe ser usada para llamarla. Entonces, suponiendo el ejemplo de
DLL mencionado anteriormente, podrías usar el siguiente código GM L:
{
global.mmm = external_define('M YOW N.DLL','MyMin',dll_cdecl,
ty_real,2,ty_real,ty_real);
global.ddd = external_define('M YOW N.DLL','DoubleString',dll_cdecl,
ty_string,1,ty_string);
}
Ahora, cuando quieras llamar las funciones, usas la siguiente función:
external_call (id, arg1, arg2,...): Llama la función externa con el id dado, y con los argumentos dados. Debes pasar
la correcta cantidad de argumentos y el correcto tipo de argumento (real o string). La función devuelve lo que
devuelve la función de la DLL.
Entonces, por ejemplo, podrías escribir:
{
aaa = external_call(global.mmm,x,y);
sss = external_call(global.ddd, "Ho la");
}
Si no necesitas usar más la DLL, deberías liberarla de la memoria, la siguiente función te permite esto:
external_free (dll): Libera de la memoria la DLL con el nombre dado.
A veces puedes querer hacer una DLL que haga algo específico en el juego. Como hacer una DLL que agrega
instancias u objetos en tu juego. La manera más fácil sería hacer que la DLL retorne un string que contenga el código
de GM L para lograr esto. El string puede ser ejecutado usando la siguiente función:
execute_string (str): Ejecuta el código en el string str.
163](https://image.slidesharecdn.com/manualgm6-1practico-100619093410-phpapp01/85/Manual-gm6-1-practico-163-320.jpg)
![Ir al cuarto indicado
Imagen de la acción Efecto de transición Código escrito
Sin efectos room_goto(rm_ejemplo20)
Si el anterior existe
Imagen de la acción Efecto de transición Código escrito
Sin efectos if (room_previous(room)>-1)
room_goto_previous()
Con esta instrucción se mueve al cuarto anterior del juego escríbela tal y como esta.
Ir al cuarto siguiente
Imagen de la acción Efecto de transición Código escrito
Sin efectos if (room_next(room)>-1)
room_goto_next()
Vamos ahora con la pestaña principal 2.
Alarma
Imagen de la acción Alarma 0, tiempo asignado Código escrito
0, tiempo 20 alarm[0]=20
Relativa alarm[0]=alarm[0]+20
Dormir o Pausar
Imagen de la acción Tiempo asignado en milisegundos Código escrito
1000 = 1 segundo falso sleep(1000);
En modo Verdadero screen_redraw();
sleep(1000);
Asignar línea de tiempo a un objeto
Imagen de la acción Nombre del objeto, posición Código escrito
tml_ejemplo, posición 0 timeline_index=tml_ejemplo
timeline_position=0
Asignar la posición a la línea de tiempo
Imagen de la acción Tiempo de posición Código escrito
0 timeline_position=0
M ostrar mensaje
Imagen de la acción M ensaje a mostrar Código escrito
Hola show_message("Hola");
M ostrar información del juego
Imagen de la acción Código escrito
show_info();
179](https://image.slidesharecdn.com/manualgm6-1practico-100619093410-phpapp01/85/Manual-gm6-1-practico-179-320.jpg)
Manual gm6.1 practico
- 1. Diseñando juegos con el Game Maker. Versión 6.1 Creado por: Mark Overmars. Manual Teórico y de Ejercicios del Game Maker. Manual traducido al español o castellano, y ampliado en parte por: GMFénix Nota: Este tutorial es una recopilación, y traducción del Archivo de ayuda del programa en si, algunas otras partes han sido tomadas de otros tutoriales que a publicado M ark Overmars creador del Game M aker, así como de otros tutoriales, que en algunos casos la traducción a sido llevada a cabo por Azhaag, Fenris78, Chico, Inte15, M ollomon, Kufru, de la comunidad del Game M aker (www.comunidadgm.tkk) otras partes, las de 3D son de los tutoriales de Correojon (correojon@gmail.com), quien también pertenece a la comunidad del Game M aker, Así como Alejandro Adrián Iglesias alías Tyranus en la CGM , otra parte la tome de un tutorial de Carlos Guidobono y Javier Filippini. La idea es completar más este manual con algunos ejercicios, y brindarte cierta información útil con respecto a otros programas, que te podrían llagar a ser útiles en el desarrollo de tus juegos, esta idea me surgió después de haber conocido y trabajado con el Game M aker. Y note que faltaba algo de información, que fuera más entendible para los que no conocemos mucho o nada de lo que es la programación, para facilitarnos la elaboración de nuestros juegos por muy sencillos que estos fueran. Ciertamente en Internet hay muchos archivos de ejemplo pero casi la mayoría si no es que todos vienen con piezas de código, y me gustaría encontrar más, con las simples opciones de Arrastrar y Soltar las acciones que maneja el Game M aker, para que así fueran más las personas que se integraran a desarrollar sus propios juegos y fueran comprendiendo mejor como se hacen y fueran avanzando, poco a poco desarrollando juegos más complejos posteriormente con el manejo de las piezas de código, o script . Si he tomado parte de algún otro tutorial presentado por alguna otra persona y no lo he comentado por favor ájamelo saber al siguiente correo electrónico, para incluirlo en los créditos de este compendio de manuales y ejercicios del Game M aker. a1969fenix@yahoo.com.mx.
- 2. Capi tul o Tema del capitulo Pagina Capitulo 1 El acuerdo de licencia del Game Maker. 8 Capitulo 2 Requerimientos mínimos e instalación del Game Maker. 9 Capitulo 3 Un breve Glosario. 9 Capitulo 4 Presentación y explicación del contenido de este manual. 10 Capitulo 4.1 Comenzando a utilizar el Game Maker. 10 Capitulo 4.2 Uso avanzado del Game Maker. 10 Capitulo 4.3 Terminando tú juego. 11 Capitulo 4.4 El lenguaje de programación del Game Maker. 11 Capitulo 5 ¿Qué hay de nuevo en la versión 6.1 del Game Maker? 11 Capitulo 5.1 El sistema de partículas. 11 Capitulo 5.2 El editor de imágenes. 12 Capitulo 6 El registro del Game Maker. 12 Capitulo 7 Algunas preguntas que te puedes estar haciendo. 12 Capitulo 7.1 ¿Para que sirve crear un video juego? 12 Capitulo 7.2 ¿Qué es un video juego? 12 Capitulo 7.3 ¿Por qué usar el Game Maker, para hacer mis juegos? 12 Capitulo 7.4 ¿Qué tipo de juegos puedo crear con el Game Maker? 13 Capitulo 7.5 ¿A que se le considera un buen juego? 13 Capitulo 7.6 ¿Qué hace que un juego tenga aceptación, o sea un 14 fracaso entre los usuarios de estos? Capitulo 8 Un juego de computadora es un programa en realida d. 14 Capitulo 8.1 Un juego de ordenador debe implica a los jugadores 14 Capitulo 8.2 Los objetos y recursos del juego 14 Capitulo 8.3 La meta o propósito del juego 14 Capitulo 8.4 Alcanzando la meta o propósito del juego 15 Capitulo 8.5 Tomando decisiones 15 Capitulo 8.6 Balance del juego. 16 Capitulo 8.6.1 El equilibrio entre los jugadores. 16 Capitulo 8.6.2 El equilibrio entre el jugador y el juego. 16 Capitulo 8.6.3 El equilibrio entre los diferentes elementos del juego. 17 Capitulo 8.7 Las recompensas. 17 Capitulo 8.8 La inme rsión del jugador en el juego. 18 Capitulo 9 Los distintos géneros de juegos. 18 Capitulo 10 La idea global, del modelo de programación. 19 Capitulo 11 Conociendo la interfase del Game Maker en modo 21 sencillo Capitulo 11.1 File (Menú Archivo). 21 Capitulo 11.2 Edit (Menú Edición). 22 Capitulo 11.3 Add (Menú Agregar). 22 Capitulo 11.4 Run (Menú Ejecutar). 22 Capitulo 11.5 Windows (Menú ventanas). 22 Capitulo 11.6 Help (Menú Ayuda) 22 Capitulo 11.7 El explorador de recursos en modo sencillo. 23 Capitulo 11.8 Eliminación de recursos. 23 Capitulo 12 Definiendo y agregando las imágenes en modo sencillo. 23 Capitulo 13 Definiendo y agregando sonidos y música en modo sencillo. 24 Capitulo 14 Definiendo y agregando los fondos en modo sencillo. 25 2
- 3. Capitulo 15 Definiendo y agregando los objetos en modo sencillo. 25 Capitulo 16 Conociendo los eventos. 26 Capitulo 17 Conociendo las acciones. 30 Capitulo 17.1 Move (Pestaña de movimie ntos). 30 Capitulo 17.2 Main 1 (Pestaña principal 1). 32 Capitulo 17.3 Main 2 (Pestaña principal 2). 34 Capitulo 17.4 Control (Pestaña de control). 35 Capitulo 17.5 Score (Pestaña de puntuación). 37 Capitulo 17.6 Draw (Pestaña de dibujo). 39 Capitulo 17.7 Usando expresiones y variables en modo sencillo. 40 Capitulo 18 Creando los cuartos o niveles de juego en modo sencillo. 41 Capitulo 18.1 Estableciendo el fondo. 41 Capitulo 18.2 Configurando los cuartos o niveles de juego. 41 Capitulo 18.3 Agregando objetos a los cuartos o niveles de juego. 41 Capitulo 19 Estableciendo un sencillo eje mplo de juego. 42 Capitulo 19.1 La idea global del juego. 43 Capitulo 19.2 El documento de diseño. 43 Capitulo 19.3 El orden de creación. 44 Capitulo 19.4 Comenzando a trabajar con el Game Maker, y con el 45 ejemplo. Capitulo 19.5 Brindando información al usuario del juego. 53 Capitulo 20 Distribuyendo tú juego en modo sencillo. 55 Capitulo 21 Uso avanzado del Game Maker. 55 Capitulo 21.1 Conociendo la interfase en modo avanzado. 55 Capitulo 21.2 File (Menú Archivo) en modo avanzado. 56 Capitulo 21.3 Edit (Menú Edición) en modo avanzado. 57 Capitulo 21.4 Add (Menú Agregar) en modo avanzado. 57 Capitulo 21.5 Script (Menú Escritura) en modo avanzado. 57 Capitulo 22 Uso avanzado de las imágenes. 57 Capitulo 22.1 Uso avanzado del editor de imágenes. 57 Capitulo 22.2 File (Menú Archivo) del editor de imágenes. 58 Capitulo 22.3 Edit (Menú Edición) del editor de imágenes. 58 Capitulo 22.4 Trasform (Menú trasformación) del editor de imágenes. 58 Capitulo 22.5 Image (Menú imagen) del editor de imágenes. 59 Capitulo 22.6 Animation (Menú animación) del editor de imágenes. 59 Capitulo 23 Strips o sprites. 60 Capitulo 23.1 Editando imágenes individualmente. 61 Capitulo 23.2 Configurando las opciones avanzadas de las imágenes. 61 Capitulo 24 Uso avanzado de los sonidos y la música. 62 Capitulo 25 Uso avanzado de los fondos. 63 Capitulo 26 Uso avanzado de los objetos. 63 Capitulo 26.1 Profundidad. 63 Capitulo 26.2 Los objetos persistentes. 63 Capitulo 26.3 Los objetos padres. 63 Capitulo 26.4 Las mascaras. 64 Capitulo 26.5 ¿Cómo obtener la información de los objetos? 64 Capitulo 27 Acciones avanzadas. 65 Capitulo 27.1 Acciones de movimiento avanzado. 65 3
- 4. Capitulo 27.2 Acciones principales 2 avanzadas. 66 Capitulo 27.3 Acciones de control avanzado. 66 Capitulo 27.4 Acciones de dibujo avanzado. 66 Capitulo 28 Acciones extra, conociendo las partículas. 67 Capitulo 28.1 Creando partículas sin usar el lenguaje de programación 68 del Game Maker (Ejemplo). Capitulo 28.2 Creando las subpartículas sin usar el lenguaje de 70 programación del Game Maker (Ejemplo). Capitulo 29 Conociendo la programación algorítmica en el Game 71 Maker. Capitulo 29.1 La estructura secuencial. 73 Capitulo 29.2 La estructura alternativa. 74 Capitulo 29.3 La estructura repetitiva. 74 Capitulo 29.4 Creando un juego con el lenguaje de programación del 75 Game Maker. Capitulo 30 Uso avanzado de los cuartos o niveles de juegos. 78 Capitulo 30.1 Las opciones avanzadas de los cuartos o niveles de 78 juegos. Capitulo 30.2 Agregando Tiles (Mosaicos) a los cuartos o niveles de 79 juegos. Capitulo 30.3 El uso de las vistas en los cuartos o niveles de juego. 80 Capitulo 31 Fuentes. 80 Capitulo 32 Trayectorias o caminos. 80 Capitulo 32.1 Definiendo las trayectorias o caminos. 82 Capitulo 32.2 Asignando trayectorias o caminos a los objetos. 83 Capitulo 32.3 El evento fin de las trayectorias o los caminos 84 Capitulo 32.4 Ejemplo de uso de las trayectorias o caminos. 84 Capitulo 33 Las líneas de tiempo. 85 Capitulo 33.1 Ejemplo de uso de las líneas de tiempo 86 Capitulo 34 Scripts. 88 Capitulo 35 Terminando tu juego en modo avanzado. 89 Capitulo 35.1 Información del juego en modo avanzado. 89 Capitulo 36 Configurando las opciones del juego. 90 Capitulo 36.1 Gráficos. 90 Capitulo 36.2 Resolución. 91 Capitulo 36.3 Otras. 91 Capitulo 36.4 Carga. 92 Capitulo 36.5 Las constantes. 92 Capitulo 36.6 Agregando archivos. 93 Capitulo 36.7 Error. 93 Capitulo 36.8 Información. 94 Capitulo 37 Consideraciones de velocidad. 94 Capitulo 38 El lenguaje de programación del Game Maker. 94 Capitulo 38.1 Un programa. 95 Capitulo 38.2 Explicación de las variables. 95 Capitulo 38.3 Particularidades de las variables en el Game Maker. 95 Capitulo 38.4 Uso de las variables en los juegos (Eje mplo). 97 Capitulo 38.5 Asignaciones. 101 Capitulo 38.6 Expresiones. 102 4
- 5. Capitulo 38.7 Comparaciones. 103 Capitulo 38.8 Más sobre variables extras. 105 Capitulo 38.9 Direccionando variables a otras instancias de objetos. 106 Capitulo 38.10 Ordenes (Arrays). 107 Capitulo 38.11 Sentencia if. 107 Capitulo 38.12 Sentencia repeat. 107 Capitulo 38.13 Sentencia while. 107 Capitulo 38.14 Sentencia do. 108 Capitulo 38.15 Sentencia for. 108 Capitulo 38.16 Sentencia s witch. 108 Capitulo 38.17 Sentencia break. 109 Capitulo 38.18 Sentencia continue. 109 Capitulo 38.19 Sentencia exit. 109 Capitulo 39 Funciones. 109 Capitulo 40 Scripts. 110 Capitulo 41 Construcciones with. 110 Capitulo 42 Comentarios. 111 Capitulo 43 Funciones y variables en el lenguaje del Game Maker. 111 Capitulo 44 Haciendo cálculos. 112 Capitulo 44.1 Constantes. 112 Capitulo 44.2 Funciones basadas en valores reales (números). 112 Capitulo 44.3 Funciones basadas en el mane jo de textos o cadenas 113 (strings). Capitulo 45 Manejando el tiempo y la fecha. 113 Capitulo 46 Jugabilidad. 114 Capitulo 46.1 Movimiento. 114 Capitulo 46.2 Caminos o trayectorias. 116 Capitulo 46.3 Movimientos especificados. 116 Capitulo 46.4 Verificando colisiones. 118 Capitulo 46.5 Instancias de objetos. 118 Capitulo 46.6 Desactivando instancias de objetos. 119 Capitulo 47 Sincronización de tie mpo. 120 Capitulo 48 Variables y funciones para los cuartos o niveles de juego. 120 Capitulo 49 Variables y funciones para la puntuación, la energía, y 121 las vidas. Capitulo 50 Generando eventos. 122 Capitulo 51 Variables y funciones misceláneas. 123 Capitulo 52 Inte racción con el usuario. 124 Capitulo 52.1 Soporte para el jostick. 126 Capitulo 53 Gráficos. 126 Capitulo 53.1 Imágenes. 127 Capitulo 53.2 Fondos. 127 Capitulo 53.3 Dibujando imágenes y fondos. 128 Capitulo 53.4 Dibujando formas. 129 Capitulo 53.5 Fuentes o texto. 130 Capitulo 53.6 Funciones avanzadas de dibujo. 130 Capitulo 53.7 Dibujando superficies. 132 Capitulo 53.8 Tiles. 133 Capitulo 53.9 El monitor. 134 5
- 6. Capitulo 53.10 La ventana de juego. 135 Capitulo 53.11 Vistas. 136 Capitulo 53.12 Transiciones. 136 Capitulo 53.13 Redibujado de la pantalla. 136 Capitulo 54 Sonidos y música avanzados. 137 Capitulo 54.1 Funciones básicas de los sonidos. 137 Capitulo 54.2 Efectos de sonido. 138 Capitulo 54.3 Sonidos en 3d. 140 Capitulo 54.4 CD de música. 140 Capitulo 55 Ventanas emergentes. 141 Capitulo 55.1 Splash screens. 141 Capitulo 55.2 Ventanas de preguntas y mensajes. 141 Capitulo 55.3 Lista de puntuaciones. 142 Capitulo 56 Funciones para obtener información de lo recursos. 142 Capitulo 56.1 Funciones para las imágenes. 143 Capitulo 56.2 Funciones para los sonidos. 143 Capitulo 56.3 Funciones para los fondos. 143 Capitulo 56.4 Funciones para las fuentes. 143 Capitulo 56.5 Funciones para los caminos. 144 Capitulo 56.6 Funciones para los scripts. 144 Capitulo 56.7 Funciones para las líneas de tiempo. 144 Capitulo 56.8 Funciones para los objetos. 144 Capitulo 56.9 Funciones para los cuartos o niveles de juego. 144 Capitulo 57 Funciones para modificar los recursos. 145 Capitulo 57.1 Funciones para modificar las imágenes. 145 Capitulo 57.2 Funciones para modificar los sonidos. 145 Capitulo 57.3 Funciones para modificar los fondos. 145 Capitulo 57.4 Funciones para modificar las fuentes. 146 Capitulo 57.5 Funciones para modificar los caminos. 146 Capitulo 57.6 Funciones para modificar los scripts. 146 Capitulo 57.7 Funciones para modificar las líneas de tiempo. 147 Capitulo 57.8 Funciones para modificar los objetos. 147 Capitulo 57.9 Funciones para modificar los cuartos o niveles de juego. 147 Capitulo 58 Archivos de registro y ejecución de programas. 148 Capitulo 58.1 Archivos. 148 Capitulo 58.2 Registro. 149 Capitulo 58.3 Archivos .INI 150 Capitulo 58.4 Ejecutando programas. 150 Capitulo 59 Estructura de datos. 150 Capitulo 59.1 Stracks. 151 Capitulo 59.2 Filas. 151 Capitulo 59.3 Listas. 151 Capitulo 59.4 Mapas. 152 Capitulo 59.5 Propiedades de las filas. 152 Capitulo 59.6 Celdas. 153 Capitulo 60 Creando partículas. 153 Capitulo 60.1 Efectos simples. 154 Capitulo 60.2 Tipos de partículas. 154 6
- 7. Capitulo 60.3 La forma de las partículas. 155 Capitulo 60.4 Coloreando y me zclando. 155 Capitulo 60.5 Tie mpo de vida y muerte de las partículas. 156 Capitulo 60.6 Sistemas de partículas. 156 Capitulo 60.7 Emisores de partículas. 157 Capitulo 60.8 Atractores de partículas. 158 Capitulo 60.9 Destructores de partículas. 158 Capitulo 60.10 Deflectores de partículas. 159 Capitulo 60.11 Cambiadores de partículas. 159 Capitulo 60.12 Ejemplo de fuegos artificiales con programación del 160 Game Maker. Capitulo 61 Juegos multijugador. 160 Capitulo 61.1 Configurando la conexión. 160 Capitulo 61.2 Creando y uniendo sesiones. 161 Capitulo 61.3 Los jugadores. 162 Capitulo 61.4 Datos compartidos. 162 Capitulo 61.5 Mensajes. 162 Capitulo 62 Usando dll. 163 Capitulo 63 Gráficos en 3d. 164 Capitulo 63.1 Iniciando en 3d. 165 Capitulo 63.2 Fácil dibujado en 3d. 165 Capitulo 63.3 Dibujando polígonos en 3d. 165 Capitulo 63.4 Dibujando formas básicas en 3d. 166 Capitulo 63.5 Proyección en 3d 167 Capitulo 63.6 Trasformación en 3d. 168 Capitulo 63.7 Niebla. 169 Capitulo 63.8 Luz. 169 Capitulo 63.9 Creando modelos. 170 Capitulo 64 Palabras finales. 170 Capitulo 65 Paginas Web útiles. 171 Apéndice A Glosario completo. 172 Apéndice B Descripción de todas las acciones que vienen con el 175 Action Decoder1. Apéndice C Todas las variables, funciones, y constantes del Game 186 Maker. 7
- 8. 1.- El acue rdo de licencia del Game Maker: ESTE ACUERDO EXPRESA LOS T ÉRMINOS Y LAS CONDICIONES EN LOS CUALES T U PUEDES UT ILIZAR ESTE PROGRAMA O SOFTWARE Y LOS ARCHIVOS QUE LO ACOMPAÑAN, CON LOS CUALES EL AUTOR LO EQUIPA O QUE PONE A TU DISPOSICIÓN CON ESTE ACUERDO DE LICENCIA (COLECTIVAMENTE EL SOFTWARE). LEE LOS TÉRMINOS Y LAS CONDICIONES DE ESTE ACUERDO DE LICENCIA CUIDADOSAMENTE ANTES DE INSTALAR O DE USAR EL SOFTWARE. AL INST ALAR, LA COPIA O AL UTILIZAR DE OTRA MANERA EL SOFTWARE, DE T U PARTE Y/O DE PARTE DE SU COMPAÑÍA (COLECTIVAMENTE, "TU") ES QUE ACEPTAS Y QUE CONVIENES A LOS T ÉRMINOS DE ESTE ACUERDO DE LICENCIA. SI T U O SU COMPAÑÍA NO EST Á DISPUEST A A SER LIMITADO POR ESTE ACUERDO, NO INSTALE EST E SOFTWARE. EL DERECHO DE AUTOR Y OT ROS DERECHOS DE CARACT ERÍSTICAS INTELECT UALES PROTEGEN EL SOFTWARE. EST E ACUERDO ES UN ACUERDO DE LICENCIA QUE LE DA LOS DERECHOS LIMITADOS DE UT ILIZAR El SOFT WARE Y NO UN ACUERDO PARA LA VENTA O PARA LA T RANSFERENCIA DEL T ÍTULO. EL AUT OR SE RESERVA T ODAS LOS DERECHOS NO EXPRESOS CONCEDIDOS POR ESTE ACUERDO. 1.1.- CONCESIÓN DE LA LICENCIA En los términos y las condiciones de este acuerdo, el autor le concede una licencia no exclusiva, y no transferible de utilizar el software en una sola computadora. 1.2.- LAS DERECHAS Y RESTRICCIONES DE CARACTER 1.2.1.- La Propiedad. El software y todas las modificaciones o mejoras, o el trabajo derivado basado en el software, ya sea creada por el Autor o usted, y todo el copyright, patentes, secretos comerciales, marcas registradas y otros derechos de características intelectuales o cualquier aspecto del software o cualquier modificación, mejora o trabajo derivado es y seguirá siendo de característica única y exclusiva del autor. Este acuerdo no transporta el titulo o propiedad a usted sino que por el contrario le da solamente los derechos limitados en la sección 1 y 1.1. 1.2.2.- Los Derechos Limitados. A menos que según lo expreso, dispuesto en este acuerdo, usted no tiene ningún derecho de utilizar, o hacer, sub licencias, modificar, transferir o copiar la versión original o cualquier copia del software o permitir que cualquiera otra persona lo haga. 1.2.3.- Avisos Propietarios. Usted no puede quitar, inhabilit ar, modificar, agregar o tratar de forzar con ningún código los datos del programa, el derecho de autor, la marca registrada u otros avisos y leyendas propietarios contenidas dentro del código del objeto (compilado) del software. 1.3.- SIN GARANTÍA. EL AUTOR EST Á PROPORCIONANDO EST E SOFT WARE Y LOS ARCHIVOS QUE LO ACOMPAÑAN "COMO ES". EL AUT OR NIEGA T ODAS LAS GARANTÍAS, CONDICIONES O REPRESENTACIONES (SI EST Á EXPRESADO O IMPLICADO, ORAL O ESCRIT O) CON RESPECT O AL SOFT WARE Y A LOS ARCHIVOS QUE LE ACOMPAÑAN. EL AUT OR NO AUTORIZA QUE EL SOFTWARE FUNCIONARÁ SIN LA INTERRUPCIÓN DE ALGUN ERROR O QUE LIBREMENTE, EL AUTOR CORREGIRÁ TODAS LAS DEFICIENCIAS, ERRORES, DEFECT OS O NO CONFORMIDADES O QUE EL SOFTWARE RESOLVERA SUS REQUISIT OS ESPECIFICOS. 1.4.- LOS JUEGOS CREADOS Los Juegos que usted crea con el software, usted los puede utilizar en cualquier manera que usted tenga a buen criterio. No se requiere ningún impuesto sobre patente. Se permite vender los juegos solamente si usted posee los derechos de todos los recursos usados en el juego (Imágenes, Sonidos, etc.). La responsabilidad y las responsabilidades completas por los juegos creados con el software recaen solamente sobre el creador del juego y no con el autor del software. Las versiones independientes de los juegos creados con el software se pueden distribuir sin ningunos honorarios de licencia. Sin embargo no se permite invertir en el ingenio o descompile de estos ejecutables. 1.5. O TRAS OBSERVACIONES Se apreciara y agradecerá cuando usted menciona que El Game Maker fue utilizado para crear el juego que usted realice, pero esto no se requiere. Esta licencia no se aplica a los sprites, fondos, o los sonidos proporcionados, junto con el programa. Ya que estos no son parte del programa, sino que fueron tomados de las colecciones de libre uso y previstas su conveniencia. Si usted tiene preguntas sobre estos términos, entre en contacto con a autor. En el sitio Web www.gamemaker.nl para los detalles, en los que tenga dudas. 8
- 9. 2.-Requerimientos del sistema e Instalación del Game Maker: 2.1-Requerimientos del sistema: Se recomienda una maquina con procesador Pentium III o superior, Windows 98, 98SE, 2000, M e, o XP, una tarjeta de gráficos con al menos 16 M B de memoria, que es lo que requieren la mayoría de los juegos creados, para juegos muy simples 8 M B son suficientes, una resolución de pantalla de por lo menos 800 X 600 y 16 Bits de color, tener instalado DirectX versión 8 o superior (Puedes descargar la versión más reciente de DirectX en http://www.microsoft.com/Windows/direct/. Cuando diseñas juegos y los pruebas los requerimientos de memoria son algo más elevados (por lo menos 64 M B y preferiblemente más). Cuando solo se corren los juegos el requerimiento es menor y depende mucho del tipo de juego. 2.2-Instalación del Game Maker: Seguramente ya lo hiciste, pero si no aquí se te explica como instalar el Game M aker, es tan fácil como dar un doble clic en el archivo ejecutable gmaker.exe, que ya habrás tenido que descargar de la pagina Web oficial o de algún sitio de descargas, sigue las instrucciones en pantalla, puedes instalarlo donde tu quieras, pero te recomiendo que lo dejes con los parámetros predeterminados. La primera vez que ejecutes el Game M aker te preguntara si quieres correrlo en modo simple o avanzado, si no has usado este programa antes o no tienes conocimientos en programación, usa mejor el modo simple (seleccionando No), en este modo se muestran muy pocas opciones, pero puedes cambiar al modo avanzado después usando la opción en el M enú Archivo (File menu). Junto con el archivo de instalación predeterminado, habrá una serie de carpetas, cada una contiene distintos archivos, así que encontraras las siguientes carpetas: Ejemplos: contiene algunos ejemplos que pueden ser modificados para que vayas practicando. Librerías: contiene un número de acciones, adicionalmente puedes agregar más librerías que descargues desde Internet. Gráficos: contiene una colección de gráficos que puedes usar en tus juegos, son pocos, pero en la página oficial, podrás descargar muchas más, así como en otras páginas de Internet. Fondos: contiene unos pocos gráficos de fondos, puedes conseguir más en Internet o crear los tuyos propios. S onidos: contiene unos cuantos sonidos, puedes conseguir más en Internet o crear los tuyos con un buen programa de sonido. 3.-Un breve glosario: Este es un pequeño Glosario con algunas palabras que son usadas normalmente en este manual y lo pongo aquí para que te vayas familiarizando con el uso de estas palabras, pero no están traducidas. Porque se acostumbra usarlas en ingles, ya que es (para desgracia de algunos, que no conocen bien el ingles) el idioma universal en el mundo de la programación entre otras razones. Sin embargo, para que te vayas familiarizando con ellas es posible que a lo largo de este manual encuentres estas palabras ya traducidas al español; al final de este manual se pondrá como debe de ser un glosario más extenso. Pero recuerda que es altamente recomendable que te acostumbres a nombrarlas y usarlas en inglés. Object: Siempre que en el manual se nombre a object, nos referiremos a los objetos que se agregan dentro del Game Maker en el árbol de recursos de la izquierda. S prite: Con sprite nos referimos a las imágenes fijas o animadas que agregamos en el Game Maker, en el Game Maker se les llama sprites. Depth: Con depth nos referimos a la "profundidad", esta es la profundidad con la que una instancia es dibujada. Por ejemplo, una instancia con 10 de depth, va a ser dibujada detrás o por debajo de una con 5 depth. Porque la que tiene 10 depth posee más profundidad, entonces es dibujada por debajo de la que tiene 5 depth. S ound: Con sounds nos referimos a los sonidos que se pueden agregar al juego, normalmente serán dos los tipos de sonidos que se puedan agregar los .wav y los M idi. Background: Con background nos referimos a las imágenes que son usadas de fondo o telones en los cuartos, o niveles de juego. View: Con views nos referimos a las "vistas" que usa el Game Maker, estas views pueden fijarse en las propiedades de los cuartos, o niveles de juego, no obstante, no es el único método, pero suele ser el más usual. Path: Con path nos referimos a los "caminos o trayectorias" que se usan en el Game Maker, los paths se pueden definir en el árbol de recursos a la izquierda del Game Maker. Sin embargo, hay otros métodos para agregarlos. Room: Con room nos referimos a los cuartos, o niveles de juego, que se pueden definir en el Game Maker, igual que con todos los recursos, esta no es la única forma de agregarlos. 9
- 10. Font: Este es otro recurso que se puede agregar al Game Maker en modo avanzado, las fuentes o tipos de letras, como debes saber, componen un cierto estilo de caracteres, que son usados para la escritura, en las computadoras. Time Lines: Este es otro recurso del Game Maker, su traducción sería "Líneas de tiempo". Alpha: Es un parámetro que se utiliza en las funciones de dibujo avanzadas y que indica el nivel de transparencia de lo que se está dibujando: 0 es totalmente transparente y 1 es totalmente opaco. Los valores intermedios se usan para dibujar elementos parcialmente transparentes. Keycode: Su traducción sería "Código de tecla", el keycode es un número que le corresponde a cada tecla, como los ASCII, pero un poco diferentes. S tring: Su traducción es "Cadena", esto es un tipo de datos, cuando se refiere a string es un dato en forma de texto, entre comillas. S trip: Su traducción se podría definir como “Tira cómica”, no tiene una traducción del todo real, ya que es un concepto usado en diseño grafico. Nota: Esto es solo un breve Glosario, no se pretende dar información en particular sobre esto. Si deseas más información, y no solo su traducción, puedes ir a la sección correspondiente y al final de este manual se agregara un Glosario más completo, esto es únicamente para que te vayas familiarizando con algunos conceptos. 4.-Presentación y Explicación del contenido de este manual. Es te Manual del Game Maker está di vi di do en 7 partes: 1. El acuerdo de Licencia. 2. Requerimientos del sistema e instalación del Game Maker. 3. Registro 4. Usando el Game Maker. 5. Uso Avanzado del Game Maker. 6. Terminando tú juego. 7. El lenguaje del Game Maker. 4.1.- Comenzando a usar el Game Maker: Esta sección describe los conceptos más básicos para el uso del Game M aker, explica la idea global del programa y describe como puedes agregar imágenes estáticas o Gif animados (Sprites), fondos (backgrounds) y sonidos (sounds), así como definir objetos con eventos y acciones, y la forma de cómo los debes agregar en los Cuartos, habitaciones, o niveles de juego (room). Los siguientes capítulos se describen en esta sección: Instalación Registro Introducción La interfase Global La idea global Definiendo los sprites Definiendo los sonidos y música de fondo Definiendo los Fondos Definiendo los objetos Conociendo y definiendo los Eventos Conociendo y definiendo las Acciones Creando los Cuartos, o niveles de juego Un simple ejemplo Distribuyendo tu juego 4.2.- El uso avanzado: Esta sección describe los aspectos más avanzados del Game M aker, trata sobre los Paths, Fuentes, Líneas de tiempo (Time Lines), Scripts, y técnicas para crear tus cuartos, habitaciones, o niveles de juego (Room), por medio de mosaicos (Tiles), y el uso de las vistas (Views). 10
- 11. Los siguientes capítulos se describen en esta sección: Interfase avanzada del usuario Uso avanzado de los sprites Uso avanzado de los sonidos y música de fondo Uso avanzado de los fondos Uso avanzado de los objetos Uso avanzado de las acciones Uso avanzado de los cuartos Uso de las Fuentes Uso del Paths Uso de las Líneas de tiempo Uso de los S cripts 4.3.- Terminando tú jueg o: En esta sección se te describe como convertir tu proyecto en un juego terminado, describe como agregar información sobre tu juego, como fijar las diversas opciones para el juego, y como crear los juegos en auto ejecutables (archivos.exe), que pueden ser usados para distribuirlo a otras personas, sin necesidad de estas cuenten con una versión del Game M aker. Los siguientes capítulos se describen en esta sección: Información del juego Configuración global del juego (Global Game Settings) Consideraciones de velocidad 4.4.- El lenguaje de programación del Game Maker: El Game M aker contiene un lenguaje de programación propio; ese lenguaje de programación da mucho más flexibilidad y control que las opciones estándar, en esta sección se describirá el lenguaje de programación del Game M aker (GM L), y se hará una revisión a las funciones (más de 1,000) y variables para controlar todos los aspectos a la hora de crear tus juegos. Los siguientes capítulos se describen en esta sección: GML en General Computando y calculando las cosas Jugabilidad Interacción con el usuario Graficas del juego S onidos y música de fondo Pantallas de inicio, tablas de record y otros pop u ps (S plash screens, highscores and other pop-ups) Recursos Modificación de recursos Archivos, registro y ejecución de programas Estructuras de datos (Data S tructures) Creación de partículas Juegos multijugador Uso de los dll Graficas en 3D 5.- ¿Qué hay de nuevo en la versión 6.1 del Game Maker? Si ya has usado anteriormente el Game Maker te preguntaras que hay de nuevo: 5.1.- El sistema de efectos de partícul as: Un simple mecanismo de efectos y explosiones ha sido agregado, hay simplemente una acción que puede usar en cualquier evento, de colisión; esto creara un efecto más real de explosiones, humos, fuegos artificiales, lluvia o nieve. Hay 12 tipos diferentes de efectos en 3 tamaños diferentes con color a tu elección. El sistema de partículas ha sido mejorado considerablemente, también marca cierta incompatibilidades con versiones anteriores, el principal cambio es que el sistema de partículas ahora es dibujado y actualizado aut omáticamente, ya no es necesario crea varios objetos para esto; también la acción para crear una partícula ha cambiado. 11
- 12. El sistema de partículas ahora posee una Profundidad (depth) y una posición que indica a que momento deben de ser eliminadas (deth) y en que posición deben ser dibujadas (live). Ahora hay más tipos de partículas, incluyendo anillos, humo, niebla, y explosiones; hay más posibilidades para colores, y pueden tener una orientación modificable. Los efectos anteriores del tamaño, velocidad, y dirección aleatorios han sido modificados, para dar efectos más interesantes. Las posibilidades de las partículas para usar Arrastrar y S oltar (Drag and drop) se han incrementado. 5.2.- El editor de i mágenes: Este editor ya existía en versiones anteriores, pero se le han agregado ciertas mejoras, pero aún sigue siendo muy básico. Una acción para tele transportar instancias sobre la pantalla ha sido agregada. Una acción para crear una instancia en un lugar aleatorio ha sido agregada. Una nueva estructura de datos (data structure) ha sido agregada. La cantidad de alarmas ha sido incrementada a 12, y la cantidad de eventos definidos por el usuario (user-defined event) ha sido incrementado a 16. Fueron agregadas las funciones choose (val1,val2,...) y median(val1,val2,...). Los bloques de acciones en los objetos o líneas de tiempo (time lines) han sido modificados logrando la lectura más rápida. Cuando agregues imágenes a sprites hay más opciones. Se agregaron eventos para la rueda del ratón. Ahora puedes usar números hexadecimales empezando con un $, por ejemplo $0000FF es rojo. Los momentos en las líneas de tiempo (time lines) ahora pueden ser duplicados. Se agrego la función (screen_wait_vsync()), para esperar por una actualización vertical del monitor. Ahora puedes mantener presionado <Shift> mientras eliges azulejos / mosaicos (tiles) para elegir múltiples azulejos / mosaicos (tiles) o mantener presionado <Ctrl> para elegir múltiples tamaños de las celdas. 6.- Registro del Game Maker: El precio del registro para el Game M aker 6.1 es de entre 15 y 20 euros, este puede ser por medio de tarjeta de crédito vía Internet, o una cuenta paypal, o por transferencia a la cuenta bancaria, enviando una orden de pago, los detalles se encuentran en Internet. En la pagina http://www.gamemaker.nl/registration.html 7.- Algunas preguntas que te puedes estar haciendo: Antes de continuar quizás te estés haciendo las siguientes preguntas. 7.1- ¿Para qué sirve crear un vi deojuego? : Es una buena pregunta para plantearse ya que existen muchas otras áreas de la informática que pueden ser, a primera vista, más útiles, más prácticas o más requeridas que la programación de un jueguito. Creemos firmemente que la lógica necesaria para desarrollar un juego (sin diminutivos a partir de ahora) permite incorporar elementos muy positivos a la enseñanza de la programación en computación; si a esto le agregamos que se incluyen conceptos avanzados de programación y un alto grado de interés por parte de los alumnos (o interesados) nos daremos cuenta que el proceso de crear un juego tiene un enorme interés desde el punto de vista pedagógico en el área de la informática. En un juego encontramos un conjunto de componentes que deben ser integrados de acuerdo a una metodología muy específica para que el resultado sea el deseado: no podemos elegir el color de una habitación, sin antes haber diseñado y construido la casa. Además toda la secuencia del armado puede ser estudiada mediante un análisis lógico y riguroso que nos permitirá entender mejor los conceptos de programación que queremos aprender. 7.2.- ¿Qué es un vi deojuego?: Un videojuego (o juego de computadora como es nuestro caso) es un programa (software) en el cual uno o dos jugadores como máximo en el Game M aker toman decisiones mediante el control de objetos (un auto, un avión, un personaje) en busca de conseguir un objetivo, que puede ser casi cualquier cosa: desde destruir al invasor hasta rescatar a la princesa, pasando p or pintar un área de la pantalla en cierto tiempo, etc. etc. 7.3.- ¿Por qué usar el Game Maker?: Jugar juegos de computadora es divertido, pero es más divertido si tú los creas, y los distribuyes. Después de haber leído el primer punto es probable que enseguida empecemos a pensar en crear la nueva versión del A ge of Empires o 12
- 13. de los Sims, pero, créanos, no es tan fácil: realizar un juego de calidad necesita de un grupo de programadores, artistas, ingenieros y animadores de gráficos, en muchos casos, más de cincuenta personas que trabajan durante un año y medio o dos años para lograr esos estupendos juegos que hemos nombrado más arriba. Estos juegos son creados usando lenguajes de programación como el Visual C++, Assembler o Delphi, que requieren de un gran conocimiento y de mucha experiencia; si tuviésemos que utilizar uno de dichos lenguajes sería desde todo punto de vista imposible pretender crear uno en apenas unas horas o días de trabajo. ¿Así que esto significa que es imposible crear tus juegos para computadora? Afortunadamente no, pero no esperes crear grandes juegos al inicio tal y como se dijo arriba del tipo Age of Empires, o Quake; aún que esto realmente no es necesario, ya que los juegos simples (los llamados clásicos), del tipo Pac-man, Tetris, Invasores del Espacio, M ario Bross etc. Son también buenos juegos y más fáciles de crear y usar, aún así requieren buenas habilidades, en programación, preparación de gráficos, sonidos, interacción con el usuario, etc. Por suerte para nosotros existe el Game M aker, un estupendo programa que oculta todo el trabajo engorroso de programación y nos deja la parte divertida que es la creación y definición de situaciones, personajes, reacciones, etc. El Game M aker, un programa creado por M ark Overmars, para hacer aún más fácil la creación de juegos, no hay gran necesidad en programar, gracias a una intuitiva y fácil interfase que usa la función de arrastrar y soltar (Drag and Drop), que te permite crear tus juegos más rápidamente. Puedes importar y crear imágenes estáticas o animadas, sonidos, fondos, etc. Puedes definir fácilmente los objetos en tu juego e indicar después como se comportaran, también puedes definir los cuartos con fondos estáticos o con movimiento. Y si quieres tener más control puedes usar el lenguaje de programación del Game M aker (GM L), obviamente lo mejor es ir avanzando poco a poco, es como dice un viejo refrán. Antes de correr tienes que aprender a caminar. 7.4.- ¿Qué ti po de juegos puedo crear con el Game Maker?: Por supuesto que con el Game M aker, no podremos desarrollar juegos de calidad profesional al estándar de hoy día, pero sin duda pueden ser juegos muy divertidos, y jugables (¡y que pudieron haberse vendido hace unos diez años o más!). El Game M aker no impone ningún tipo de limitación en el género de juegos que se pueden crear con él; a lo largo del tutorial crearemos juegos del tipo arcadia (de los de matar naves, marcianitos o lo que sea), de laberintos y de plataformas. Debido a la complejidad que puede llegar a alcanzar dejaremos de lado los juegos en 3D, y los juegos multiusuario, pero si se darán algunos ejemplos. (Además de que se precisa una licencia especial para poder crear estos últimos o sea registrar el producto). Somos conscientes de que esto quizás sea menos atractivo pero hay que tener siempre presente la idea de que es mejor ir avanzando de a poco a poco y ponerse metas que uno realmente pueda alcanzar, pues sino la desilus ión será muy frustrante. Básicamente el Game M aker se concentra en crear juegos de 2 dimensiones, pero eso no significa que no puedas crear mundos en 3D, aún que solamente tenga una funcionalidad limitada para los gráficos 3D; solo piensa que grandes juegos como Age of Empires usa tecnología de 2D, y que tú puedes hacer uno de este estilo con el Game M aker. Una vez que estudies este manual, y entiendas los conceptos y su funcionamiento. El Game M aker tiene 2 versiones, una gratuita y limitada, y la otra de registro con todas las funciones activas, La versión gratuita puede ser usada sin ningún cargo, y puedes distribuir los juegos que crees con esta versión, incluso venderlos (ver los términos de acuerdo de licencia que se encuentran al inició para más información). Es altamente recomendable que registres tu copia de Game M aker, ya que con este paso eliminaras el logo que aparece cuando se cargan los juegos, y ayudaras a dar soporte al desarrollo de nuevas versiones del Game M aker, con lo que se podrá conseguir crear mejores juegos. En este documento se te trata de informar sobre todo lo que puedes hacer con el Game M aker, así de cómo crear tus propios juegos, recuerda que aún así no es fácil crear grandes juegos para computadora al inicio, empieza con los ejemplos fáciles que te darán una idea de lo divertido y fácil que puede ser el crear tus juegos. Visita el sitio oficial http://www.gamemaker.nl/ para descargar el programa, y muchos ejemplos con los que puedes ir estudiando y modificando, tutoriales, ideas, y desde donde podrás visitar sitios y foros como el de la comunidad Game M aker, http://comunidadgm.org/ en donde podrás conseguir recursos y ayuda si te inscribes en ellos créeme suelen ser de gran ayuda aún para los ya experimentados (al final se te darán algunas direcciones de Internet que te pueden ser útiles, de donde podrás descargar, imágenes, sonidos, ejemplos, etc.). 7.5.- ¿Qué se considera un buen juego? Cuando Atari produjo su primer juego de consola en los años 70 no fue demasiado popular. Esto cambio drásticamente cuando el juego S pace Invaders fue creado y con el la consola de Atari. En un corto intervalo de tiempo, Atari vendió una descomunal cantidad de consolas y de su juego, lo mismo ocurrió con la creación del Pac-man. Y por ejemplo, para Nintendo los que marcaron la diferencia fueron Tetris, y Mario Bross sus ganadores absolutos, sin duda. ¿Qué tienen estos juegos que los hacen tan especiales? Que ellos marcan la diferencia entre el triunfo y el fracaso, independientemente 13
- 14. de los dispositivos para los que fueron programados. Lo mismo ocurre exactamente con los juegos de ordenador, algunos de los juegos programados se hacían extremadamente populares, haciendo de forma inmediata a sus creadores millonarios, con miles de copias vendidas, mientras que otros juegos eran monumentales fracasos y a sus creadores no les quedaba otra cosa que lamentarse. Esto conlleva que haya infinidad de juegos que nunca verán la luz, debido a que son cancelados en mitad de su programación por que se les augura un completo fracaso. 7.6.-¿Que hace que un juego no teng a aceptación entre los usuarios y fracase? Esta es una pregunta muy complicada de contestar, ya que cientos de programadores se la han hecho en algún momento de su vida sin obtener una respuesta satisfactoria, esta pregunta abarca gran cantidad de aspectos que intentaremos contestar en este tutorial de la mejor manera posible. 8.-Un juego de ordenador es un programa: Esto lo hace muy diferente de los juegos de mesa o de los deportes. No hay piezas que mover y no hay una interacción física directa. Los aspectos sociales que se pueden experimentar con cualquier otro tipo de juego desaparecen parcialmente con un juego de ordenador. Pero veámoslo más detenidamente. Un programa de software puede reaccionar mucho mejor y adaptarse a los jugadores. La mayoría de los juegos de ordenador tienen un elemento de tiempo real que no esta presente en los juegos de mesa. El juego continúa aunque los jugadores no hagan nada. Esto puede aumentar la emoción y dar un mayor sentimiento de presencia en el juego. Los juegos de ordenador también pueden adaptarse a los usuarios, haciéndolos satisfactorios para una gran variedad de jugadores, tanto principiantes como jugadores avanzados, sin ningún tipo de distinción. La posibilidad de tener oponentes controlados por el ordenador, añade nuevos desafíos al juego. Los juegos de ordenador pueden ser más complejos porque el propio juego puede ayudar a los jugadores a comprender la mecánica del juego y a enseñarles como jugar. Finalmente, los juegos de ordenador también pueden crear un mayor ambiente de juego envolviendo al jugador con bonitos gráficos, melodías y secuencias de video. 8.1.-Un juego de ordenador debe i mplica a los jugadores: Esto es algo obvio. Un juego de ordenador no solo es algo para mirar. Deberás implicarte en el juego y en las decisiones que este te hace que tomes. Aunque quiero hacer hincapié en la importancia del jugador, los programadores de juegos profesionales y principiantes, olvidan muy a menudo que debes hacer el juego, no para ellos, sino para la gente que va a jugarlo, así que siempre debes pensar en quienes serán los jugadores y tomar en cuenta sus opiniones y sugerencias. Un juego para niños será algo diferente de un juego para adultos y un juego para jugadores experimentados será diferente de un juego para jugadores con menos experiencia. Necesitas atraer a la audiencia correcta. Los juegos malos están escritos a menudo para la audiencia equivocada. Por ejemplo, un jugador con gran experiencia en simuladores de vuelo quiere ser capaz de controlar todos los aspectos del avión y quiere que las cosas sean lo mas realistas posibles pero para un jugador que solo quiere divertirse con un poco de vuelo rápido, resulta frustrante y aburrido tantas opciones para p oner en funcionamiento el avión, lo más normal es que no consiga levantar el vuelo y no hablemos de llegar a aterrizar el aparato en tierra firme. Siempre que necesites dirigir al usuario, trata de hacerlo del modo más natural posible sin que se note que l a explicación esta demasiado forzada. 8.2.-Los objetos y recursos del jueg o: En un juego normalmente controlas cierto tipo de objetos, como el personaje principal, diferentes unidades, un coche, etc. En algunos juegos solo puedes controlar un objeto, mientras que en otros, como los juegos de estrategia, puedes controlar muchos objetos diferentes. Tras los objetos que el jugador controla, hay normalmente muchos otros objetos que juegan determinado papel en el juego. Esta es una importante cualidad. En otros juegos tú también controlas ciertos objetos, como botones, pero estos no juegan un papel en el juego. Solo envían determinados comandos al programa. Además, controlando los objetos del juego, puedes controlar a menudo ciertos recursos. Esto se hace más evidente en los juegos de estrategia y simulación en los que debes controlar la comida, madera, piedra, oro, etc. Pero también en muchos otros juegos, hay recursos que controlar, como munición para tus armas, un escudo que puede ser utilizado durante un tiempo limitado, etc. La planificación cuidadosa de los recursos y su uso pueden añadir mucho atractivo a la jugabilidad. El diseñador del juego debe balancear la disponibilidad del recurso con su necesidad de hacer el juego interesante. 8.3.-Un juego necesita una meta: Este es el ingrediente crucial en un juego. La gente quiere ganar una partida y además debe haber una meta que alcanzar. Para juegos largos, también debe de haber objetivos secundarios, como terminar un nivel en particular, derrotar a cierto enemigo, o adquirir una nueva habilidad. Alcanzar una meta o un objetivo secundario debe dar lugar a una recompensa, dicha recompensa puede consistir en una puntuación extra o alguna bonita secuencia de video, pero lo mejor es si la recompensa es parte del juego en si misma. Por ejemplo, una nueva arma, alguna 14
- 15. información útil adicional, etc. Hablaremos más sobre objetivos y recompensas mas adelante. Ya sabemos lo que es un juego de ordenador, pero esto no dice mucho de cuando un juego es bueno. Piensa en la siguiente historia de un juego: Tienes que rescatar a la princesa que esta atrapada en una fortaleza, en la pantalla se muestran dos caminos, uno se dirige a la fortaleza y el otro a una cueva. Tienes que elegir que camino escoger. Si eliges el de la fortaleza, enhorabuena, rescataste a la princesa y ganaste el juego, si elegiste la otra opción, has muerto, y no has conseguido el objetivo. Si lo compruebas, este juego tiene todos los ingredientes descritos arriba. Hay un jugador, hay una decisión que tomar, el jugador controla lo que sucede, hay objetos en el juego (el príncipe, el monstruo de la cueva, etc.) y hay un objetivo claro. Pero obviamente es un juego bastante aburrido, no hay un desafío. El juego es demasiado fácil, claramente tenemos que hacer un mejor trabajo para convertirlo un juego interesante. 8.4-Alcanzando metas: La parte mas importante de un juego es esa donde hay una meta y el juego desafía al jugador a jugar y alcanzarla. Actualmente, a menudo hay muchos objetivos secundarios diferentes. Las metas son de todo tipo. Una meta puede ser intentar derribar a un avión enemigo o finalizar un nivel recogiendo todos los diamantes, o alcanzar la mayor puntuación o finalizando el juego. Claramente algunas de estas metas son de pronta finalización, mientras que otras son de larga duración que solo pueden ser alcanzadas jugando el juego durante semanas, lo que hace al juego más interesante. Un buen juego esta repleto de estas metas y el jugador debe ser recompensado cuando alcanza alguna de estos objetivos (que además son divertidas de alcanzar). Los objetivos no deben de ser demasiado fáciles de alcanzar. Debe haber un desafió. Cuando el juego progresa los objetivos deben hacerse más duros de alcanzar y el jugador debe hacerse más experimentado en el juego para alcanzarlos. Esta curva de aprendizaje es muy importante. Al principio el jugador necesita comprender los controles y mecanismos del juego. Esto se hace mejor alcanzando algunas metas sencillas. M as adelante, el jugador comprende mejor el juego y estará preparado para un mayor desafió. Obviamente, cuando los objetivos son difíciles de alcanzar, hay una gran posibilidad de fallo. Sin embargo debes ser cuidadoso con esta posibilidad. Es fácil desconectar al jugador, haciéndole dejar el juego debido a que se siente frustrado. Definitivamente eso no es lo que queremos que ocurra. Para evitar esto es crucial que, en el caso de fallo, el jugador siempre tenga el sentimiento de que cometió un error que podría haber evitado. Esto no debe ser un fallo del juego que ocasione que el jugador pierda, sino el mismo. Este es uno de los aspectos que distinguen a juegos como Pac-Man y Tetris de otros juegos. Tú siempre tienes el sentimiento de que hiciste algo erróneo. Tú puedes enfadarte contigo mismo cuando te va mal y determinas evitar ese error en la próxima ocasión. Este sentimiento te hace permanecer jugando el juego. Por otro lado, considera un juego de Laberintos en el que de cuando en cuando a intervalos aleatorios, un relámpago aparezca en cualquier punto, matándote si estas en los alrededores. En este juego tú, como jugador, no hiciste nada malo, tuviste la mala suerte de estar en el lugar equivocado. Esto es muy frustrante. No estas enfadado contigo mismo, sino con el juego. Probablemente dejes pronto de jugarlo. No pienses que los juegos comerciales son perfectos en este aspecto. Muchos juegos crean enemigos aleatorios, y si tienes mala suerte aparecen en el momento mas inadecuado y te matan, sin posibilidad de salvarte. Espero que hayas aprendido de esto, y que debes de ser cuidadoso con la “suerte” en tus juegos. Si el jugador puede alcanzar una meta no debe depender de la suerte, ni de la buena, aunque pienses que pueda resultar menos frustrante, debe depender de su habilidad y ser él, el único responsable de sus errores. Imagina que tienes la buena suerte de que encuentras una superbomba, un arma muy poderosa dentro del juego, justo antes de enfrentarte al enemigo final, poseyendo la superbomba, la lucha se hace muy sencilla, no siendo un gran desafío. Habiendo conseguido la superbomba normalmente no dará demasiada satisfacción al jugador acabar con el monstruo. Hubiera sido mucho mejor si la superbomba estuviera siempre allí, pero que el jugador tuviera que hacer un movimiento difícil para alcanzarla, como saltar un peligroso agujero por ejemplo donde corre peligro de morir en el juego. Ahora el jugador tiene una interesante decisión: desarrollar el peligroso salto para hacer la lucha más sencilla, o no arries garse a la caída y enfrentarse al monstruo con menos armas, lo que hace al jugador decidir. 8.5.-Tomando decisiones: Como vimos arriba, crear una decisión interesante, aumenta la jugabilidad considerablemente. En general, las decisiones son un elemento crucial en los juegos. Cuanto mas interesante sean las decisiones, mas interesante será el juego. Puede haber decisiones de bajo nivel muy simples o muy complicadas decisiones estratégicas. Veamos el archí conocido juego de Pac-Man, esta rodeado de decisiones. La mas importante decisión que debes de tomar constantemente es la de en que dirección moverte. El jugador trata de estar lo más lejos posible de los monstruos, o va detrás de los puntos que debe ir recogiendo, aunque los monstruos permanezcan cerca de él. O ira a una esquina, donde puedes ser alcanzado, o al centro, donde puedes moverte a más direcciones, pero es atacado por varios sitios a la vez. El segundo tipo de decisiones reside en las píldoras que puede comer que le dan la posibilidad de comerse a los monstruos. ¿Como va a usarlas? ¿Las dejara para el final y solo la utilizara para coger los últimos puntos o la comerá pronto para comer la mayoría de los puntos del laberinto?. Una vez que se las comas, ¿Va a cazar los enemigos para conseguir puntos extra o va a usar el tiempo 15
- 16. de seguridad que le dan para comer más puntos y acabar el nivel?. Por ultimo, está el bonus que aparece de cuando en cuando, puede intentar comerlo para conseguir una puntuación extra, pero corre el peligro de ser atrapado por un monstruo al ir por el bonus. Como una recompensa debe estar relacionada con el logro que se consiguió, un castigo debe estar ajustado a la seriedad del error. Si el jugador pierde, debe ser porque ha cometido un grave error o una serie de otros más pequeños. En ese caso el jugador definitivamente sentirá que el mismo es el culpable de perder, y continuara jugando para intentar hacerlo mejor. 8.6-El equilibri o del juego: En un buen juego, tiene diferentes aspectos que están balanceados. Por ejemplo, el jugador debe tener las armas con las que combatir a los enemigos, las armas no deben de ser demasiado poderosas porque harán el juego demasiado fácil, pero tampoco deben ser demasiado débiles porque entonces el jugador solo podría sobrevivir gracias a la suerte y no ha su habilidad. El equilibrio es difícil de alcanzar y los jugadores son muy hábiles buscando el punto donde el juego no esta equilibrado y pueden explotar este desequilibrio, arruinando a veces la diversión del juego y su dinámica. Se puede hablar de muchos puntos a tener en cuenta acerca del equilibrio de un juego. Hay actualmente tres aspectos de equilibrio que son muy diferentes entre si: Equilibrio entre los jugadores. Equilibrio entre el jugador y el juego. Equilibrio entre los diferentes elementos del juego. 8.6.1- Equilibrio entre los jugadores: Si tú creas un juego de dos jugadores, normalmente el mejor jugador gana la partida, y no el más afortunado. Imagina una estrategia en la que los dos jugadores compitan entre si, en la mayoría de los juegos de estrategia tien es que construir una ciudad y para esto necesitas madera que debes talar de los bosques de las cercanías, ahora imagina que solo hay un bosque en el planeta y un jugador comienza la partida muy cerca del bosque y el otro muy lejos. Esto da ventaja al primer jugador que ganara el juego, debido a su cercanía en relación al bosque con el otro jugador. Así que el juego esta muy desequilibrado, y quien gana no es el mejor si no el que tenga la fortuna de aparecer cerca del bosque. Un juego de ajedrez por ejemplo, es muy equilibrado (por no decir que es el juego mas equilibrado de todos los existentes). Cada jugador tiene las mismas piezas y pueden hacer los mismos movimientos. El único problema es que hay un jugador que empieza primero y esto es, actualmente es una gran ventaja en el ajedrez. Pero esto es equilibrado porque cada jugador puede empezar el mismo numero de veces y a la larga el juego se rige por la astucia e inteligencia de los jugadores y no por quien haya realizado la primera jugada. El ajedrez es un juego simétrico, los juegos simétricos son muy equilibrados. Pero la simetría es también un poco aburrida. Imagina que en un juego de estrategia el mundo aparece completamente simétrico y cada jugador juega la misma carrera con las mismas cosas, por lo tanto es imposible que haya un ganador. Esto haría al juego menos atrayente. Esto es usado muchas veces, por ejemplo, los mapas multijugador en Red Alert II son muy simétricos. Una manera de alcanzar falsas simetrías es usando falsas simetrías, me explico exponiendo un ejemplo: En nuestro juego de estrategia nosotros permitimos al primer jugador empezar detrás de la montaña mientras que el segundo jugador tiene su ciudad al lado de un río. El primer jugador le damos la posibilidad de crear barcos mientras que el segundo jugador puede crear helicópteros. Esto parece muy asimétrico, pero los helicópteros pueden pasar la montaña y de igual manera los barcos pueden cruzar el río. Así que el equilibrio se iguala, muchos juegos de estrategia usan este tipo de falsa simetría, los movimientos podrían parecer diferentes pero al final las posibilidades son las mismas . 8.6.2- Equilibrio entre el jugador y el juego: El juego esta aquí para ayudar y divertir al jugador, no para pelearse con él. Como dije antes, el jugador debe perder porque él es quien comete el error, no porque olvido la tecla de disparar o la de saltar, los diseños en la interacción con el usuario (el uso del teclado, ratón, joystick...) son importantes y debe estar muy especificado para evitar este tipo de problemas. También necesitas infundir un buen equilibrio entre lo que el jugador pueda hacer y lo que el juego puede hacer por el jugador. Por ejemplo, en la mayoría de los juegos, el jugador no necesita seguir pulsando los botones para hacer que en el juego el personaje ande o siga un camino concreto. El juego lo hace automáticamente por él, pero el jugador debe presionar un botón para hacer que el personaje dispare o ejecute alguna acción de vital importancia. En la mayoría de los juegos de estrategia, los soldados automáticamente empiezan a atacar enemigos que vienen en masa y permite al jugador constantemente chequear todas las unidades sin tener que preocuparse por que estas peleen de manera automática. Pero el jugador debe decidir cuando empezar la invasión en territorio forastero, pero como bien sabemos los juegos hacen decisiones erróneas, llegado este punto, por ejemplo, ellos fuerzan al jugador a traer comida constantemente para las tropas o ellos fuerzan retirar soldados heridos de la batalla. Por ejemplo, una de las 16
- 17. cosas que la mayoría de la gente comprendió acerca de Black and White era que, cuando tu gente esta rezando tu tenias que llevarle comida todo el tiempo. Doy otro ejemplo, en los primeros juegos de aventuras, uno de los mayores problemas era encontrar donde tu debías dar clic en el dibujo para obtener ciertas cosas, por ejemplo, para abrir una puerta tu tenias que encontrar el botón secreto que presionar, solo después de la interminable tarea de presionar las 100 piedras de la pared, encontrabas la acertada que permitía abrir la puerta, sobra decir que esto no es nada divertido para el juego. En los juegos modernos de aventuras, el cursor del ratón cambia cuando tú lo mueves sobre el sitio donde tú puedes dar clic y un mensaje normalmente aparece indicando que hay que dar clic. Las muestras visuales son normalmente dadas, por ejemplo, dotando a una de las piedras de un color muy diferente a las del resto. Esto mejorara mucho el juego. En síntesis, es el jugador el que debe gastar su tiempo y energía en decisiones importantes del juego, y el juego debe hacer el resto. El juego debe hacer entender al jugador que debe tomar parte en las decisiones cruciales del juego. 8.6.3- Equilibrio entre los diferentes elementos del juego: Un juego contiene muchos y distintos elementos: diferentes armas, diferentes enemigos, diferentes unidades, diferentes caminos... todos son accesorios que pueden ser usados por el jugador. Estos elementos se usan en las decisiones del juego: que arma usar para cada enemigo, que camino tomar, como usar los accesorio o en que orden... Esto hace al juego muy interesante. Pero lo mejor es hacer que las decisiones sean más reales. Por ejemplo, en los elementos del juego tienes cuatro tipos de armas, pero una es superior a las otras, es más poderosa, por lo tanto el jugador nunca usara las otras tres armas una vez que posea la mejor. Así que no hay mas decisiones que tomar, para procurar a tu juego decisiones interesantes, tu debes equilibrar los aspectos buenos del juego con los malos, mantener una regularidad. Por ejemplo, el arma mas poderosa solo puede dispararse una vez por segundo, o la munición es mas cara que las demás, o solo la podrá usar por algún tiempo, o no puede ser usada en una cueva por algún motivo, o un oponente es mas sensible a un arma que a otra... También tú tienes que equilibrar las fuerzas del jugador con las del oponente. Cuando nuevos oponentes aparecen en el transcurso del juego, tú debes dar al jugador nuevos poderes o habilidades para pelear con ellos de forma igualada, pero ten cuidado de guardar un equilibrio entre oponente y jugador. Esto no hace de todo al juego más interesante. No hay diferencia entre conducir un coche lento contra coches lentos o un coche rápido contra coches rápidos (por supuesto, conducir el coche mas rápido es más difícil). La cuestión aquí es que el jugador debe mejorar durante el juego, no el personaje con el que juega, es el jugador el que debe mejorar su habilidad en el transcurso del juego. No olvides que el jugador debe aprender a jugar el juego. Eso es, el juego debe comenzar sencillo con respuestas sencillas por parte del jugador. Cuando el juego progresa y el jugador se vuelve mejor, debería enfrentarse a más y más decisiones complicadas. Esto puede lograrse introduciendo nuevas características gradualmente durante el juego, estas características deben ser igualadas a la habilidad del jugador, que se supone debe tener llegado a este punto. M uchísimos juegos muestran todas las características que posee el jugador en los primeros niveles, un gran error y muy típico, incluso en juegos comerciales. Lo que hace que los niveles cobren una monotonía de movimientos que aburren al jugador. Los buenos juegos siguen dando sorpresas hasta el final. 8.7- Las recompensas: Necesitas recompensar al jugador cuando este alcanza una meta. Un premio puede venir en forma de un puntaje particular, algún gráfico o alguna música bonita, o ítems que pueden ser utilizados en el juego, por ejemplo, mejores armas, power-ups, hechizos, conocimientos sobre el mundo del juego u otra información de utilidad. La durabilidad de la recompensa puede ser permanente o temporal. Los premios temporales son típicamente suministrados cuando el jugador logra una meta menor, esto facilita la jugabilidad por un rato. Ejemplos de este tipo de premio son, balas extra o ser temporalmente invisible a los oponentes o ser invulnerable durante un pequeño laxo de tiempo. Los premios permanentes son dados cuando son alcanzadas aquellas metas mas difíciles de alcanzar en el juego, por ejemplo, conseguir una nueva arma, o un hechizo, o un vehiculo. Este premio va a cambiar la jugabilidad desde ese momento, preferentemente extendiendo el rango de decisiones que el jugador puede tomar. Darle al jugador el tipo correcto de premio es un tema más difícil de lo que puedas pensar. La gente es selectiva con respecto a sus premios, si los premios son muy pequeños no van trabajar lo suficiente para conseguirlos, si son muy grandes, se vuelven codiciosos y desean premios más grandes. Es un fenómeno psicológicamente comprobado que los jugadores comienzan esperando premios y si durante el juego decides que un tipo particular de premio no esta más, ellos se enojaran. Déjame darte un ejemplo de esto, si en el primer nivel del juego le das al jugador un poco de vida extra por cada oponente que mata, el jugador espera eso, si decides que en el segundo nivel el jugador debería estar más experimentado y paras de dar este premio, el jugador tiende a enojarse y podría parar de jugar al juego, puesto que esperaba que en el siguiente nivel se le diese el mismo premio. También debes decidir si los premios deben ser predecibles o al azar. Por ejemplo, en tu juego quis ieras dar un ítem de bonus, cada que elimines a 50 enemigos, en otra alternativa, das un ítem de bonus que aparece al azar, de forma aleatoria. El efecto de estas dos opciones en el jugador son completamente diferentes, en la primera situación al principio el jugador no esta muy interesado en matar ponentes, va a tardar mucho hasta que esto resulte en bonus. Lo que hará al juego menos intenso por lo que deben haber otros aspectos que mantengan al jugador interesado, como explorar el ambiente, pero cuando el numero de muertes se aproxima a 50 la jugabilidad se volverá más intensa y el jugador trabajará más duro en matar oponentes, entonces hay una alta variación en la intensidad del desarrollo del juego, lo que logra más interés en cierto tipo de jugadores. Cuando el premio va ligado al azar hay siempre un interés en intentar mat ar oponentes ya que esto puede llevar a un 17
- 18. premio en alguno de los que elimines. Entonces la intensidad media del juego será mucho mayor, pero no habrá variaciones de intensidad, lo que puede llevar al juego a una monotonía que aburra al jugador. Lo mejor es mantener un equilibrio entre ambos tipos de recompensa. Si el jugador no sabe la relación entre su acción y la recompensa, esto produce una frustración al jugador. Indica tan claramente como puedas como se consiguen los bonus y los premios, para que el jugador pueda entender el por que de su recompensa. 8.8- La inmersión del jugador en el juego. La cuestión clave aquí es la inmersión del jugador en el juego. El juego se realza en gran parte si el jugador se siente inmerso en el juego, si él se siente que está presente en el mundo del juego y que importan sus decisiones y acciones realmente, si él se une emocionalmente a los personajes principales del juego y realmente desea ayudarles, es entonces cuando se hace notar la importancia de la inmersión por parte del jugador en el juego. Los ingredientes importantes para alcanzar esta inmersión son la historia detrás del juego, un buen guión, los alrededores en los cuales el juego ocurre, unos escenarios ricos y variados, la personalidad variada y atraye nte de los personajes, el buen uso de las canciones o música en el juego etc., etc... 9.- Los distintos Géneros de Juegos. Existen infinidad de géneros de juegos, al igual que existen muchísimos géneros de películas de cine. Con el paso del tiempo, estos géneros han ido aumentando, y aquí te listo los más comunes. Juegos de arcade: La velocidad de reacción es el aspecto más apreciable de este tipo de juegos. Ejemplos típicos son los de disparo, algunos juegos de laberintos como el Pac-man, juegos estilo breakout, etc. Estos juegos son relativamente sencillos de hacer y normalmente los gráficos en dos dimensiones son suficientes para ellos. En definitiva, son los primeros juegos por los que debería comenzar un novato. Un tipo particular de juegos de arcade son los pimballs, aunque éstos son un poco más complicados de crear ya que necesitan un movimiento natural de la pelota. Juegos de aventuras: El aspecto más importante es la historia. La mayoría de este tipo de juegos son en su mayor parte en dos dimensiones y usan la muy conocida interfase de apunta y da clic. Su dificultad de desarrollo no recae sobre las acciones sino en crear una interesante, divertida y sorprendente historia. La imaginación juega un papel muy importante en los juegos de aventuras. Juegos de ingenio: Pensar astutamente es el aspecto más importante. M uchos juegos de laberintos están más basados en resolución de problemas que en velocidad de reacción. Otros ejemplos incluyen juegos de tablero y de deslizar objetos. Est os juegos son también creados normalmente en dos dimensiones y son relativamente sencillos de hacer, al menos que el juego deba ser jugado contra la computadora, en cuyo caso puede ser difícil de programar la forma en que la computadora juega, la llamada IA (inteligencia artificial). Juegos de rol (RPG): Consisten en manejar un personaje a través de un mundo complejo. Los ejemplos típicos son Diablo y Baldur´s Gate. El aspecto más importante de tales juegos es el desarrollo del personaje que el jugador controla aprendiendo nuevas habilidades, volviéndose más fuerte y consiguiendo mejores armas. Al mismo tiempo los oponentes se vuelven más poderosos. Estos juegos son a menudo isométricos, es decir, que tienen una mirada fija del mundo, pero este no es un aspecto crucial. También se pueden crear RPGs de dos o tres dimensiones, aunque este tipo de juegos son más difíciles de desarrollar, ya que se debe crear el mecanismo de desarrollo del personaje. Un buen diseño de niveles es crucial en este tipo de juegos. Juegos de estrategia: Pueden ser en tiempo real o en turnos. Aquí el jugador solo controla los personajes indirectamente pero arma estrategias que el personaje debe seguir. Los ejemplos incluyen Age of Empires, Caesar, Theme Park y otros juegos de construcción de ciudades o imperios. Los juegos de estrategia usan casi siempre la vista isométrica. Toman mucho tiempo ya que requieren muchos diferentes 18
- 19. objetos de juego, como personajes o edificios, y todos necesitan sus propias imágenes animadas y un comportamiento específico. Juegos de disparos en primera persona: Este tipo de juegos pueden ser vistos como la versión tridimensional de los viejos juegos de arcadea. Aquí el énfasis esta en la acción rápida y rítmica, no en inteligentes resoluciones de problemas. Ejemplos famosos son obviamente Doom y Quake. Este tipo de juegos necesitan un mundo tridimensional para crear la sensación de que se está jugando en la realidad. Juegos de disparos en tercera persona: El jugador controla directamente un personaje a través de un mundo hostil. Un ejemplo claro es Tomb Raider. La principal diferencia con los juegos de rol es que no hay mucho énfasis en el desarrollo del personaje. Es más un tema de acción rápida y de descubrimiento del mundo del juego. M uchos juegos de disparos en tercera persona también tienen una historia y toman prestados aspectos de juegos de aventuras. Los juegos de disparos en tercera persona no necesitan ser de tres dimensiones (por ejemplo en GTA) y pueden ser creados con relativa facilidad. Juegos de deportes: Consisten en jugar a un deporte simulado. Existen muchos de estos juegos pero son frecuentemente algo aburridos. Crear un convincente y divertido juego de este tipo es un auténtico reto. Juegos de carreras: S on en cierto sentido un tipo especial de juegos de deportes. Ya que muchos merecen tener una categoría propia. Algunos juegos de carreras, como por ejemplo muchos juegos de formula-1, tratan de imitar la conducción de un auto lo más perfecto posible. Otros juegos son más del estilo arcade y hacen de la conducción algo muy sencillo. Los juegos de carreras pueden ser tridimensionales o bidimensionales. Uno de los mayores retos al crear un juego de carreras es desarrollar una conducción convincente de los autos controlados por la computadora. Simuladores: Igual que simuladores de vuelo. Estos juegos tratan de simular realistamente un mecanismo, como por ejemplo, un avión. Son populares ya que a la gente le gusta entender como funcionan estos sistemas y ser capaces de controlarlos. Crear simuladores es algo difícil ya que deben ser convincentes. Todos estos géneros pueden ser llevados al fascinante mundo de 3D (Tercera dimensión) 10.-La idea global, del modelo de programación. Siempre que vayamos a crear un programa (y nuestros juegos lo serán) deberemos elegir un modelo a seguir; hoy por hoy el modelo que más se usa y que ha probado ser exitoso es el de la programación orientada a objetos. El Game M aker aplica este modelo de una forma soberbia, por lo que pasaremos a explicarlo. En este modelo el elemento básico es el objeto: todo aquello sobre lo que es posible ejercer una acción; así, en un juego como el típico de la nave que mata marcianos. Otro componente del modelo son los eventos; un evento es algo que sucede ya sea sobre el objeto o provocado por él. Siguiendo con nuestro ejemplo de los marcianitos un evento se producirá cuando el usuario presione la tecla de disparo o cuando la nave resulte alcanzada por los rayos que nos disparan los marcianos; también serán eventos el haber presionado una tecla para que la nave se mueva hacia la izquierda o la derecha o mover el ratón para que un misil persiga al marciano más peligroso. Que le dispara a los marcianitos, consideraremos objetos a la nave, a los marcianitos (cada marcianito un objeto) pero también serán objetos las balas que disparamos las explosiones que se producen al chocar contra algo. No son objetos, sin embargo, los sonidos, el fondo de la pantalla (un decorado del espacio en nuestro ejemplo) ni los diferentes niveles que pueda tener el juego. No debemos confundir un evento con lo que hace nuestro programa cuando el evento efectivamente se activa: estas son las acciones. El evento es al presionar alguna tecla o botón y las acciones son las órdenes que debemos programar o escribir para cuando se presione esta tecla o botón. Si queremos que al presionar esta tecla o botón se dispare una bala entonces debemos programar esta acción (crear y disparar la bala) y que ocurra en ese evento (o sea al apretar la tecla o botón indicado). Por suerte no estamos limitados a la cantidad de acciones que podemos ejecutar cuando ocurre el evento y así podríamos agregar que además de salir la bala sume en un valor a el contador cuanto esta alcance a un enemigo y se reproduzca un sonido de efecto. Para completar el modelo nos queda hablar de las Propiedades. Estas son las diferentes características que tiene cada objeto, como el nombre del objeto, su color, el ancho, largo, etc. En el Game M aker este concepto aparece entremezclado con los anteriores, ya que en las propiedades aparecen los eventos y las acciones definidas para ese objeto. Por lo tanto debe de quedar claro que: Objeto: Es todo aquello sobre lo que se puede realizar una acción. Evento: Algo que sucede sobre un objeto o provocado por él , ya sea al presionar una tecla o botón, o porque así esta programado. Acción: Cada orden que se le da al programa para que sea ejecutada cuando ocurre el evento en el que está definida o programada. Propiedades: Cada una de las características de un objeto. 19
- 20. Antes de profundizar en el uso y las posibilidades del Game M aker, es bueno tener una idea global detrás del programa; los juegos creados con el Game M aker toman lugar en uno o más cuartos, o niveles de juego, (los cuartos son planos no en 3D, pero pueden contener imágenes en 3D). En estos cuartos, o niveles de juego se colocan los objetos, los cuales definirán al juego; los objetos, típicos como las paredes, pelotas en movimiento, el o los personajes principales, etc., se moverán alrededor y reaccionaran a las acciones que indique el jugador por medio del teclado, ratón, o jostick, así como a las acciones (actions) que tengan ya programadas o definidas. Por ejemplo, cuando el personaje principal es tocado por un enemigo probablemente muera, o se le reste energía. Los objetos son los ingredientes más importantes de los juegos creados con el Game M aker, así que hablaremos más de ellos en este manual. Primero que todo, la mayoría de los objetos necesitan alguna imagen para hacerlos visibles en pantalla, tales imágenes son llamadas sprites; una imagen (sprite) a menudo no es solo una imagen fija, sino un conjunto de imágenes que son mostradas una tras de otra para crear la animación, a este tipo de imágenes se les conoce como Gif animados, en algunos casos no es necesario el uso de alguna imagen, esto se vera más adelante. Cierta cosas le sucederán a los objetos, tales sucesos se llaman eventos, y dependiendo de estos los objetos pueden tomar ciertas acciones. Por ejemplo cuando un objeto pelota es creado, se l e puede indicar que tome cierto movimiento, si esta se encuentra en su camino con un objeto pared, se consigue un evento colisión (collision event). En tal caso puedes indicar que la pelota se detenga o que rebote en otra dirección; también le puedes agregar un sonido (para esto el Game M aker te permite definir los sonidos). Cuando el jugador presiona una tecla hay un evento de teclado (keyboard event), y el objeto tomara la acción programada, como moverse a una dirección definida; para cada objeto que crees, puedes indicarle acciones de eventos; y de esta forma definir el comportamiento del objeto. Una vez que hayas definido todos tus objetos con sus respectivos eventos es tiempo de crear los cuartos, o niveles de juego en los cuales tomaran acción; los cu artos, o niveles de juego ser án usados como niveles en tu juego, o para desplazarse a otros cuartos, o niveles de juego, hay acciones para moverse de un cuarto a otro. Algo muy importante los cuartos, o niveles de juego suelen tener imágenes de fondo, esta puede ser una imagen o un color simple, tales imágenes pueden ser creadas desde el Game M aker, o cargadas desde un archivo; después debes de poner los objetos en el cuarto, o nivel de juego, puedes poner muchas figuras o instancias de los mismos objetos en un solo cuarto, o nivel de juego o solo colocar uno. Por ejemplo para un objeto pared puedes definir y crear un solo objeto y colocarlo alrededor de todo el cuarto, también puedes tener varias instancias de un enemigo, mientras tengan el mismo comportamiento. Una vez creado el cuarto, o nivel del juego, con los objetos, es hora de ejecutar el juego, el primer cuarto se mostrara y los objetos comenzaran a tomar las acciones indicadas en sus eventos de creación. En resumen, las siguientes cosas (a menudo llamadas recursos) desempeñan un papel crucial en los juegos: Objetos (objects): S on los elementos que normalmente toman vida para el desarrollo del juego. Cuartos, o niveles de juego (Room): Los lugares o niveles donde se desplazan los objetos. Imágenes (sprites): Las imágenes estáticas o animadas que representan a los objetos. S onidos (sounds): Utilizados como música de fondo, o efectos, para los objetos. Fondos (background): Las imágenes que se usan de fondos para los cuartos. Hay realmente un número más de recursos de otro tipo, están las trayectorias, los scripts, las fuentes, y las líneas de tiempo. Estos son importantes para juegos más avanzados, y solo se verán al ejecutar el Game M aker en modo avanzado, y serán explicados dentro de los capítulos avanzados dentro de este manual. La aproximación del Game M aker a la creación de juegos es un tanto particular; en ella intervienen elementos que es necesario comprender para poder armar efectivamente un juego. Un juego consta, como ya hemos dicho, de muchos elementos integrados de una manera muy específica; algunos de estos elementos no son fácilmente perceptibles en el juego pero forman igualmente parte de él. M ás adelante veremos que incluso existe un orden muy específico que conviene respetar para poder realizar con mayor facilidad el juego, aquí te muestro un diagrama básico de lo que debe de contener tu juego. Recuerda que siempre debes de tener una idea de que tipo de juego vas a crear, debes de pensar que imágenes vas a utilizar, para tus fondos y objetos, debes de seleccionar los sonidos apropiados para la música de fondo, y los efectos dentro del juego, debes de pensar que tamaño tendrán tus cuartos o niveles de juego, y cuantos serán, debes de programar los eventos y las acciones para tus objetos, tanto visibles y los no visibles, para poder tener después de un rato de armado y trabajo un juego terminado. 20
- 21. Nota: Los formatos de imagen que pueden ser utilizados como sprites incluyen: BMP, GIF, ICO, JPG, PC X, TIF y una gran cantidad de otros formatos, lo que, quiere decir que podemos usar cualquier programa de dibujo que nos guste para crear una imagen (sprite). Explicaremos ahora lo más necesario para ir conociendo el Game M aker. 11.- Conociendo la inte rfase en modo sencillo del Game Maker. Cuando inicias Game Maker se ve la siguiente ventana: (En realidad, esto es lo que ves cuando estás en modo simple, En modo avanzado se muestran ciertas funciones adicionales). A la izquierda, ves un árbol de recursos representado por carpetas en donde deberás colocar los diferentes recursos mencionados anteriormente: S prites (imágenes), S ounds (Sonidos), Backgrounds (Fondos), Objects (Objetos), Room (Cuarto, o nivel de juego), y dos más: Game Information y Global Game Setting, los cuales veremos más adelante. En la parte superior hay un menú y una barra de herramientas. En este capítulo describiremos brevemente las funciones de los botones, menús, etc. En capítulos siguientes describiremos todo esto con más detalle. 11.1.- File (Menú Archi vo): En el menú archivo (file) puedes encontrar los comandos para cargar y guardar archivos, especialmente estos: New (Nuevo): Permite crear un juego nuevo. Hay que tener cuidado pues el Game M aker no permite tener más de un juego abierto a la vez, por lo que si quieres comenzar un nuevo proyecto de juego y ya tenías otro abierto –al que tal vez hiciste algún cambio- el Game M aker te preguntará si lo quieres guardar. Si contestas que si lo guarda y luego crea una pantalla de proyecto de juego vacía. Open (Abrir): Esta opción te permite abrir un proyecto de juego ya guardado en alguna unidad de almacenamiento, con la misma aclaración que en el caso anterior; si ya estabas trabajando en algún proyecto de juego y le hiciste algún cambio el Game M aker te preguntará si lo quieres guardar y después abrirá el proyecto de juego solicitado. Recent Files (Archivos Recientes): Esta opción sirve para cargar rápidamente alguno de los archivos con los que se han trabajado últimamente, aún que sólo aparecen en esta lista los 8 últimos archivos abiertos. S ave (Guardar): Nos permite guardar un trabajo en una unidad de almacenamiento como el disco duro, un disk et. Si el proyecto de juego con el que estamos trabajando no ha sido guardado nunca el Game M aker nos preguntará por un nombre con el cual debe de guardar el archivo. Si ya tenía un nombre la opción guardar lo vuelve a guardar con ese nombre. S ave As (Guardar Como): Nos permite guardarlo con un nuevo nombre o en otra ubicación, lo que es muy útil cuando uno quiere ir conservando los cambios, que están bien antes de hacerle modificaciones de las cuales no se sabe cómo quedarán. 21
- 22. El Game Maker guarda los archivos bajo un formato propio que tiene la extensión .gmd Game Maker Design (diseño del Game Maker). En este archivo están incluidos todos los datos necesarios para que el juego funcione utilizando el Game Maker. Create Executable (Crear ejecutable): Cuando creamos un juego y nos parece que ha quedado bien surge naturalmente la idea de mostrarlo a otras personas. El archivo .gmd que guarda el GM necesita obligatoriamente que las otras personas tengan instalado el Game M aker, lo que, en general, no es bueno. Por suerte el Game M aker trae incorporada la opción de crear un archivo ejecutable que es un archivo tipo .exe independiente del programa de creación. Los archivos así creados son de libre distribución: ¡otra de las maravillas del Game M aker!, pero no puedes distribuir tu juego en modo de proyecto y dar una copia del programa Game M aker. Advanced Mode (Modo avanzado): Permite acceder a más opciones. Ver más adelante. ¡Importante! Exit (S alir): Al elegir esta opción el Game M aker verifica si se le hicieron cambios al proyecto de juego que está activo (de forma similar a la opción Nuevo); si se le hicieron cambios nos pregunta si queremos guardarlo y si no, sale del programa. 11.2.- Edi t (Menú Edici ón): Este menú contiene un número de comandos que tratan con los recursos (objetos, imágenes, sonidos, etc.). Insert resource (Insertar un Recurso): Inserta el recurso elegido. Esto será tratado con más profundidad en capítulos siguientes. Duplicate (Duplicar): Hace una copia del recurso elegido y lo agrega. Delete (Borrar): Elimina el recurso elegido. Ten cuidado, esto no se puede rehacer. Rename (Renombrar): Da al recurso un nuevo nombre. Esto también se puede hacer desde las propiedades del recurso. Properties (Propiedades): Usa este comando para ver las propiedades del recurso. También se puede lograr haciendo doble clic sobre el recurso. Ten en cuenta que para todos estos comandos existen diversas for mas de hacerlo. Como usando clic derecho sobre la carpeta donde se requiere algún recurso. 11.3.- Add (Menú Agregar o Adquirir): Con este menú, puedes agregar o adquirir nuevos recursos. Ten en cuenta que hay otras formas de lograr esto. 11.4.- Run (Menú Ejecutar): Run normally (Ejecutar Normalmente): Ejecuta el juego como se vería normalmente. El juego se verá y actuará como si fuera una versión terminada del ejecutable. Run in Debug mode (Ejecutar en Modo de Depuración): Corre el juego en Debug M ode (M odo de depuración). En este modo puedes comprobar ciertos aspectos del juego. Es muy útil cuando hay algún error. 11.5.- Windows (Menú Ventanas): En este menú puedes encontrar los comandos más usuales para manejar las diferentes propiedades de la ventana en el Game M aker. Cascade (Cascada): Acomoda las ventanas en forma de cascada. Arrange Icons (Modo de Arrastre): Es útil en particular cuando modificaste el tamaño de la ventana. Close All (Cerrar Todas): Cierra todas las ventanas de propiedades. 11.6.- Hel p (Menú Ayuda): Aquí encontrarás algunos comandos de ayudarte. Contents (Contenido): Este comando muestra el archivo de ayuda. Registration (Registro): Por más que el Game M aker pueda ser usado gratis, estás altamente recomendado que lo registres. Esto desbloqueará gran cantidad de opciones adicionales que te ayudarán en el desarrollo de tu juego. Una vez que usas este comando, podrás ingresar la clave que recibiste al comprarlo. Web site (Sitio Web): Te conecta al sitio oficial del Game M aker. About Game Maker (Acerca del Game Maker): Brinda cierta información sobre la versión del Game M aker. 22
- 23. 11.7.- El Expl orador de Recursos: Como ya viste arriba a la izquierda de la pantalla aparece una zona en la que se muestra, bajo la forma de un conjunto de carpetas, todos los recursos que estamos utilizando en el juego; al decir recursos recordemos que son todos los elementos que hacen el juego: fondos (backgrounds), cuartos, o niveles de juego (rooms), imágenes (sprites), objetos (object), etc. Estos recursos aparecen agrupados en carpetas con el nombre del tipo del recurso. Aquí puedes ver todos los recursos de tu juego. Funciona prácticamente igual que el explorador de Windows, y te será familiar. Si una opción posee un signo (+) es porque puedes ver recursos dentro de esa carpeta. Puedes hacer doble clic sobre el recurso para acceder a las propiedades de este. Puedes cambiar el orden de los recursos arrastrándolos con el ratón. Obviamente, el lugar debe ser el correcto, no puedes arrastrar un sonido a la carpeta de los fondos (backgrounds). Podemos modificar los recursos haciendo doble clic con el ratón sobre el nombre de este o seleccionándolo y luego presionando ALT- Enter. 11.8.- Eli minación de recursos: M uchas veces a lo largo del proceso de creación de un juego nos daremos cuenta que hemos agregado recursos que luego no hemos utilizado, o nos han quedado de una forma que no vale la pena modificarlos, es más fácil borrarlos y empezar de nuevo desde cero. Para eliminar un recurso lo seleccionamos haciendo un clic con el botón izquierdo sobre él y luego hacemos clic con el botón derecho para hacer aparecer un menú contextual; allí elegimos la opción eliminar (Delete). El Game M aker nos pedirá confirmación sobre la acción; si contestamos que No se cancela la operación y todo queda como estaba. Por el contrario si contestamos que si el recurso desaparece y no hay vuelta atrás; mucho cuidado. En este capítulo hemos echado un primer vistazo al Game M aker; vimos el menú File desde donde se realizan las operaciones de abrir y guardar los juegos que vamos creando. Hemos aprendido también a manejar el explorador de recursos, herramienta fundamental del Game M aker; y que desde allí agregamos, modificamos y borramos los diferentes recursos que tiene un juego (imágenes, fondos, objetos, sonidos, cuartos, habitaciones o niveles de juego). Antes de seguir leyendo, asegúrate de tener bien claro el manejo de los recursos: es fundamental para aprovechar las secciones que vienen. 12.- Definiendo las imágenes en modo sencillo: Los sprites son representaciones graficas de los objetos que usaremos en las pantallas de nuestros juegos. El manejo de las imágenes (sprites) es un poco diferente al de los fondos (backgrounds), debido a que pueden ser estáticos o animados; por lo tanto cuando agregamos una imagen (sprite) aparece la ventana de propiedades que muestra, entre otros datos, la cantidad de subimágenes o cuadros que forman la animación. Por ejemplo, la siguiente imagen es de un Pac-man moviéndose hacia la izquierda. Cuando haces un juego debes de recolectar o crear un buen número de imágenes (sprites) para el juego. Algunas colecciones interesantes puedes encontrarlas en la página del Game M aker. Otros sprites los puedes encontrar en Internet como gifs estáticos o animados, o sprits. Para añadir una imagen (sprite), elige la opción agregar imagen (Add Sprite) del menu agregar (Add), o usa el botón correspondiente de la barra de herramientas. Aparecerá la siguiente ventana: Arriba puedes indicar el nombre de la imagen (sprite). Todas las imágenes (sprites) y el resto de recursos tienen un nombre por defecto en este caso sprite0. Lo mejor y lo más lógico es darle un nombre descriptivo. Se atento para no dar dos nombres iguales en los recursos. Aún que no es estrictamente necesario, debo avisarte de que no uses más caracteres que las letras, números y el guión bajo “_” en el nombre de un recurso, y que siempre empiece por una letra. En particular, no uses el espacio, es muy importante para cuando comiences a trabajas con código así que vete acostumbrando. Para cargar una imagen (sprite) desde una carpeta externa utiliza el botón cargar imagen (Load Sprite), localiza la carpeta en donde tienes guardada la imagen que quieres usar y selecciónala da clic en abrir y listo, la imagen a sido cargada al Game M aker. 23
- 24. Game M aker puede cargar muchos formatos de imagen. Cuando cargas un GIF animado, se incluyen todas las subimágenes. Cuando hay varias subimágenes puedes rotarlas usando las flechitas de la barra de herramientas. La casilla llamada Transparent (transparente) indica si el fondo será transparente. La mayoría de los sprites son transparentes. El color de la transparencia está determinado por el color de la esquina inferior izquierda. Ten cuidado de que el fondo no tenga el mismo color de algo dentro de la imagen. (Fíjate que los archivos GIF tienen su propio color como transparente. Esto no ocurre en Game M aker.) Con el botón Edit Sprite (editar imagen) puedes editar una imagen (sprite), o crear uno completamente nuevo. NOTA: cabe aclarar, que Game M aker importa al juego todo recurso que cargues desde tu PC. Así no necesitas una carpeta de recursos o archivos fuera del juego, todo estará dentro del archivo de trabajo. 13.- Definiendo los sonidos y la música en modo sencillo: M uy atrás en el tiempo quedaron los primeros juegos en los que todo el sonido que estos producían eran unos débiles beeps, clinks o zaps; hoy por hoy todos esperamos que un juego tenga variedad de sonidos de calidad digit al y súper realistas. Los sonidos que utiliza el Game M aker pueden ser de tres tipos o formatos: Sonidos digitalizados sin comprimir (WAV): pueden ocupar mucho espacio pero son los que mejor suenan en todos las computadoras que tengan tarjeta de sonido. Sonidos comprimidos (M P3): ocupan mucho menos espacio pero tienen una cierta pérdida de calidad debido al hecho de estar comprimidos. Sonidos bajo la forma de Instrucciones (M IDI): es un formato de sonido muy utilizado por los músicos pero su calidad de reproducción depende del equipamiento que uno tenga instalado en la computadora; con las tarjetas de sonido comunes el resultado es bastante pobre. La mayoría de los juegos tiene ciertos efectos sonoros y música de fondo, muchos efectos de sonido útiles pueden ser encontrados en la página oficial del Game M aker, y puedes encontrar más en Internet. Para agregar un recurso de sonido en tu juego, utiliza la opción Add sound (A gregar Sonido), desde el menú Add (A gregar), o usa el botón de la barra de herramientas, o da clic derecho con el ratón en la carpeta correspondiente (Sounds). Aparecerá la ventana siguiente: Para cargar un sonido, presiona el botón Load S ound (Cargar sonido). Una ventana de selección de archivos, se mostrara en donde podrás elegir el archivo de sonido, nuevamente localiza la carpeta donde tienes guardados tus sonidos para tus juegos. Hay dos tipos de archivos de sonido importantes y que son soportados por Game M aker, archivos WAV (*.wav) y archivos M IDI (*.M IDI). Los archivos Wave son usados para efectos de sonido cortos. Usan mucha memoria, pero se ejecutan instantáneamente. Usa este tipo de archivos para los efectos de sonido de tu juego (Explosiones, disparos, golpes, etc,etc,etc). Los archivos M idi son diferentes y los puedes usar como música de fondo. Como resultado usan mucho menos memoria, pero están limitados a música instrumental (usando el secuenciador de la computadora). Además, por defecto solo se puede ejecutar un archivo M idi a la vez, mientras puedes usar múltiples archivos .wav de forma simultánea. Una vez cargado el archivo de sonido, puedes escucharlo pulsando en el botón reproducir (el de la flecha verde), además el botón S ave sound (S alvar S onido) te guarda en una carpeta de la computadora, que tu indiques una copia del sonido, esto es útil solo si no cuentas con algún sonido que te interese y venga en alguno de los juegos editables o ejemplos con los que puedes practicar; esto se vera más adelante. 14.- Definiendo los fondos en modo sencillo: El tercer tipo de recursos básicos son los fondos (backgrounds), los fondos son generalmente imágenes grandes que están detrás de todo lo demás en tus juegos y que utilizaras en tu cuarto, o nivel de juego, en los cuales se llevara acabo tu juego. La imagen de fondo puede ser estática y puede dársele un movimiento para simular que tiene cierto desplazamiento. Las imágenes de fondo se hacen a menudo de una manera tal que pueden embonar un área sin grietas 24
- 25. visuales; de esta manera se puede llenar todo el fondo con un cierto patrón de una imagen pequeña, un número de fondos (backgrounds) se pueden encontrar en la pagina del Game M aker y muchos más en Internet , o puedes crear los tuyos propios. Para agregar un recurso de fondo a tu juego, utiliza la opción agregar fondo (Add background) en el menú agregar (Add) o utilizan el botón correspondiente en la barra de herramientas. La ventana siguiente aparecerá en pantalla. Si no elegimos una imagen cuando volvamos al explorador de recursos veremos el nombre de fondo que creamos pero sin nada al lado; un fondo bien elegido aparecerá a la izquierda del nombre y se vera de esta forma. 15.- Definiendo objetos en modo sencillo: Se ha visto hasta ahora que tu puedes agregar imágenes (sprites) y sonidos (sounds) al juego, pero estos no hacen nada durante el juego son solamente recursos. Ahora explicaremos el recurso más importante que se utiliza en el juego, los objetos (objects), teniendo en cuenta son los elementos que en realidad intervienen en el juego, y son los elementos que el jugador puede controlar o con los que va a interactuar en el juego. El proceso de agregar un objeto es, en sí, muy similar al de cualquier otro elemento; hacemos clic con el botón derecho del M ouse sobre la opción objetos del explorador de recursos y allí elegimos agregar objeto (Add Object) o vamos al menú Add, Add Object. Se abre la ventana de propiedades del objeto que es el verdadero corazón del Game M aker; allí podremos definir el nombre pero también todos los eventos (events) a los que va a responder ese objeto y las acciones que va a ejecutar cuando el evento se dispare o active. Los objetos (objets) son las entidades en el juego que hacen cosas. La mayoría del tiempo tienen una imagen (sprite) como representación gráfica de modo que tu y las personas que van a usar tus juegos los puedan ver. Tienen un comportamiento ya que pueden reaccionar a ciertos eventos. Todas las cosas que tú ves en el juego (a excepción del fondo) son objetos. O derivaciones de los objetos iniciales. Los caracteres, los monstruos, las pelotas, las paredes, etc. son todos objetos. También puede haber ciertos objetos que tú no desee que se vean pero que controlen ciertos aspectos del juego; por ejemplo los llamados controladores, los cuales pueden o no incluir una imagen. Tiene que quedar clara la diferencia entre las imágenes (sprites) y los objetos (objects). Los sprites son las imágenes (animadas o no animadas) que no tienen ningún comportamiento. Los objetos tienen normalmente una imagen (sprite) para representarlos, pero los objetos (objects) tienen un comportamiento. Así que ¡Sin objetos no hay juego! También observa la diferencia entre los objetos y las instancias de los objetos. Un objeto describe cierta entidad, por ejemplo un monstruo. Puede haber casos o instancias múltiples de este objeto en el juego. Cuando hablamos de un objeto significa todas las imágenes de los casos o instancias de este objeto. Para agregar un objeto a su juego, elije como ya se menciono arriba agregar objeto (Add object) en el menú agregar (Add). La ventana siguiente aparecerá: Este se ve algo más compleja. En la izquierda hay cierta información de carácter general sobre el objeto. En el centro esta la lista de los acontecimientos o eventos que pueden sucederle al objeto. A la derecha están las diversas pestañas de acciones que el objeto puede realizar al activarse un evento. Los eventos y las acciones serán explicados en los capítulos siguientes. Entonces en esta ventana de propiedades se pueden realizar los siguientes pasos: 25
- 26. 1.- Darle un nombre al objeto. 2.- Asignarle una imagen, que obviamente ya tiene que estar definida. 3.- Agregar uno o más eventos. 4.- Elegir todas las acciones que tengas previstas para cada evento. 5.- Se tienen que repetir los dos pasos anteriores tantas veces como eventos vaya a tener el objeto. Como siempre, puedes (y debes) dar al objeto un nombre con sentido. Puedes elegir después la imagen para el objeto. Para elegirla da clic con el botón izquierdo del ratón en la caja de la imagen o el botón del menú al lado de él. Entonces se abrirá un submenú con todas las imágenes disponibles. Seleccione la que deseas utilizar para representar el objeto. Si tú no tiene imágenes (sprites) en el juego todavía, puede pulsar el botón nuevo para agregar un nuevo recurso de imagen o para cambiar los existentes. También, cuando seleccionas un recurso habrá un botón de edición (edit) que puedes utilizar para cambiar la imagen (sprite). Esto es más rápido pero primero hay que encontrar el recurso en la lista de recursos y en seguida indicarle que desea editarlo. Debajo de esto hay dos opciones. Visible indica si el objeto es visible. Claramente, la mayoría de los objetos son visibles, pero a veces es útil tener objetos invisibles (como los controladores). Por ejemplo, puedes utilizarlos para las puntuaciones o para un movimiento de un monstruo o enemigo. Los objetos invisibles reaccionarán a los eventos y otras acciones. La opción de nombre sólido (Solid) indica si este es un objeto sólido (como lógicamente lo seria una pared). Las colisiones con los objetos sólidos se tratan diferentemente de colisiones con los objetos no-sólidos. Se aconseja utilizar el sólido solamente para el objeto que no se está moviendo. 16.- Conociendo los eventos: Game M aker usa lo que es llamado un mecanismo manejado por eventos. Esto funciona así. En cualquier momento que algo suceda en el juego las instancias de los objetos, obtienen eventos -una especie de mensajes diciéndoles que algo ha ocurrido y que deben de realizar una acción-. Las instancias pueden entonces reaccionar a estos mensajes ejecutando ciertas acciones. Para cada objeto, se debe indicar a cuales eventos, debe responder y que acciones debe ejecutar cuando el evento ocurra. Esto puede sonar complicado pero en realidad es bastante simple. Primero que nada, para la mayoría de eventos, los objetos no tienen que hacer nada. Para los eventos donde algo debe ser hecho puedes usar un simplísimo sistema de Arrastrar y Colocar para indicar las acciones. En el centro de la ventana de propiedades del objeto, esta un listado de eventos a los cuales el objeto debe reaccionar. Al inicio esta vacía. Pero puedes agregarle eventos a la lista presionando el botón Add Event (Agregar evento). Aparecerá el siguiente formulario con todos los tipos de eventos disponibles. Seleccionas el evento que quieres agregar. En algunos casos aparecerá un menú con opciones extra para algunos eventos. Por ejemplo, para el evento 'Keyboard' (Teclado) debes seleccionar una tecla de entre el menú de opciones. Abajo encontraras una lista completa de todos los eventos más sus descripciones. Al seleccionar uno de los eventos de la lista de eventos del objeto, este será el evento en edición. Para editar otro evento simplemente da clic al botón que represente el evento que deseas realizar. A la derecha de la ventana de propiedades del objeto, están todas las acciones representadas por pequeños iconos. Estas están agrupadas en pestañas. En próximos capítulos encontraras las descripciones de cada acción y lo que estas hacen. En el formulario, entre los eventos y las pestañas de acciones esta una lista de acciones, que deben ser ejecutadas por el evento seleccionado. Para añadir acciones al evento seleccionado, se arrastran con el M ouse desde las pestañas de acciones a la lista de acciones del evento. Estas se ubicaran una bajo la otra con una corta descripción. Por cada acción que coloques, se te pedirá que proveas o especifiques algunos parámetros. Estos serán descritos en un próximo capítulo. Después de agregar algunas acciones la ventana lucirá más o menos así: Ahora puedes empezar a agregar acciones a otros eventos. Selecciona el evento que quieres dándole clic, y arrastra las acciones necesarias a la lista de acciones del evento. Puedes cambiar el orden de las acciones en la lista simplemente arrastrándolas y colocándolas en la lista. Si presionas la tecla (Alt) mientras arrastras, harás una copia de la acción seleccionada. Puedes además arrastrar acciones de la lista de un objeto hacia la lista de acciones de otro objeto. Si das clic derecho sobre una acción, aparecerá un menú en donde puedes borrar la acción (puedes 26
- 27. hacerlo también presionando la tecla (Delete o supr) en el teclado o copiar y pegar acciones) Puedes seleccionar múltiples acciones para cortar, copiar o borrar usando las teclas (Shift) o (Control). Puedes seleccionar todas las acciones de un evento presionando (Control + A). Si dejas el puntero del M ouse sobre una acción, una descripción detallada aparecerá acerca de la acción. Ve el próximo capítulo para más información sobre las acciones. Para borrar el evento seleccionado junto a todas sus acciones, presiona el botón (Delete). -Los eventos sin ninguna acción son automáticamente borrados cuando cierres la ventana, así que no hay necesidad de borrarlos manualmente-. Si quieres asignar estas acciones a un evento diferente (Por ejemplo, si decidiste usar una tecla diferente para algo) presiona el botón cambiar (Change) y selecciona el nuevo evento que quieres (¡Este no debería estar definido ya!). Usando el menú que aparece al dar clic derecho en la lista de eventos, puedes además duplicar un evento, esto es, agregar un nuevo evento con las mismas acciones del evento seleccionado. Como ya se señalo arriba, para agregar un evento simplemente presiona el botón Agregar Evento (Add Event) y el formulario se mostrara: Seleccionas el evento que quieres agregar. Recuerda que dependiendo del evento algunas veces un menú aparecerá con opciones extra. A continuación se te presentara la descripción de cada evento (Recuerda que normalmente solo usaras unos pocos de ellos, a la hora de elaborar o crear tu juego, en juegos más complicados puede ser que tengas que usar más de estos eventos). Recuerda: Que si agregas un evento, pero no defines acciones para ese evento y cierras la ventana de propiedades del objeto, el evento recién definido se borra de la lista. Esto se hace como una forma de asegurarnos de que no quede basura en el programa; un evento sin acciones no tiene sentido. “Create event” (Evento Creación o Crear) Este sucede cuando una instancia de objeto es creada. Es normalmente usado para darle movimiento a la instancia cuando se cree o aparezca en el cuarto, o nivel del juego destinado o establecer ciertas variables para la instancia por medio de un objeto controlador o de control. “Destroy event” (Evento Destrucción) Este evento sucede cuando la instancia es destruida. Para ser preciso, sucede justo antes de que la instancia se destruya, ¡así que la instancia aún existe cuando el evento es ejecutado! (y aún tiene todas sus propiedades) La mayoría de las veces este evento no es usado, pero puedes por ejemplo usarlo para cambiar la puntuación del juego, o crear algún otro objeto al destruir otro. “Alarm events” (Eventos de Alarmas) Cada instancia tiene hasta 12 “Relojes de Alarma”. Puedes iniciar estos relojes usando ciertas acciones (detalladas en el siguiente capítulo). El reloj de alarma entonces comienza una cuenta regresiva hasta llegar a 0, en ese momento el evento de alarma indicado o establecido es generado o creado. Para indicar las acciones para uno de los relojes de alarma, primero debes seleccionarlo del menú (uno de los relojes disponibles). Los relojes de Alarma son muy útiles. Puedes usarlos para hacer que ciertas cosas sucedan, cada cierto tiempo. Por ejemplo un mounstro puede cambiar la dirección en la que camina cada 20 pasos (steps -pasos del juego). En este caso alguna de las acciones en el evento de alarma debería reestablecer el tiempo de la alarma de nuevo, ya que las alarmas solo se ejecutan una única vez y luego se desactivan automáticamente. “Step events” (Eventos de “Paso” del juego) Los eventos paso (step) ocurren en cada paso del juego. Aquí puedes poner acciones que necesites, que se ejecuten continuamente. Por ejemp lo si un objeto debe seguir a otro, aquí puedes ajustar la dirección de movimiento hacia el objeto que se esta siguiendo. Debes ser un poco cuidadoso con este evento. No pongas muchas acciones complicadas en el evento paso de objetos de los cuales habrá muchas instancias (por ejemplo en un enemigo común y corriente). Esto puede reducir la velocidad del juego. Para ser más precisos, hay tres tipos diferentes de eventos pasos. Normalmente solo necesitaras el evento por defecto, pero usando el menú, puedes además seleccionar los eventos: Inicio de paso (Begin Step) y Final de Paso (End Step). El evento 'Begin Step' (Inicio del Paso) se ejecuta al inicio de cada paso del juego, justo antes de que cualquier otro evento se ejecute. El evento 'Step' (Paso normal) es ejecutado antes que las instancias sean colocada en sus nuevas posiciones (si se están moviendo por ejemplo). El evento 'End Step' (Fin del Paso) es ejecutado al final de cada paso en el juego, justo antes de dibujar la pantalla. Este es típicamente usado para cambiar la imagen dependiendo de la dirección de movimiento. 27
- 28. “Collision events” (Eventos de Colisión o choque) Cuando sea que dos instancias colisionen o choquen (Esto es, que sus imágenes se sobrepongan o encimen) un evento de colisión es generado. Para ser precisos, dos eventos de colisión se generan; uno por cada instancia. La instancia puede reaccionar ante algún evento de colisión (Por ejemplo si una bala golpea al personaje, este tal ves pierda o energía o muera). Para este fin, del menú selecciona al objeto con el cual quieres definir el evento de colisión y luego define las acciones. Hay una diferencia en lo que pasa si la instancia colisiona con un objeto sólido o con uno no sólido. Primero que nada, si no hay acciones en el evento colisión (o si ni siquiera has definido el evento colisión entre dos objetos), nada sucede. Las instancias simplemente siguen moviéndose; aún si el otro objeto era sólido. Cuando el evento colisión contiene acciones esto es lo que puede pasar: Si el otro objeto es sólido, la instancia es colocada en su ultima posición conocida (donde estaba antes que la colisión ocurriera si se estaba moviendo) entonces el evento es ejecutado. Finalmente la instancia es movida a su nueva posición. Así que si el evento por ejemplo provoca que la dirección del movimiento se revierta o regrese, la instancia rebota contra el otro objeto sin detenerse. Si después de eso aún hay una colisión, la instancia se mantiene es su posición previa. Así que efectivamente dejara de moverse. Cuando el otro objeto es no sólido, la instancia no es puesta en su posición anterior. El evento simplemente se ejecuta con la instancia en su posición actual. Así que no hay una segunda revisión de colisión. Si piensas bien en esto, esto es lógicamente lo que debería suceder. Ya que el objeto no es sólido, podemos simplemente movernos sobre el o a través de el. El evento simplemente nos notifica que esto esta ocurriendo. Hay muchos usos para los eventos de colisión. Las instancias de objetos lo pueden usar para rebotar contra las paredes. Puedes usarlo para destruir instancias de objetos cuando estas sean golpeadas o alcanzadas por una bala, o un enemigo. “Keyboard events” (Eventos del Teclado) Cuando el jugador presiona una tecla, un evento de teclado se ejecuta para todas las instancias de todos los objetos involucrados. Hay un evento diferente por cada tecla. En el menú (al agregar el evento) selecciona la tecla para la cual quieres definir el evento de teclado y luego arrastra las acciones para ese evento. Obviamente solo unos cuantos objetos necesitan eventos para unas cuantas teclas. Puedes tener un evento en cada paso del juego mientras el jugador mantenga una tecla presionada. Hay dos eventos especiales del teclado. El primero es llamado No Key (Ninguna tecla). Este ocurre en cada paso del juego cuando ninguna tecla esta siendo presionada. El segundo se llama Any key (Cualquier tecla) y ocurre en cualquier momento, que cualquier tecla este siendo presionada (sin especificar cual). Si el jugador presiona múltiples teclas a la vez, los eventos de cada tecla presionada se ejecutan. Debes notar que las teclas del teclado numérico solo producen sus correspondientes eventos cuando NumLock (Bloqueo numérico) esta activado. “M ouse events” (Eventos del Ratón) Un evento del M ouse ocurre para una instancia cuando el cursor del M ouse esta dentro de la imagen que representa a la instancia del objeto. Dependiendo del botón del M ouse que sea presionado puedes obtener No Button (Ningún Botón), Left Button (botón izquierdo), Right Button (Botón derecho) o M iddle Button (Botón central del M ouse, si tiene 'M ouse wheel' es al presionar la rueda como si fuera un botón). Los eventos de botón simple del M ouse (left Button, right Button y middle Button) son generados en cada paso del juego, mientras el jugador mantenga el botón del M ouse presionado. Los eventos pressed (presionado) son solo serán generados una única vez cuando el botón es presionado. Los eventos release (soltar o liberar el botón) son generados una única vez justo cuando el botón del M ouse es soltado. Nota que estos eventos solo ocurren si el cursor del M ouse esta sobre la instancia. Si quieres poder activar o usar a los eventos del M ouse (normal, pressed y release) pero en un lugar cualquiera de la pantalla (no necesariamente sobre una instancia) usa los eventos globales del M ouse que están en un submenú (global M ouse). Hay dos eventos especiales del M ouse. El evento M ouse Enter (Al entrar el ratón) se ejecuta cuando el puntero del M ouse entra en la instancia (justo cuando se pone sobre la imagen). Al contrario el evento M ouse Leave (Al salir el ratón) sucede cuando el puntero del M ouse se quita de sobre una instancia (sale de la instancia) Estos eventos son típicamente usados para cambiar la imagen o ejecutar algún sonido (Por ejemplo podrías en un menú tener un botón, al ponerse el M ouse sobre el botón, el botón se ilumina (Cambia su sprite) y se escucha un sonido (Evento M ouse enter), luego en el evento (M ouse leave) reestableces el grafico del botón por su imagen original, haciendo así un botón cambiante). Finalmente hay algunos eventos relacionados con el joystick (control de juegos) que se encuentran dentro de los eventos del M ouse. Puedes definir eventos para las cuatro direcciones principales en el joystick (para direcciones diagonales, los dos eventos son ejecutados). Además puedes definir eventos hasta para 8 botones del joystick. Puedes definir esto para el joystick primario y secundario (Game M aker soporta hasta dos joysticks simultáneos) “Other events” (Otros eventos) Hay algunos eventos extra que pueden ser útiles en algunos juegos y están es este menú. Los eventos que puedes encontrar son: Outside (Afuera del Cuarto): Este evento ocurre cuando la instancia del objeto sale completamente del cuarto, o nivel de juego. Típicamente es un buen momento para destruirla, o hacerla aparecer en otro lado 28
- 29. Boundary (Al limite o Frontera): Este evento ocurre cuando la instancia de objeto intercepta o llega a el limite del cuarto, o nivel de juego pero aún esta en parte dentro del cuarto, o nivel del juego (room). Game start (Inicio del juego): Este evento solo se ejecuta en el primero cuarto, o nivel de juego (Room), cuando el juego inicia. Se ejecuta después del evento (room start) -ver el siguiente evento- pero antes del evento creación de las instancias del objeto en el cuarto, o nivel de juego. Este evento es típicamente definido solo en un objeto controlador y es usado por ejemplo para iniciar alguna música de fondo, inicializar algunas variab les o cargar alguna información (de un archivo). Game end (Fin del juego): Ese evento se ejecuta para todas las instancias cuando el juego termina (o te sales del juego). De nuevo, típicamente se define este evento en un único objeto y es usado por ejemplo para guardar alguna información en un archivo. Room start (Inicio de Room) : Este evento se ejecuta para todas las instancias que inicialmente estén en un cuarto, o nivel de juego (Room), cuando este cuarto, o nivel de juego (Room), se inicia. Sucede después de los eventos de creación (Creation) de las instancias. Room end (Fin del Room) : Este evento se ejecuta para todas las instancias existentes cuando el cuarto, o nivel de juego (Room), termina. No more lives (No más vidas): Game M aker posee un sistema p redefinido de vidas (lives). Hay una acción para establecer y cambiar el número de vidas (lives). Cuando sea que el número de vidas sea menor o igual a cero, este evento es generado. Es típicamente usado para terminar o reiniciar el juego. No more health (No más energía): Game M aker posee un sistema predefinido de energía. Hay una acción para establecer y cambiar la energía. Cuando sea que la energía sea menor o igual a cero, este evento es generado. Es típicamente usado para reducir el número de vidas o para reiniciar el juego. End of animation (Fin de la animación) : Como fue indicado antes, una animación (sprite animado) consiste en cierto número de imágenes que son mostradas una tras la otra. Luego de que la última subimagen es mostrada la animación se reinicia desde la primera imagen. Este evento se genera en ese preciso momento (antes de cambiar la última imagen por la primera). Por ejemplo esto puede ser usado para cambiar la animación o destruir la instancia. End of path (Final del camino o trayectoria): Este evento se genera cuando la instancia esta siguiendo (usando) un camino, o trayectoria (path) y el final del camino o trayectoria es alcanzado. User defined (Eventos definidos por el usuario): Hay disponibles ocho de estos eventos. Estos normalmente no son generados nunca, a menos que tu mismo los ejecutes desde un bloque de código en lenguaje Game M aker (GM L). “Draw event” (Evento de dibujo) Las instancias cuando son visibles, dibujan (Automáticamente) su imagen en cada paso de juego en la pantalla. Cuando especificas acciones en el evento dibujo (Drawi), la imagen no es dibujado, pero estas acciones son ejecutadas en su lugar. Esto puede ser usado para dibujar algo más que la imagen o para antes de dibujar hacer algunos cambios a los parámetros de la imagen. Hay varias acciones de dibujado que están disponibles para ser usadas especialmente en el evento dibujo (Drawi). Hay que notar que el evento dibujo (Drawi), es solamente ejecutado si el objeto (más específicamente, si la instancia del objeto) es visible. Además, nota que, independientemente de lo que dibujes, los eventos de colisión son basados en la imagen asociada con la instancia (o si la posee en su máscara). “Key press events” (Evento presionar una tecla) Este evento es similar al evento keyboard pero este sucede una única vez cuando la tecla es presionada, en lugar de generarse continuamente. Es útil cuando quieres que las acciones se ejecuten una única vez, como por ejemplo para que cada que se presiona una tecla haya un disparo por parte de una nave, o un golpe o patada por parte del personaje que esta interactuando con el jugador. “Key release events” (Evento soltar/liberar una tecla) Este evento es similar al evento keyboard pero sucede una vez cuando la tecla es soltada o liberada en lugar de generarse continuamente. En algunos casos, es importante comprender el orden en el cual Game M aker procesa los eventos. Este orden es el siguiente: 1.- Evento de inicio de paso (Begin step event) 2.- Eventos de los relojes de alarma (Alarm events [1-8]) 3.- Eventos del teclado ('Keyboard', 'Key press' y 'Key release') 4.- Eventos del M ouse (M ouse events) 5.- Evento paso normal (En este punto, todas las instancias son colocadas en su nueva posición) 6.- Eventos de colisión 29
- 30. 7.- Evento de final del paso (End step events) 8.- Evento dibujo (Drawing) Los eventos creación, destrucción y los del menú otros eventos son generados cuando las correspondientes acciones o causas suceden. 17.- Conociendo las acciones en modo sencillo: Las acciones indican las cosas que suceden en un juego creado con el Game M aker. Las acciones (actions) se ponen en los eventos de los objetos (objects). Es interesante destacar que cada acción tiene su propia ventana de definición, donde podemos darle valores a las acciones (actions); en algunos casos será simplemente elegir para donde queremos que se mueva la instancia del objeto; en otros será marcar la velocidad de caída y la aceleración; en otros si tiene que destruirse a sí mismo o a otro(s) objeto(s). Siempre que ocurra el evento (event) especificado estas acciones (actions) se realizan, dando por resultado cierto comportamiento para las instancias del objeto. Hay una gran cantidad de acciones disponibles y es importante que entiendas lo que hacen. En este capítulo se explicaran las acciones disponibles en el modo simple del Game M aker. Algunas de estas acciones solo estarán disponibles en la versión registrada del Game M aker si es así se hará la indicación. Todas las acciones (actions) están a la derecha de las características en los objetos (objects). Hay seis pestañas de acciones. Tienes que seleccionar la pestaña que deseas pulsando sobre ella. Cuando mantengas el ratón sobre las acciones te aparecerá una pequeña descripción de la acción que hace o realiza pero en ingles. Para poner una acción (action) en un evento (event), pulsa sobre el icono y arrástrala a la ventana de acciones. Después puedes cambiar el orden en la lista del evento pulsando y arrastrando la acción. Si pulsas (Alt) mientras pulsas sobre la acción realizaras una copia de la misma. (Tú puedes arrastrar y copiar acciones entre las listas de eventos del mismo juego.) Utiliza el botón derecho del ratón y selecciona la acción de la pestaña correcta para quitar acciones, o utiliza la tecla (Del o supr), también puedes copiar y pegar acciones usando los comandos apropiados. Cuando pones una acción (action) en la lista de la acciones, se abre una ventana nueva, en la cual puedes completar algunos parámetros para la acción (action). Los parámetros serán descritos después al describir las acciones. Hay dos tipos de parámetros que aparecen en muchas acciones así que describiré éstos dos aquí. En la parte superior puedes indicar a que objeto se aplicara la acción. Por defecto es al objeto mismo, que es el objeto para el cual se realiza la acción. La mayoría de las veces es lo que necesitas. En el caso de un evento de colisión, puedes especificar para que objeto se aplicara la acción implicado en la colisión (collision). Por ejemplo, de esta manera puedes destruir el otro objeto implicado en el evento. Finalmente, puedes elegir aplicar la acción (action) a todas las repeticiones de un objeto particular. De esta manera podrías cambiar todas las pelotas rojas a pelotas azules (Por Ejemplo). El segundo tipo de parámetro es la casilla denominada relative (relativa). M arcando esta casilla, los valores que escribas dentro están concernientes a los valores actuales y serán sumados o agregados. Por ejemplo, de esta manera puedes agregar cierta cantidad de puntos a la puntuación actual, cambiado la puntuación actual al nuevo valor agregado. Los otros parámetros serán descritos más abajo. Tienes que pensar que puedes modificar todos los parámetros de la acción (action), simplemente dando doble clic sobre el icono de la acción que deseas modificar. La explicación sobre las acciones la puedes encontrar a continuación en las siguientes páginas. 17.1.- Move (Pestaña de movi miento): En esta pestaña existen las acciones siguientes y se describirá a continuación la acción que genera cada uno de los botones que aquí: S tart moving in a direction (Comenzar moviéndose en una dirección): Usa esta acción para indicarle a la instancia del objeto que debe de comenzar a moverse en una dirección particular. Puede indicar la dirección usando los botones con las flechas. Utiliza el botón de en medio para detener el movimiento. También necesitas especificar la velocidad del movimiento, ya que si solo asignas la dirección pero no la velocidad y no ocurrirá nada al iniciar el juego. Esta velocidad se da en píxeles por paso del juego. El valor predeterminado es 0. También puedes especificar direcciones múltiples. Así se elegirá una dirección al azar. De esta manera puedes hacer que un monstruo comience a caminar de iz quierda o derecha, abajo o arriba cuando se cree. Set direction and speed of motion (Fijar la dirección y la velocidad del movimiento): Esta es la segunda manera de especificar un movimiento. Aquí puede indicar una dirección exacta, en un ángulo entre 0 y 360 grados. El grado 0 es la derecha. La dirección va contra las agujas del reloj. Por 30
- 31. ejemplo 90 indica una dirección hacia arriba. Si deseas una dirección arbitraria o al azar, puedes aplicar random (360). Así tu verás que la función al azar (random) da un número al azar más pequeño que el valor indicado pero mayor que 0. Puede que hayas notado que hay una etiqueta nombrada relativa (relative). Con esto, el nuevo movimiento se agrega el anterior. Por ejemplo, si la instancia se está moviendo hacia arriba y tú agregas un cierto movimiento a la izquierda, el nuevo movimiento será arriba y a la izquierda. Move towards a point (Movimiento hacia un punto): Esta acción da una tercera manera de especificar un movimiento. Indicas aquí una p osición y una velocidad y la instancia comenzará a moverse con esa velocidad hacia la posición indicada (No parará en la posición indicada). Por ejemplo, si quisieras que una bala vaya hacia la posición de la nave espacial puedes utilizar como posición nave_espacial.x, nave_espacial.y (recuerda que los nombres de los objetos no deben de llevar espacios). Aprenderás más sobre el uso de variables como éstos más adelante. Si compruebas la casilla de verificación, especifica la posición concerniente a la posición actual del objeto. (La velocidad no se toma como relativa). Set the horizontal speed (Fijar la velocidad horizontal): La velocidad de una instancia consiste en una parte horizontal y una parte vertical. Con esta acción puedes cambiar la velocidad horizontal. Una velocidad horizontal positiva significa un movimiento a la derecha. Negativo significa un movimiento a la izquierda. La velocidad vertical seguirá siendo igual. Usa la opción (relative) para aumentar la velocidad horizontal (o disminuirla con un número negativo). Set the vertical speed (Fijar la velocidad vertical): De una manera similar a la anterior, con esta acción puedes cambiar la velocidad vertical de la instancia. Set the gravity (Fije la gravedad): Con esta acción puedes indicar la gravedad para un objeto en particular. Especificas una dirección (un ángulo entre 0 y 360 grados) y una velocidad, y en cada paso (step) esta cantidad de velocidad en la dirección dada se agregara al movimiento actual del objeto. Normalmente necesitas un incremento muy pequeño de la velocidad como por ejemplo 0,01. Normalmente necesitarás una dirección hacia abajo (270 grados). Si verificas la casilla relativa, aumenta la velocidad y la dirección de la gravedad. Observa que, contrariamente a la vida real, diversos objetos pueden tener diversas direcciones de la gravedad. Reverse horizontal direction (Cambiar la dirección horizontal): Esta acción cambia el movimiento horizontal de la instancia del objeto. Esto puede ser usado por ejemplo cuando el objeto choca con una pared vertical. Reverse vertical direction (Cambiar la dirección vertical): Esta acción invierte el movimiento vertical de la instancia del objeto. Esto puede ser usado por ejemplo cuando el objeto choca con una pared horizontal. Set the friction (Establecer la fricción): La fricción retrasa o disminuye la velocidad de las instancias del objeto cuando se mueven. Especificas la cantidad de fricción. En cada paso (step) esta cantidad se resta de la velocidad hasta que la velocidad se convierte en 0. Usa un número muy pequeño, por ejemplo 0,01. Jump to a given position (S altar a una posición dada o especificada): Con esta acción puedes poner la instancia en una posición en particular. Especificas simplemente las coordenadas “x” y “y”, y la instancia se coloca en el punto de referencia indicado. Si marcas la casilla de verificación (relative), la posición está concerniente a la posición actual del objeto. Esta acción se utiliza a menudo para mover continuamente un objeto. En cada paso (step) incrementamos la posición un poco. Jump to the S tar Position (Salta a la posición de comienzo o inicio): Normalmente esta acción se usa cuando la instancia del objeto que representa al jugador es eliminada, y se le indica que debe de reaparecer en la posición donde fue creada al inicio del juego, cuarto o nivel del juego. 31
- 32. Jump to a random position (Salta a una posición al azar): La instancia del objeto se desplaza a una posición al azar por todo el cuarto, o nivel de juego (Room). Solamente se eligen las posiciones donde la instancia del objeto no haga contacto con ningún objeto sólido. Puedes especificar que se alinee en la cuadricula o rejilla del cuarto (snap). Si especifica valores positivos, las coordenadas elegidas serán múltiplos del número entero de los valores indicados. Esto se podría por ejemplo utilizarse para mantener el objeto alineado con las celdas de tu juego. Puedes especificar si encajara en una cuadricula (snap) horizontal separada y/o si encaja en una cuadricula (snap) vertical. Snap to grid (Emplazar en una celda): Con esta acción puedes redondear la posición de la instancia a una rejilla o celda. Puede indicar el valor en que se colocara horizontal y vertical (es decir, el tamaño de las separaciones de la rejilla). Esto puede ser muy útil para cerciorarse de que las instancias permanecen dentro de una rejilla. To transport when one leaves outside (Transportar cuando se sale fuera): Con esta acción puedes cambiar la posición de una instancia de objeto, es decir, cuando se sale del cuarto, o nivel de juego, por un lado, la instancia reaparece en el otro lado. Esta acción se utiliza normalmente en el evento Outside. Observa que la instancia debe tener una velocidad, porque la dirección para cambi arse está basada en la dirección del movimiento. Puedes indicar si cambiara solamente de modo horizontal, vertical, o en ambas direcciones, un ejemplo de esto es el juego del Pac-M an. Move to contact position (Moverse al entrar en contacto con una posici ón): Con esta acción puedes mover la instancia de un objeto, en una dirección dada hasta que una posición de contacto con otro objeto que se alcanza. Si hay ya una colisión en la posición actual la instancia no se mueve. Si no, se pone la instancia momentos antes que ocurra una colisión. Puedes especificar la dirección pero también una distancia máxima para el movimiento. Por ejemplo, cuando está bajando la instancia puede bajar una distancia máxima hasta que se encuentra un objeto. Puedes también indicar si considerar a un objeto sólido en particular o a todos los objetos. Normalmente se pone esta acción en la colisión para cerciorarse de que la instancia para la cual habrá el contacto esta presente con la otra instancia implicada en la colisión. Bouce against objects (Rebotar contra objetos): Cuando pones esta acción en la colisión con un determinado objeto, la instancia rebota contra este objeto de una manera natural. Si fijas el parámetro exacto a falso, sólo las paredes horizontales y verticales se tratan correctamente. Cuando fijas exacto las instancias inclinadas (e incluso las que llevan curvas) se tratan correctamente. Esto sin embargo hace al juego más lento, pero en ocasiones vale la pena. También puedes indicar si rebotara solamente con objetos sólidos o contra cualquier objeto. El rebote no es totalmente exacto porque éste depende de muchas características. Pero en muchas situaciones el efecto es bastante bueno y más que satisfactorio. 17.2.- Main 1 (Pestaña princi pal 1): Las siguientes acciones se encargan de manejar instancias de objetos, sonidos y cuartos: Estas acciones son la que más se usaran dentro del desarrollo de los juegos, a continuación se explica la acción que realiza cada uno de los botones, aquí mostrados. Create an instance of an object (Crear la instancia de un objeto): Con esta acción puedes crear una instancia de un objeto. Debes especificar el objeto del que se va a crear la instancia y su posición. Si seleccionas la casilla (Relative), la posición de la nueva instancia será relativa a la del objeto desde el que se crea la instancia. Crear instancias durante el juego es extremadamente útil: Una nave puede crear balas, una bomba puede crear una explosión, etc. En muchos juegos se usa un controlador (invis ible para el jugador) que, pasado un cierto tiempo, crea instancias de enemigos o algún otro tipo de objetos. Create an instance of an object with a speed and direction (Crea una instancia de objeto con una velocidad y dirección): Esta acción funciona igual que la anterior, pero con un par de añadidos. En esta acción, puedes especificar la velocidad y dirección de la nueva instancia. Observación: Al seleccionar la casilla (Relative), tan solo la posición es relativa, no la velocidad ni la dirección. Por ejemplo, para hacer que una bala se mueva en la dirección en la que se mueve una nave, usamos un pequeño truco: Como posición, ponemos 0, 0 y seleccionamos (Relative). Para la 32
- 33. dirección, necesitamos obtener la dirección actual del objeto. Esto puede hacerse escribiendo direction En el campo “direction”. (Direction es una variable local que indica la dirección en la que se mueve la instancia de un objeto.) Create instance of random object (Crear una instancia de un objeto al azar): Esa acción te permite crear una instancia de un objeto al azar, entre 4 objetos que pueden ser elegidos. Especificas los cuatro objetos y la posición. Una instancia de objeto de uno de esos cuatro objetos es creada en la posición indicada. Si necesitas menos de cuatro objetos, solo marca (No Object). Esto es útil, por ejemplo, para crear a un enemigo al azar en una posición, y así darle un poco de variedad a tus juegos. Change the instance (Cambiar la instancia/objeto por otro): Con esta acción, puedes cambiar la instancia actual por otra instancia de otro objeto. Por ejemplo, puedes cambiar la instancia de una bomba por la de una explosión. Todas las variables, como la velocidad o la posición, se mantienen al cambiarse la instancia. Puedes indicar si quieres que los eventos “Dest roy” y “Create” de las instancias se ejecuten o no. Destroy the instance (Destruir la instancia): Con esta acción destruyes la instancia actual del objeto. En un evento de colisión lo más normal seria que las partes involucradas fueran destruidas, así qu e asumiendo que una de las balas de nuestra nave alcanza a una nave enemiga, esta debe de ser destruida al entrar en contacto con la bala, pero la bala también debe de ser destruida, de lo contrario seguiría con su ruta y podría destruir más enemigos algunas ocasiones esto puede ser útil pero normalmente no es lo que se busca, otra forma de usar esta acción es cuando un objeto desaparece del cuarto o nivel del juego, ese podría ser un buen momento para destruirlas sin generar un tipo de puntuación. Destroy instances at a position (Destruye las instancias en una posición): Con esta acción se destruyen todas las instancias de objetos cuyo límite cuadrado contenga la posición especificada. Es muy útil, por ejemplo, cuando haces explotar una bomba, lo que querrás ver es que se destruyan no solo un edificio si no también algunos de los que están a su lado, o si la dejas caer sobre un monstruo que mueran los otros que se encuentren cerca. Cuando seleccionas la casilla (Relative), la posición se convierte en relativa a la instancia. Change the sprite (Cambia la imagen): Con esta acción podemos cambiar la imagen del objeto. Debes indicar la nueva imagen que formara parte del objeto. También puedes usar una subimagen para la imagen. Normalmente suele usarse 0 (la p rimera subimagen) o una subimagen particular. Usa -1 si no quieres cambiar la subimagen actual. Finalmente, puedes cambiar la velocidad de la animación de las subimágenes. Si no quieres ver el objeto animado, pon la velocidad a 0. Si la velocidad es mayor que 1, algunas subimágenes no se verán. Si es menor que 1, se verán durante más de un paso (step). No uses una velocidad negativa. Cambiar las imágenes de las instancias es muy útil. Por ejemplo, puedes cambiar la imagen según la dirección de un personaje. Esto se haría poniendo una imagen para cada una de las cuatro direcciones o, si se mueve en 360º, haciendo una imagen con animación de rotación, y poniendo la subimagen correspondiente a la dirección, un ejemplo típico de esto es el Pac man. Transform the sprite (trasforma la imagen): Usa esta acción para cambiar el tamaño y la orientación de la imagen durante el juego. Usando la escala puede hacerse más grande o más pequeña la imagen. El ángulo da la rotación en sentido de las agujas del reloj de la imagen. Por ejemplo, para hacer que la imagen mire hacia la dirección en la que se mueve, ponemos la dirección en el campo correspondiente. Esto puede servir, por ejemplo, para un coche. También puedes indicar si quieres que la imagen esté volteada vertical u horizontalmente. Esta acción sólo está disponible en la versión registrada de GM . Set sprite blending (Fijar la mezclar del sprite): La imagen se dibuja normalmente mientras que se define. Usando esta acción puedes cambiar el color de la imagen. El color se mezcla con la imagen, es decir, se combina con los colores de la imagen así si tu imagen fuera de color rojo y lo combinas con un tono amarillo obtendrás una imagen naranja. Si quieres dibujar una imagen en distintos colores, es mejor que la imagen original sea en blanco y negro, y luego usar está acción para cambiarlo. También puedes indicar la transparencia. Con un valor de 1 la imagen es opaca, mientras que con un valor de 0, es completamente transparente (invisible). Con un valor intermedio (0.5) consigues semitransparencia. Es muy útil para efectos de oscuridad, para nubes, etc. Esta acción sólo está disponible en la versión registrada de GM . Play a sound (Reproducir un sonido): Con esta acción puedes reproducir uno de los sonidos que se hallan añadido al juego. Puedes seleccionar alguno de los sonidos soportados para el juego, e indicar si quieres que se reproduzca una sola vez (por defecto) o indefinidamente (loop). Los archivos de sonido real (WAV, M P3, etc.) pueden reproducirse simultáneamente, pero en los M IDI, tan solo uno podrá ser reproducido a la vez. Cuando comience un M IDI, el que esté sonando en ese momento se detendrá. 33
- 34. S top a sound (Detener un sonido): Esta acción simplemente detiene el sonido que se esté reproduciendo cundo tu lo indiques en un evento durante el juego. Imagina que llegas al final de un cuarto o nivel de juego, y tienes una música de fondo reproduciéndose, pero al llegar con el jefe de nivel deseas cambiar la música de fondo por otra, pues primero tendrías que detener la música de fondo del nivel y luego iniciar con la música destinada para el jefe de ese nivel en el juego. Si hay varias instancias del sonido sonando a la vez, se pararán todas. If a sound is playing (Si un sonido se esta reproduciendo): Esta sentencia condicional reproduce un bloque de acciones si el sonido seleccionado se está reproduciendo. En caso contrario, dicho bloque se pasa por alto. Puedes seleccionar (Not) para indicar que se reproduzca el bloque si no se está reproduciendo dicho sonido, y que se pase por alto si se está reproduciendo. Por ejemplo, puedes hacer que si una música de fondo no está sonando, comience a sonar, y que si está sonando, no ocurra nada. Nota esta acción: Devuelve true (verdadero) cuando el sonido está realmente siendo tocado por los parlantes. Después de que llames esta acción para reproducir un sonido, no llega inmediatamente a los parlantes entonces la acción puede devolver false (falso) por un breve tiempo. Go to pre vious room (Ir al cuarto, o nivel de juego previo o anterior): Te mueve al cuarto anterior. Puedes indicar el efecto de transición que quieres que se reproduzca. Puedes experimentar para ver cuál es el que más te gusta. Si no hay un cuarto, o nivel de juego (Room), anterior, se producirá un error. Go to next room (Ir al siguiente cuarto, habitación o nivel de juego): Te mueve al siguiente cuarto, o nivel de juego (Room). Puedes indicar el efecto de transición. Si no existe un cuarto siguiente, se producirá un error. Restart the current room (Reiniciar el cuarto, habitación o nivel de juego actual): Se reinicia el cuarto, o nivel de juego actual. Puedes indicar el efecto de transición. Go to a different room (Ir a un cuarto diferente): Te mueve a un cuarto que selecciones, esto es útil por ejemplo si en tu juego tu colocas un bonus o ítem que al ser tomado por el jugador lo traslade a otro cuarto o nivel del juego, solo debes de indicar a que cuarto o nivel de juego tiene que ser movido el jugador. Recuerda que puedes indicar un efecto de transición, y que el cuarto o nivel de juego debe de existir o se producirá un error. If previous room exists (Si el cuarto previo existe): Sentencia condicional que comprueba que exista un cuarto o nivel de juego anterior, y si este existe reproduce un bloque de acciones. Lo lógico es poner este condicional antes de moverse a un cuarto anterior, para evitar errores. . If next room exists (Si el cuarto siguiente existe): Sentencia condicional que comprueba que exista un cuarto o nivel de juego siguiente, y rep roduce un bloque de acciones si éste existe. Lo lógico es poner este condicional antes de moverse a un cuarto siguiente para evitar errores. 17.3.- Main 2 (Pestaña Princi pal 2): Aquí están más acciones principales en la pestaña 2, las que se ocupan de los tiempos, mensajes e información al usuario, guardando y abriendo juegos. Set an alarm clock (Fijar una alarma): Con esta acción que puedes fijar una de las 12 alarmas para los objetos. Selecciona el número de tiempo de la alarma en milisegundos. Después del número indicado de milisegundos, el objeto ejecutara las acciones 34
- 35. para el evento que se encuentre Alarma. Puedes también aumentar o disminuir el valor. Si fijas la alarma a un valor menor que (<) o igual a 0 se desactivará, así que el evento no se generará. Nota: 1000 milisegundos equivalen a 1 segundo. Sleep for a while (Congelar la escena por un tiempo): Con esta acción puede congelar la escena por un tiempo. Esto se suele utilizar en el principio o el final de un nivel, o cuando se da a el jugador un mensaje. Especificas el número de milisegundos para congela o dormir (sleep) el desarrollo del juego. También puede indicar si la pantalla debe primero ser redibujada para reflejar la situación o acción más reciente. Display a message (Muestra un mensaje): Con esta acción que puedes mostrar un mensaje en una ventana de diálogo. Simplemente escribes el mensaje. Si utilizas el símbolo de número (#) en el texto del mensaje, este será interpretado como un salto para una nueva línea. Si el texto del mensaje comienza con un símbolo de comillas o doble comillas, se interpreta como expresión. Ve abajo para más información sobre expresiones. Show the game information (Muestra información sobre el juego): Con esta acción puedes abrir la ventana de información del juego, durante el juego mismo, esta acción es normalmente llevada a cabo presionando la tecla F1, pero quizás tú quieras asignar a otra tecla o a algún botón dentro de la pantalla de juego esta acción, y así dar a conocer de que se trata el juego, como se juega y que botones o teclas debe de usar el jugador. Restart the game (Restaurar el juego): Con esta acción reinicias o comienzas el juego desde el principio, esta acción la puedes colocar en un botón al final del juego para que el usuario decida si quiere iniciar una nueva en tu juego. End the Game (Terminar el Juego): Con esta acción terminas se cierra el juego, este es la otra acción que le deberías de dar al jugador una vez terminado tu juego, la puedes colocar al f inal de juego en un botón y si el jugador ya no quiere jugar tu juego en ese momento entonces salir de el; o lo puedes todo el tiempo durante el juego por si el jugador quiere salir de tu juego, pero deberás en este caso permitirle guardar el avance que ya haya obtenido en el juego, de otra forma tendría que comenzar todo de nuevo y esto podría terminar por desanimar al jugador para que siga jugando tu juego. S ave the Game (Salva / Guarda el juego): Con esta acción puedes guardar el avance actual del juego. Especificas el nombre de fichero donde guardar el juego, (el archivo, se crea en el directorio de funcionamiento del juego). Una vez que el juego ha sido guardado el jugador lo podrá cargar más adelante con la acción siguiente. (Por favor realícelo s olamente cuando el estado del juego sea básico. Las cosas que por ejemplo no se guardan son el sonido actual que se esta escuchando, y aspectos avanzados como el contenido de las estructuras de datos (data structures), y de las partículas (particles), etc). Load the game (Cargar / Abrir el juego): Carga el estado del juego desde un archivo guardado. Especificas el nombre del archivo donde estará guardado el juego. Cerciórate de que el juego guardado sea para el mismo juego y que esté creado con la misma versión de Game M aker. Si no un error ocurrirá. (Para ser exacto, el juego se carga en el final del paso del juego. Por eso algunas acciones después de la carga en el juego actual, no se llegaran a cargaran. 17.4. – Control (Pestaña Control): Existe un número de acciones con las cuales puedes controlar otras acciones que se realizan. La mayoría de estas acciones te preguntan por algo, por ejemplo si hay una posición vací a. Cuando la respuesta es sí, verdadera (true) la siguiente acción es ejecutada, si no es ignorada. Si quieres que múltiples acciones sean ejecutadas o ignoradas de acuerdo con el resultado puedes colocarlas en un bloque, poniendo un bloque de inicio y un bloque de fin alrededor de ellas. También puede haber una parte extra (else) la cual es ejecutada cuando la respuesta es no. Entonces una pregunta se ve típicamente como se presenta en el dibujo de al lado: Aquí se hace una pregunta, si una posición para la instancia del objeto actual está libre de colisiones. Si es así, la instancia empieza a moverse en la dirección dada. Si no, la instancia salta a otra posición dada. Para todas las decisiones hay un campo nombrado (NOT). Si verificas este campo, el resultado de la pregunta es invertido. Esto es, si el resultado fuera verdadero se convierte en falso y si es falso, se convierte en verdadero. Esto te permite realizar ciertas acciones cuando una pregunta no es verdadera. Para muchas preguntas puedes indicar que se deberían aplicar para todas las instancias de un objeto en particular. En este caso el resultado es verdadero solo si es verdadero para todas las instancias del objeto. Por ejemplo, puedes verificar si para todas las pelotas, la posición a la derecha esta libre de colisiones. 35
- 36. Las acciones de preguntas que están disponibles se verán a continuación. (Nota que todas ellas tienen un icono diferente y un color de fondo diferente de forma que puedan ser distinguidos de otras acciones más fácilmente). If a Position is collision free (Si la posición esta libre de colisiones / Choques): Esta acción de pregunta regresa verdadera si el objeto, o la instancia del objeto actual pueden ser colocados en una posición determinada, si no genera una colisión con otro objeto. Puedes especificar si la posición es absoluta o relativa, también puedes indicar si solo los objetos sólidos, o todos, deberán ser tomados en cuenta; esta acción es usada típicamente para comprobar si la instancia se puede mover a una posición en particular. If a position is a collision at a position (si hay una colisión en la posición): Esta acción es la contraria a la anterior, regresa verdadero si hay una colisión cuando la instancia del objeto actual es colocada en una posición determinada (de nuevo, tanto para objetos sólidos, o para todos los objetos). If there is an object at a position (Si hay un objeto en esta posición): Esta acción da verdadero si la instancia colocada en una posición indicada, se encuentra con una instancia del objeto indicado. If the number of instancias is a value (Si el número de instancias es o da un valor): Especificas un objeto y un número, si el número actual de instancias del objeto es igual al número, la pregunta devuelve verdadero; de otra forma es falso. También puedes indicar que la comprobación debería ser si el número de instancias es mayor que (>) o menor que (<) a el valor dado. Esto es comúnmente usado para terminar con el nivel del juego o con el juego. With a change perform next action (Realiza la siguiente acción con una probabilidad): Especificas el número de lados de un dado el cual es lanzado después, si el dado cae en uno, el resultado es verdadero y la siguiente acción es ejecutada. Esto puede ser usado para poner un elemento al azar en tu juego. Por ejemplo, en cada paso de juego puedes generar con una probabilidad particular una bomba o un cambio de dirección. M ientras el número de lados del dado sea mayor, hay menos probabilidad de un cambio al azar; de hecho puedes usar números reales. Por ejemplo si estableces el número de dados a 1.5 la acción siguiente es realizada 2 de cada 3 veces. Usar un número menor que 1 no tiene sentido. If the user answer yes to a question (Si el usuario responde si a una pregunta): Con esta acción especificas una pregunta al jugador, una caja de dialogo es mostrada entonces al jugador con dos botones de si o no. El resultado es verdadero si el jugador responde si. (Esta pregunta siempre da como resultado si). If an expresión is true (Si una expresión es verdadera): Esta es la acción de pregunta más general, puedes ingresar una expresión arbitraria, si la expresión se considera como verdadera (esto es, un número mayor o igual a 0.5) la siguiente acción es realizada. Ve capítulos más adelante para más información sobre las expresiones. If a Mouse button is pressed (Si un botón del ratón es presionado): Devuelve verdadero si el botón indicado del ratón esta presionado, un uso estándar es en el evento paso; puedes comprobar si un botón a sido presionado y si lo esta, activar la siguiente acción, por ejemplo moverse a una posición (usa esta acción para moverte o saltar a un punto con valores M ouse_x y M ouse_y). If instante is alingned with gris (Si la instancia esta alineada con una rejilla, o cuadricula) Devuelve verdadero si la posición de la instancia concuerda en una cuadricula, especificas el espacio vertical y horizontal de la cuadricula; esto es muy útil cuando se crean acciones, como por ejemplo haciendo un giro o una rotación, estas serán solo permitidas cuando la instancia este alineada a la posición de la cuadricula. 36
- 37. S tar of block (Inicio de bloque): Indica el inicio de un bloque de acciones, como se vio en la imagen de arriba donde se realiza una pregunta. End of block (Fin de un boque): Indica el final de un bloque de acciones. Else (En otro caso, de lo contrario). Nota la palabra Else se podría traducir como lo que se encuentra encerrado entre paréntesis. Pero al parecer no tiene una traducción. Realiza la acción o acciones que esta después del else, y es ejecutado cuando el primer resultado es falso. Repet next action (Repetir la acción siguiente): Esta acción es usada para repetir la acción (o bloques de acciones) que sigue un número determinado de veces, simplemente especificas el número a realizar la o las repeticiones y estas se llevaran acabo. Exit the curret event (Salir del evento actual): Cuando se encuentra esta acción no se ejecuta ninguna de las otras acciones en el evento. Esto es típicamente utilizado en una pregunta, por ejemplo, cuando una posición esta libre no es necesario hacer nada así que salimos del evento; en este ejemplo, las acciones solo son ejecutadas cuando hay una colisión. Si quieres más control sobre lo que esta pasando en el juego puedes utilizar El lenguaje de programación del Game M aker, que se describe más adelante. Execute a piece of code (ejecutar una pieza de código): Cuando agregas esta acción, un formulario es mostrado en el puedes escribir una pieza de código que se debe de ejecutar, esta acción puede contener llamadas a funciones o a un código más complejo, usa esta acción preferiblemente para piezas pequeñas de código; para piezas más grandes usa mejor los Scripts los cuales se describirán más adelante. Comment (Comentario): Usa esta acción para agregar una línea de un comentario a la lista de acciones. La línea se muestra en una fuente cursiva. Agregar comentarios a tus acciones te ayuda a recordar que están realizando tus acciones, dentro de los eventos. La acción del comentario no hace nada, durante el proceso de juego; solo te sirve a ti mientras desarrollas tú juego, para no perder la idea o lógica del juego. Set the value of a variable (Establecer el valor de una variable): Hay muchas variables incorporadas en el juego, con esta acción puedes cambiarlas. También puedes crear tus propias variables y asignarles sus respectivos valores. Especificas el nombre de la variable y el nuevo valor. Cuando verificas la caja ( Relative), el valor será agregado al valor actual de la variable. Por favor nota que esto solo puede ser hecho si la variable tiene un valor asignado. Ve más adelante para más información sobre variables. If a variable has a value (Si una variable tiene un valor): Con esta acción puedes comprobar cual es el valor de una variable. Si el valor de la variable es igual al número dado, le pregunta regresa verdadero y la acción es ejecutada. De otra forma regresa falso. También puedes indicar que la verificación debería ser si el valor es menor o mayor que el valor dado. (Ve más adelante para más información sobre variables). De hecho, puedes usar esta acción para comparar dos expresiones. Draw the value of a variable (Mostrar el valor de una variable): Con esta acción puedes mostrar el valor de una variable en una posición particular en la pantalla. Date cuenta de que esto sólo puede ser usado en el evento draw (de dibujo) de un objeto que normalmente sería un controlador, piensa que con esto podrías mandar ciertos mensajes al jugador, mostrando el valor de la variable dentro del cuarto o nivel del juego. 17.5.- Score (Pestaña de Puntuación): En la mayoría de los juegos el jugador o los jugadores tienen una puntuación. También suelen tener un número determinado de vidas. Para terminar, se suele tener también una cierta cantidad de energía. Las siguientes acciones facilitan el trabajo para conseguir todo esto. 37
- 38. Set the S tore (Poner la puntuación): Game M aker tiene un sistema de puntuación interno. La puntuación suele mostrarse en el marco de la ventana del juego. Esta acción te sirve para cambiar la puntuación. Simplemente debes introducir un valor de puntuación que será tomado cada que ocurra un evento de colisión. En caso de que quieras que la puntuación aumente o disminuya con el valor establecido, escribe dicho valor y marca la casilla (Relative). If store has a value (Si la puntuación alcanza un valor): Con esta acción pedes comprobar si la puntuación es igual (=), mayor (>) o menor (<), que a un valor dado. Debes indicar el valor con el que quieres comparar la puntuación, y el método de comparación (igual, mayor o menor), esto te puede servir por ejemplo, para agregar vidas extras al jugador si alcanza una puntuación en particular dentro del juego. Draw the value of score (Dibuja el valor de la puntuación en): Con esta acción puedes hacer que el Game M aker dibuje un texto con la puntuación en una posición del cuarto, o nivel del juego. Debes dar la posición donde quieres que se dibuje, y ahí mismo se dibujará. La fuente o tipo de letra (font) dependerá de la fuente o tipo de letra establecida anteriormente. Esta acción solo puede usarse en el evento draw. Nota no marques la casilla relative, sino, no se vera la puntuación donde tu quieres. Display the highscore table (Muestra la tabla de altas puntuaciones): En cada juego, existe una tabla de record, donde se guardan las mejores puntuaciones aún que cierres el juego. Esta acción muestra dicha tabla. Si la puntuación actual está dentro de las altas puntuaciones, se permite la inserción de un nombre para la puntuación. Puedes indicar el fondo de la lista de fondos (background), si la ventana lleva o no un borde, Cual es el color de la nueva entrada y las viejas entradas, y la fuente o tipo de letra de dichas entradas (La fuente o tipo de letra dependerá de la fuente establecida anteriormente). Clear the higscore table (Limpiar / borrar las puntuaciones en la tabla de puntuaciones): Esta acción borra la puntuación de la tabla de record. Set the number of lives (Fijar el número de vidas): Game M aker tiene también un sistema interno de vidas. Con esta acción puedes cambiar el número de vidas que tendrá el jugador en el juego. Normalmente suele establecerse a 3 al comienzo, e ir restándose o sumándose vidas según lo que vaya ocurriendo. No te olvides de activar la casilla (Relative) si lo que quieres es aumentar o disminuir el número de vidas. En el momento que las vidas sean 0 o menor (<) que 0, se activará el evento (event) no más vidas (No more lives). If lives is a value (Si el número de vidas es igual a un valor): Con esta acción puedes comprobar si el número de las vidas han llegado a un cierto valor. Debes indicar el valor que quieres comprobar, y si pretendes comprobar que las vidas sean iguales (=), mayores (>) o menores (<) a dicho valor. Draw the number of lives (Dibujar el número de vidas): Con esta acción puedes mostrar el número de vidas en una posición del cuarto o nivel del juego. Debes dar la posición donde quieres que se dibuje, y ahí mismo se dibujará, también debes dar un titulo que se colocara antes del número de vidas. La fuente o tipo de letra (font) dependerá de la fuente establecida anteriormente. Esta acción solo puede usarse en el evento draw. Draw the lives as image (Dibuja el número de vidas con imágenes): En lugar de indicar el número de vidas con un número, a veces resulta ser mejor usar una imagen. Con esta acción puedes dibujar un número de pequeñas imágenes igual a la cantidad del número de vidas. Debes especificar la posición y la imagen y esta se dibujara automáticamente en la posición indicada con la imagen asignada (Se te recomienda crear una imagen muy pequeña para esto). Esta acción solo puede usarse en el evento draw. Set the health (Fijar el nivel de energía): El Game M aker tiene también un sistema interno de energía. Puedes usar esta acción para cambiar la cantidad de energía. La energía está representada en porcentaje, es decir, un valor de 100 se considera la energía total, y un 0 nada de energía. Simplemente debes introducir un valor para la energía. Si pretendes restar o sumar un valor a la energía no te olvides de marcar la casilla (Relative). Cuando la energía llega a 0 se activa el evento sin energía (Out of health). If the health is a value (Si la energía es igual a): Con esta acción puedes comprobar si la energía tiene un cierto valor. Debes indicar el valor que quieres comprobar, y si pretendes comprobar que la energía es igual (=), mayor (>) o menor (<) a dicho valor. Draw the health bar (Dibujar la barra de energía): Con esta acción puedes dibujar una barra que representará la energía. Cuando la energía esta en 100 la barra está completamente llena, y cuando esta en 0, vacía. Debes indicar la posición y tamaño de la barra estableciendo dos coordenadas “X” y “Y”, así como el color de la barra y de su fondo. 38
- 39. Set the window caption information (Fijar la información de la ventana): Normalmente, junto al titulo de la venta se muestra la puntuación y el nombre del cuarto o nivel del juego. Con esta acción puedes quitarlos o cambiarlos. Debes indicar si quieres que se muestre el nombre, la puntuación, la energía o las vidas; esto es muy útil si no quieres que se vea nada de esto en el titulo de la ventana del juego, porque tú tal vez quieres dibujarlo en otro lado dentro del cuarto, o nivel del juego. 17.6.- Draw (Pestaña de Di bujo): Las acciones de Dibujo solo tienen efecto en los eventos de dibujo; en otros eventos básicamente son ignoradas, por favor recuerda que el dibujar otras cosas además de las imágenes (sprites) y fondos (backgrounds) puede hacer relativamente lento el desarrollo del juego, así que usa estos eventos cuando los consideres estrictamente necesario para tus juegos. Draw a sprite image (Dibujar una imagen): Especificas la imagen (sprite), la posición (absoluta o relativa a la posición actual del objeto) y la subimagen del sprite. (Las subimágenes se numeran a partir de 0) Si deseas dibujar la subimagen actual, utiliza el número -1. Draw a background image (Dibuja una imagen de fondo): Indicas la imagen de fondo, la posición (absoluta o relativa) y si la imagen debe cubrir todo el cuarto, o nivel de juego o solo debe de hacer en ciertas coordenadas. Draw a text (Dibujar –Escribir- un texto): Con esta acción especificas el texto y la posición donde debe de ser mostrado en el cuarto o nivel de juego. El símbolo de número (#) dentro del texto se interpreta como una nueva línea. Puedes crear textos multilínea. Si el texto comienza con comillas simples o dobles, se interpreta como expresión. Por ejemplo, puedes utilizar „x: „ + string(X) para exhibir el valor de la coordenada x del objeto. (X es una variable que almacena la coordenada X del objeto actual. La función string() convierte el número en una (cadena) string, y (+) combina / une las dos sentencias). Draw a rectangle (Dibuja un rectángulo o cuadrado): Especificas las coordenadas de las dos esquinas opuestas del rectángulo; absoluta o relativa a la posición actual del objeto y hay será dibujado un cuadrado o rectángulo. Draw a horizontal gradient (Dibuja un rectángulo con un color degradado en forma horizontal): Esta acción también dibuja un rectángulo pero esta vez usando color degradado que cambia de izquierda a derecha. Especificas el rectángulo y los dos colores para utilizarlo. Esta acción está solamente disponible en la versión registrada. Draw a vertical gradient (Dibuja un rectángulo con un color degradado en forma vertical): Esta acción también dibuja un rectángulo pero esta vez usando color degradado que cambia de la parte superior a la inferior. Especificas el rectángulo y los dos colores para utilizar. Esta acción está solamente disponible en la versión registrada. Draw an ellipse (Dibuja un eclipse o círculo): Esta acción dibuja una elipse o circulo. Especificas las coordenadas de las dos esquinas opuestas del rectángulo circundante; en forma absoluta o relativa a la posición actual del objeto. Draw a gradient ellipse (Dibuja un círculo con un color degradado): Se dibuja otra vez una elipse pero esta vez especificas un color para el centro y otro para el límite. Esta acción está solamente disponible en la versión registrada. Draw a line (Dibuja una línea): Especificas las coordenadas de los dos extremos de la línea; absoluta o relativa a la posición actual del objeto, con esta acción puedes ir dibujando una línea atrás del objeto por ejemplo. 39
- 40. Draw an arrow (Dibuja una flecha): Especificas las coordenadas de los dos extremos de la línea y el tamaño de la extremidad de la flecha. Set the colors (Fija los colores): Con esta acción seleccionas el color utilizado para las formas, las líneas, y el texto de dibujado. (No influencia en las imágenes (sprites) y los fondos (backgrounds) dibujados). Change fullscreen mode (Cambia a pantalla completa): Con esta acción puedes cambiar el modo de la pantalla si la quieres ver completa (cubriendo toda el área del monitor) o no. Puedes indicar si se activa la acción fullscreen (pantalla completa) o si se debe volver a modo de ventana preestablecido. Take a snapshot image of the game (Tomar una imagen del juego): Con esta acción puedes tomar una imagen del juego y almacenarla en un archivo bmp. Especificas el nombre del fichero donde se debe de almacenar la imagen. Esta acción está solamente disponible en la versión registrada. Create an effect (Crear un efecto): Con esta acción puedes crear todo tipo de efectos de una manera muy sencilla. Puedes especificar el tipo de efecto, como una explosión, humo, etc. su posición, su tamaño y su color. El resto será automático. (Para nieve y lluvia la posición es irrelevante, ya que siempre caerá del borde superior de la pantalla. En este caso deberás ejecutar esta acción en le evento paso del juego (step)). Esta acción está solamente disponible en la versión registrada del Game M aker. 17.7.- Usando Expresiones y Vari ables: En muchas acciones necesitaras proporcionar los valores para algunos parámetros. Puedes escribir un número o una palabra, y también puedes escribir una fórmula, por ejemplo: 32*12. Pero también puedes escribir expresiones realmente mucho más complicadas. Por ejemplo, si desea duplicar la velocidad horizontal, podrías establecerla de la siguiente forma 2*hspeed. Aquí hspeed es una variable que indicaba la velocidad horizontal actual del objeto. Hay una gran cantidad de otras variables que puedes utilizar. Las cuales se verán más adelante pero por ahora veremos las más importantes: x: La coordenada x del objeto y: La coordenada y del objeto hspeed: La velocidad horizontal (en píxeles por paso) vspeed: La velocidad vertical (en píxeles por paso) direction: La dirección actual de movimiento en grados (0-360) speed: La velocidad en esa dirección visible: Si el objeto es visible es (1), pero si es invisible es (0) image_index: Esta variable indica que subimagen de la imagen (sprite) actual se muestra actualmente. Si tú la cambias y la fijas la velocidad a 0 entonces se mostrara una sub-imagen fija. image_speed: Esta variable indica la velocidad con la cual se muestran las subimágenes de la imagen (sprite). El valor prefijado es 1. Si pones ese valor mayor a 1 algunas subimagen se saltan para hacer la animación más rápida. Si lo haces más pequeño que 1 la animación se hace más lenta porque repite subimagen. S core: El valor actual de sistema de puntuación interna del Game M aker. Lives: El valor actual del sistema de vidas interno del Game M aker. health: La energía actual que esta entre los valores 0 a 100. mouse_x: La posición (X) del M ouse. mouse_y: La posición (Y) del M ouse Puedes cambiar la mayoría de estas variables usando la acción de la variable del sistema. También puedes definir tus propias variables fijándolas o asignándolas a un valor. Entonces puedes utilizar estas variables en expresiones. Las variables que creas son locales a la instancia del objeto actual. Es decir, cada objeto tiene su propia copia de ellas. Para crear una variable global, pon la palabra global y un punto delante de ella. Por ejemplo global.pelota haría referencia a todos los objetos de las pelotas en un juego. Puedes también referirte a los valores de las variables para otros objetos poniendo el nombre del objeto y un punto delante de ellos. Por ejemplo, si quisieras que una bala se trasladara al lugar donde está una moneda podrías fijar la posición con esta instrucción (moneda.x, moneda.y). En el caso de un acontecimiento de colisión puedes referirte a la coordenada x del otro objeto como other.x. En expresiones condiciones puedes utilizar comparaciones como (<) menor que, o mayor que (>), etc. En tus expresiones puedes también utilizar funciones. Por ejemplo, la función random (10) da un número verdadero al azar de forma aleatoria debajo de 10. Puedes fijar por ejemplo la velocidad o la dirección del movimiento a un valor al azar. Existen muchas más funciones, que están explicadas más adelante en siguientes capítulos. 40
- 41. 18.- Creando los Cuartos o Niveles del juego: Los cuartos o niveles de juego (Rooms en inglés) son los lugares donde el juego transcurre. Todo juego necesita obligatoriamente por lo menos un nivel, o puede contener muchos de estos dependiendo el tipo de juego que se este haciendo, cada uno cuenta con un fondo que puede ser desde un simple color, o una imagen diseñada previamente, para este fin. Ahora que has aprendido como definir los objetos con su comportamiento en forma de eventos y acciones, es hora de crear los cuartos, o niveles de juego, en los que se llevara acabo el juego. Cualquier juego requerirá al menos un cuarto, o nivel de juego, como ya se menciono. En estos cuartos, o niveles de juego (rooms) colocamos las instancias de los objetos. Una vez que el juego inicia se muestra el primer cuarto, o nivel de juego y las instancias de los objetos en él toman vida por las acciones programadas o definidas en sus eventos de creación. Hay un gran número de posibilidades al crear cuartos, o niveles de juego. Además de establecer ciertas propiedades y agregar las instancias de los objetos puedes agregar fondos (backgrounds), definir vistas (views), y agregar mosaicos o azulejos (tiles). Estas opciones se discuten más adelante, en este capítulo solamente discutiremos las opciones básicas, el agregar instancias de objetos y la configuración de las imágenes de fondo (background). Para crear un cuarto o nivel de juego, selecciona Add Room en el menu Add. Se muestra la siguiente ventana: A la izquierda veras tres pestañas (cinco en modo avanzado). A la derecha en la ventana de diseño puedes ver el cuarto. Al principio está vacío, con un fondo gris y una cuadricula (grid). La solapa objetos (Objects) es donde agregamos las instancias de los objetos que van a participar y existir en ese nivel. La solapa opciones (Settings) es donde podemos cambiar los datos generales del nivel (nombre, tamaño, etc.). La solapa fondos (backgrounds) en la que podemos cambiar la imagen de fondo que va a tener el nivel. Por supuesto que al dar clic en cada solapa la apariencia de la ventana cambia para mostrar diferentes datos; en la de objetos (Objects) la opción fundamental es la de agregar estos objetos. Basta con hacer clic en el sitio indicado para que se muestre una lista con los objetos existentes (¡por eso hay que definirlos antes!) Con su imagen (sprite) asociado a la izquierda. 18.1.- Configuración del cuarto o ni vel de juego: Cada cuarto tiene ciertas opciones que puedes cambiar haciendo clic en la pestaña opciones (settings). Sólo trataremos las más importantes aquí. Cada cuarto tiene un nombre, mejor dale uno con sentido. También hay un título. Este título se muestra en la ventana cuando se ejecuta el juego. Puedes establecer el ancho y alto del cuarto (en píxeles). También puedes configurar la velocidad del juego. Este es el número de pasos por segundo. Entre más velocidad, más suave será el movimiento. Pero necesitarás una computadora más rápida para ejecutarlo. En la parte superior de la pestaña opciones (settings) puedes indicar el tamaño de las celdas de la cuadrícula usada para alinear los objetos. Al hacer clic en el botón Show puedes indicar si por ejemplo. Se deben de mostrar las líneas de la cuadrícula. 18.2.- Estableciendo el fondo: Con la pestaña backgrounds puedes establecer la imagen de fondo para el cuarto. De hecho, puedes indicar varios fondos. La pestaña se ve como sigue: En la parte superior se ve el color de fondo. Puedes hacer clic sobre este para cambiarlo. El color de fondo sólo es útil si no usas una imagen de fondo que cubra todo el cuarto. De otra forma, mejor inhabilita la opción Draw background color ya que significaría una pérdida de memoria. Abajo puedes ver una lista de 8 fondos. Puedes definir cada uno de ellos pero la mayoría de las veces sólo necesitaras uno o dos. Para definir un fondo, primero selecciona uno en la lista. A continuación marca la opción Visible when room starts o de otra forma no lo verás. El nombre del fondo se pondrá en negritas cuando esté 41
- 42. definido. Ahora indica una imagen de fondo haciendo clic en el botón con icono de un menú, junto a donde dice (no background). Hay ciertas opciones que puedes cambiar. Primero que nada puedes indicar si la imagen de fondo se repetirá horizontal y/o verticalmente. Puedes también indicar la posición del fondo en el cuarto (esto también influirá la cobertura). Finalmente puedes hacer que el fondo se desplace dándole una velocidad horizontal o vertical en píxeles por paso. Hay una opción más llamada Foreground image. Cuando la activas, el fondo se colocará en primer plano, y se dibujará al frente de todo en lugar de detrás de todo. Obviamente una imagen de este tipo deberá ser parcialmente transparente para que tenga alguna utilidad. 18.3.- Agregando las instancias de los objetos: Luego de haber elegido el objeto que vamos a agregar hacemos clic en el lugar donde queremos que aparezca esa instancia del objeto; podemos poner todas las instancias que queramos y todas se van a comportar como lo hemos programado para el objeto que da origen a las instancias de los objetos. Para eliminar una instancia de objeto que pusimos o colocamos mal; simplemente da clic derecho con el M ouse sobre la instancia del objeto que quieras eliminar. Para agregar instancias al cuarto, primero selecciona la ficha objects si no está visible. A continuación selecciona el objeto que deseas agregar haciendo clic en el botón con icono de un menú (o haciendo clic izquierdo en el área de imagen a la izquierda). La imagen del objeto aparecerá en dicha ventana. (Nota que hay una cruz en la imagen en la zona superior izquierda. Esta indica cómo se alinearan las instancias con la cuadrícula). Ahora haz clic con el botón izquierdo del ratón en el área a la derecha. Aparece una instancia del objeto. Éste se alineará a la cuadrícula indicada. (Puedes cambiar la cuadrícula en las opciones; -ve arriba-. Si mantienes presionada la tecla (Alt) mientras colocas la instancia no se alineará a la cuadrícula). Con el botón derecho del ratón puedes borrar las instancias de los objetos que te hayan quedado mal. De esta manera es como vas definiendo el contenido del cuarto. Si mantienes presionado el botón del ratón y la tecla (Shift o M ayúsculas) mientras lo arrastras sobre el cuarto, o nivel de juego (room) colocarás o eliminarás varias instancias. Como te darás cuenta, si colocas una instancia sobre otra, la primera desaparece. Normalmente será lo que desees, pero no siempre. Esto puede evitarse al deshabilitar la opción Delete underlying a la izquierda. Hay tres acciones que puedes realizar usando el botón derecho del ratón: cuando mantienes presionada la tecla (Ctrl.) mientras haces clic sobre una instancia con el botón derecho, la instancia al fondo en esa posición será traída al frente. M antener presionada la tecla (Alt) enviará al fondo la instancia que se encuentre al frente. Esto puede emplearse para cambiar las instancias sobrepuestas. Finalmente, al mantener presionada la tecla (Shift) mientras haces clic con el botón derecho eliminará todas las instancias en esa posición, no sólo las del frente, ten cuidado. Hay cuatro útiles botones en la ficha a la izquierda cuando se trabaja en modo avanzado y pienso que es bueno que los vayas conociendo. Cuando presionas el botón Clear se borrarán todas las instancias del cuarto. Cuando presionas el botón S hift puedes mover a todas las instancias cierto número de píxeles. Usa valores negativos para moverlas hacia la izquierda o hacia arriba, y positivos para moverlos a la derecha o abajo. Esto es útil cuando decidiste por ejemplo agrandar el cuarto. (También puedes usar esto para colocar instancias fuera del cuarto, lo cual es útil en ciertas ocasiones). Finalmente hay dos botones para ordenar las instancias por la coordenada “X” o la coordenada “Y”. Esto es útil cuando se colocan instancias que se sobreponen parcialmente. 19.-Realizando un sencillo e jemplo de juego: (pendiente) Una vez que ya has visto y conoces un poco de como se agregan las imágenes, los sonidos, los fondos de los cuartos, y los objetos seria bueno hacer un pequeño y simple ejemplo, asumiendo que se hace funcionar el Game M aker en modo simple (Si esta en modo avanzado no importa también se puede realizar el ejercicio). El primer paso es describir el juego que se desea hacer, y desarrollar el documento de diseño. (Recuerda que aún que no es obligado debes de realizar siempre esto ya que te ahorrara mucho tiempo, más adelante). Como este va a ser nuestro primer juego, será mejor diseñar algo simple que mantendrá al jugador entretenido por un rato. Nuestra primera creación va a ser un pequeño juego de acción que llamaremos, por ejemplo, Caza al Payaso, procura siempre, darle a tus juegos nombres ocurrentes y llamativos que capten la atención de los jugadores. Esta es la descripción del juego: 42
- 43. 19.1.-La i dea global del jueg o Caza al payaso: Caza al payaso es un pequeño juego de acción. En este juego el payaso se mueve a través de la pantalla. El objetivo del jugador consiste en atrapar al payaso haciendo clic sobre el. Si el jugador progresa en el juego, el payaso comenzara a moverse a mas velocidad y será mas difícil capturarlo, por cada captura, la puntuación se vera incrementada. El objetivo del juego será conseguir la mayor puntuación posible. Obviamente un juego como este tendrá una apariencia un tanto limitada. Pero debes recordar que para hacer juegos complejos en primer lugar, debemos de familiarizarnos con el programa y sus funciones haciendo juegos simples, esto no quiere decir que dichos juegos no sean entretenidos y adictivos a la par. Recuerda que es mejor ir avanzando poco a poco, y ponerse metas que uno pueda llegar a alcanzar, de lo contrario la desilusión por nuestro fracaso puede ser muy frustrante. 19.2.-El documento de diseño: El segundo paso de la creación de un juego es escribir un documento de diseño mas preciso, en este incluiremos todos y cada uno de los detalles de nuestro juego. Te recomendamos que lo hagas siempre antes de hacer tu juego, por muy simple que este sea. Aquí se te enseñara ha hacer dos tipos de documento de diseño para Caza al Payaso (Ha sido omitida la descripción ya escrita arriba). La primera versión: Objetos del juego: Deberán de existir dos objetos: el Payaso y la pared. El objeto pared tiene un cuadrado como imagen. La pared que define el área de juego esta compuesta por muchos de estos objetos, el objeto pared no hace nada. Solo se coloca allí para evitar la salida del payaso del área de juego. El objeto payaso tiene una imagen con la cara de un payaso que se mueve a una velocidad programada o establecida, siempre que colisione con una pared este rebota y reproducirá un sonido y así sucesivamente. Cuando el jugador de clic sobre el payaso, se reproducirá un segundo sonido y la puntuación aumentara en 10 puntos. Tras ser atrapado el payaso se moverá a un lugar aleatorio dentro del cuarto o nivel del juego y su velocidad es incrementada ligeramente. S onidos: Usaremos dos sonidos en el juego. Un sonido de rebote que emplearemos cuando el payaso golpee en una pared y un sonido para cuando pulsemos sobre el payaso. Controles: El único control que tiene el jugador es el ratón., y ha de pulsar con el botón izquierdo sobre el payaso para cazarlo e ir así, incrementando su puntuación. Flujo del juego: Al comenzar el juego la puntuación es de 0. Se muestra la pantalla con el payaso moviéndose, el juego comienza de inmediato. Cuando el jugador puls e la tecla <ESC> en cualquier momento, el juego termina. Niveles: Solo hay un nivel. La dificultad del juego aumenta con el incremento de la velocidad del payaso. La segunda versión, la mía aquí le he agregado las imágenes que representan los eventos y las acciones para que te vayas familiarizando, normalmente no hago esto pero creo que en este manual te puede ser útil, para una mayor comprensión: El objeto pared solo se colocara cubriendo gran parte del cuarto, tanto para evitar que salga el payaso, y encuentre alguno que otro obstaculó, mientras se desplaza por el cuarto. No tendra eventos ni Acciones. Para el Objeto: Evento: Lo que quieres que haga, Acción: Lo que debe de suceder al activarse el o realice. evento. Pared No hay eventos a programar. No hay acciones a programar. El objeto payaso se movera con una velocidad establecida, en la acción de movimiento, cada que choque o colisione con un objeto pared, rebotara, cambiando su dirección, y reproducira el sonido especificado. Cuando el jugador atrape al payaso dando clic en la imagen, se agregara cierta puntuación a la puntuación del juego, se reproducira el sonido especificado, el payaso se movera en otra dirección, y aumentara su velocidad. Para el Objeto: Evento: Lo que quieres que haga, Acción: Lo que debe de suceder al activarse el o realice. evento. Payaso Crear Iniciar un movimiento al azar. Collision pared Rebotar en otra dirección y , Al chocar con la pared Reproducir el sonido de rebote. 43
- 44. M ouse left Agregar puntuación, pressed Al presionar el botón izquierdo del cambiar dirección, ratón sobre el payaso. reproducir el sonido de que ha sido atrapado, Y aumentar la velocidad. Controles a usar: Como control se usara el M ouse de la computadora, el botón que será programada para atrap ar al payaso será el botón izquierdo del M ouse. El Flujo del juego: El juego comenzara con una puntuación de cero y cada que se atrape al payaso el valor se incrementara en 10 puntos, en cualquier momento que el jugador pulse la tecla Esc. o de clic sobre la X de la ventana, terminara el juego de forma inmediata. La dificultad del juego aumenta con forme se vaya atrapando al payaso, con un incremento de velocidad, establecido para el payaso. Niveles de juego: Solo habrá un cuarto o nivel de juego, con un fondo en color gris, y las orillas rodeadas del objeto pared, para este ejemplo. Usa la versión que más te acomode o crea una propia. La creación de juegos con el Game M aker puede verse muy beneficiada si tenemos un criterio riguroso y metódico que aplicar; este criterio se puede traducir en la práctica en el seguimiento de una lista de pasos. Por supuesto que esto no es en absoluto una obligación, simplemente pretende ser una guía para mejorar nuestra elaboración de juegos. 19.3.- El orden de creación: Es conviene seguir un orden de creación al realizar un programa y en nuestro caso el juego, es un programa. Aún que no es obligatorio seguir el que aquí se presenta, tú puedes decidir tu orden para crear tus juegos, este es solo un ejemplo, suponiendo que ya tienes bien planeado tu juego, y ya lo describiste y creaste el documento de diseño entonces es hora de definir y elegir: 1) Las imágenes que se van a usar. 2) Los fondos. 3) Los sonidos. 4) Los objetos que tomaran su representación grafica de los sprites, y aquellos que no lo harán, los que serán visible y aquellos que no lo serán (más adelante se vera que resulta útil no hacer visibles algunos objetos). 5) Los eventos para cada objeto, si los lleva o no los lleva. 6) Las acciones para cada e vento. 7) El/los cuarto (s), o nivel (es) del juego (rooms). Es importante destacar que, para poder seguir los pasos antes dichos, debemos tener el juego muy bien pensado. No podemos definir los sonidos, por ejemplo, sino sabemos qué es lo que va a pasar cuando una nave choque contra una roca: ¿pierde energía o es destruida? Lo mismo podemos decir de las imágenes ¿voy a tener una nave que lucha contra otra (dos imágenes –sprites-) o voy a luchar contra diferentes tipos de naves, cada vez más difíciles? (varios sprites). De cualquier manera, siempre, siempre, debemos primero pensar el juego antes de empezar a trabajar en él, pues el tiempo que nos lleve pensar esto, nos ahora trabajo al programar y realizar el juego. Continuemos bien con nuestro proyecto de juego: Como el documento de diseño describe, necesitaremos 2 imágenes (S prites) para los objetos de nuestro juego. Recuerda que para hacer los S prites puedes emplear cualquier programa de dibujo que quieras, como por ejemplo el Paint que incluye Windows, o si deseas algo un programa más profesional de dibujo, puedes conseguir el GIMP, o el Pain.Net los cuales son Gratis, y no les piden mucho a las versiones por las que tienes que pagar. O puedes usar el que viene incorporado con el Game Maker el cual es un programa de dibujo muy sencillo pero útil para este propósito. Crear S prites bien definidos es un arte que requiere mucha practica pero por fortuna hay extensas colecciones de imágenes gratuitas en Internet, no obstante se te invita a que hagas tus propios S prites. Para nuestro primer juego utilizaremos dos S prites de la colección que por defecto (Están incluidos en la carpeta de resources que se incluyen en el Game M aker). El Payaso, y la Pared . 44
- 45. 19.4.- Comenzando a trabajar con el Game Maker y con nuestro ejempl o: Damos doble clic sobre el icono se creo del Game M aker en nuestro escritorio. Al iniciar el Game M aker nos mostrara esta ventana: Nota: Si arrancas Game Maker en modo avanzado, aparecen muchas más funciones y mucha más información, pero no la necesitamos para nuestro juego sencillo. Para añadir los sprites a nuestro juego pulsamos desde el menú etiquetado Add y seleccionamos Add S prite. Así nos aparecerá el formulario o ventana de la izquierda. Presiona el botón etiquetado Load S prite y selecciona el archivo que contiene la imagen del payaso y da clic en abrir. (Puedes encontrarlo en la carpeta resources dentro de la carpeta example.) El S prite se mostrara en el formulario. Rellena el campo Name para dar al S prite un nombre, como por ejemplo spr_payaso (yo personalmente siempre pongo en todos los S prites spr_ al inicio para reconocer que son nombres de sprites), pero tu puedes utilizar tu propio método y tal vez solo le pongas payaso, o lo que se te ocurra. Utilizar convenciones en los nombres es muy práctico. Observa que la propiedad Transparent esta seleccionada. Esto indica que el color de fondo del S prite actualmente será transparente (o sea que podrás ver el fondo a través de el). Y generalmente querrás que tus sprites tengan un fondo transparente. Presiona el botón OK y el S prite será añadido, a continuación realiza los mismos pasos y selecciona el S prite del muro, llámalo spr_muro, por ejemplo. En la derecha de la ventada del Game Maker en el árbol de recursos aparecerán los nombres de los dos sprites, y una pequeña imagen representándolos. 45
- 46. Aquí podrás buscar siempre todos los sprites, sonidos, objetos... que hayas creado o cargado. Después haremos los demás recursos del juego. Ahora puedes seleccionar los recursos haciendo doble clic en el nombre. Y ahora puedes usar el menú Edit para cambiar el recurso, duplicarlo, borrarlo etc, etc. Si das clic con el botón derecho del ratón aparecerá el mismo menú, que aparece al dar clic en Add. Estos recursos pueden ser cruciales si haces un juego mas complicado, pero de momento no es necesario usarlo. Después de añadir los S prites, añadimos los dos sonidos (S ounds). Uno para cuando el payaso colisiona contra el muro, y el otro cuando le cogemos con el ratón. Los archivos en formato .wav son excelentes para sonidos cortos de efectos, como es el caso. Unos cuantos de estos efectos vienen con la instalación del Game Maker y otros muchos se encuentran por la red. Para añadir el primer sonido para el juego, elige Add S ound del Add menú. Con lo que aparece la ventana a la izquierda, si estas usando el Game M aker en modo simple, de otra forma te aparecerá una ventana más completa, y con más opciones. Nombramos el sonido, por ejemplo, snd_rebote, repite los pasos para el sonido donde se atrapa el payaso. Teniendo añadidos las imágenes y los sonidos al juego, no quiere decir que esto ya haya acabado y el juego se desarrolle por su cuenta. Los S prites son solo imágenes para los objetos, y nosotros todavía no hemos definido ninguno. De manera similar, los sonidos solo se escucharan si nosotros les decimos que se reproduzcan. Entonces debemos definir 2 objetos. Pero antes de que hagamos esto, tendrás que entender la manera en que Game Maker y la mayoría de los programas para el desarrollo de juegos funcionan así. Como indicamos anteriormente, en el juego hay cierto numero de objetos, en un juego, por muy simple que sea siempre ha de haber cuanto menos un objeto y un S prite. Durante el desarrollo del juego, 1 o más "instancias" de esos objetos se presentaran en el juego. Ten en cuenta que puede haber múltiples instancias de un mismo objeto. Como se puede apreciar en el ejemplo de: Caza al Payaso, hay muchas instancias del objeto "pared" que delimitan el campo, y solo habrá 1 instancia del objeto "payaso". Las instancias de los objetos, no harán nada, al menos hasta que tú les digas que hagan algo. Tú haces esto, indicando como las instancias de los objetos reaccionaran a los eventos que sucedan. Hay varios eventos que pueden ocurrir. El primer evento importante es cuando la instancia es creada. Este es el evento "CREATE" o de creación. Probablemente, alguna reacción, es requerida aquí. Por ejemplo, nosotros le decimos a nuestra(s) instancia(s) del objeto payaso que debe empezar a moverse en una dirección en particular. Otros eventos ocurren cuando 2 instancias colisionan entre si; Un evento llamado "COLLIS ION" o de colisión. Por ejemplo, cuando la instancia del payaso colisiona con las instancias de la pared, el payaso tiene que reaccionar y cambiar su rumbo. Otra vez, sucede otro evento, cuando el usuario presiona una tecla del teclado o da clic con el ratón sobre una instancia. Para el payaso, usaremos un "MOUS E EVENT" ("EVENTO DE RATON") para hacer que reaccione cuando se haga clic sobre el. Para indicar que debe suceder en caso de que algún evento se lleve a cabo, especificamos diferentes acciones. Hay muchas acciones que podemos elegir. Por ejemplo, hay una acción, que le da a la instancia del objeto una dirección en particular, hay una para cambiar el "score" (puntuación), y hay una para empezar la reproducción de un sonido. Entonces, definir un objeto del juego, consiste en unos p ocos aspectos: podemos darle a él objeto una imagen, o dejarlo sin imagen en algunos casos esto suele ser útil como se vera mas adelante, podemos darle propiedades, y podemos indicarle a que eventos responderá y que acciones hará en el momento de responder a cierto evento, 46
- 47. sencillo, no. Abajo aparecerá la ventana de propiedades de los objetos, en esta ventana es donde se programaran todos los eventos y acciones que deben de realizar los objetos, de acuerdo a los eventos programados, o indicados por el o los jugador(es). Selecciona el Sprite de la pared y nómbralo por ejemplo como obj_pared, a continuación comprueba que el objeto sea sólido pulsando encima de la característica S OLID con el ratón. Así conseguimos un objeto que sirve de pared. Para el objeto del payaso comenzamos de la misma manera. Agrega un nuevo objeto, cambie el nombre por obj_payaso (el nombre, repito es libre de ser escogido, esto es solo para facilitar la compresión del ejemplo) y escoge el Sprite correcto. El payaso no necesita ser sólido. Tenemos que especificar su comportamiento. Para esto necesitamos el resto de la forma. En el centro usted ve una lista vacía con tres botones debajo de ella. Esta lista contendrá los diversos eventos que el objeto puede realizar. Con los botones debajo de ella usted puede agregar eventos, suprimir eventos o cambiarlos. Hay una gran cantidad de eventos pero no los necesitaras todos en tu juego solo usaremos unos pocos. Al lado de los eventos hay una lista vacía donde estarán las acciones que se deben realizar para el evento seleccionado. Y a la derecha de esta lista hay una serie de pestañas con pequeños iconos que ya hemos visto antes. Estos iconos representan las diversas acciones. En total hay cerca de 100 y cada una tiene su función. Puedes arrastrar acciones de las páginas en la derecha a la lista de la acción, para que esto suceda cuando ocurra el evento. Bien después de este breve recordatorio. Primero debemos definir qué debe suceder cuando el objeto payaso se creé. En este caso quisiéramos que el payaso comenzara a moverse en una dirección arbitraria. Pulsa en Add Event. Esto hará que se muestre la siguiente una ventana: 47
- 48. Pulsa el botón donde dice Create y como veras el evento Create ahora estará en la lista de eventos. Ahora arrastre el icono con las ocho flechas rojas a la lista del evento Create. Este icono corresponde a la acción de movimiento en una dirección particular. Cuando la pones en la lista de eventos de Create aparecerá esta ventana. La mayoría de las acciones están asociadas a las formas en las cuales se pueden configurar ciertas características para la acción. Por el momento olvídate de la caja Applies to. Vamos a especificar dos características aquí, la dirección de movimiento y la velocidad de dicho movimiento. Como necesitamos una dirección aleatoria, pulsa en las ocho flechas (no en el cuadrado central; eso detendría el movimiento). La velocidad (S peed) puede variar al gusto del programador, en nuestro caso pongamos la velocidad en 4, para evitar que los movimientos del payaso sean demasiado rápidos. Solo nos resta pulsar en el botón OK para indicar al programa, que hemos terminado este proceso, y la ventana debe de lucir así. Ahora vamos a indicar que es lo que debe de pasar cuando el payaso choque con la pared, para eso utilizaremos la acción de rebote Al ser arrastrada la acción a la zona de las acciones nos aparecerá una nueva ventana en la cual hay dos propiedades que podemos cambiar, pero sus valores por defecto son adecuados. Para nuestro ejemplo ya que no estamos interesados en rebotes precisos y queremos que rebote contra los objetos sólidos. (Recuerda que hicimos sólida la pared). Así que solo nos resta darle clic al botón OK. También necesitamos añadir una acción más para que se reproduzca el sonido snd_rebote en este caso. La acción de sonido podemos encontrarla en la pestaña nombrada main1 y aparece con la imagen de un altavoz o bocina. Arrástrala a la lista y aparecerá el siguiente formulario: 48
- 49. Aquí puedes modificar de nuevo dos propiedades. Primero debes escoger el sonido a reproducir pulsando en el botón del menú sound. Nosotros necesitamos para el juego el sonido snd_rebote. (Aquí puedes empezar a comprender porque es bueno dar nombres reconocibles a tus recursos). La segunda propiedad permite hacer un bucle con el sonido elegido, reproduciéndolo continuamente. Obviamente ahora no es eso lo que queremos, así que dejamos el valor de la propiedad loop en false. Presiona el botón OK, para cerrar la ventana con los cambios realizados. El formulario de propiedades del objeto deberá de verse ahora de la siguiente manera: Si por alguna razón te equivocaste, puedes hacer clic con el botón derecho del ratón sobre cualquier acción que añadieras anteriormente, para sombrearla y elegir Delete para borrar la acción, (o presionar la tecla Del). También puedes elegir la opción Edit Values para cambiar las propiedades de la acción. (También puedes conseguirlo haciendo un doble clic con el botón izquierdo sobre la acción que quieres cambiar). Finalmente necesitamos definir que hacer cuando el usuario pulse sobre el payaso con el botón izquierdo del ratón. Pulsa de nuevo en el botón Add Event y elige ahora Mouse. Aparecerá una ventana con muchas opciones. La opción que necesitamos es Left Pressed. Esta acción solo se lleva a cabo cuando el jugador pulsa con el botón izquierdo sobre la instancia del objeto. Otros eventos del ratón se desarrollan siempre que el jugador mantenga el botón del ratón pulsado, o suceden independientemente de donde se pulse el botón del ratón. Necesitamos tres acciones en este evento. La primera de todas es incrementar la puntuación cada vez que hagamos clic sobre el payaso. Recuerda que el Game Maker guarda y muestra la puntuación automáticamente. Para incrementar la puntuación, arrastra el botón de acción Set the Score, a la ventana de acciones desde la pestaña nombrada como S core, aparecerá la ventana a la izquierda. Escribe un valor de 10, en lugar del cero que aparece por defecto, porque nosotros aumentaremos el marcador con 10 puntos. Pero esto no es suficiente, la acción pone el marcador a 10 pero queremos añadir 10 puntos al marcador, cada que se atrape al payaso. Esto puede ser llevado a cabo seleccionando la casilla de la propiedad Relativa (Relative). M uchas acciones tienen recuadros para aumentar un valor mayor que el dado por defecto. Presiona OK para cerrar el formulario. La siguiente acción es para reproducir el sonido. Esta acción puede ser añadida exactamente igual a como añadimos el sonido de la acción del rebote. Lo siguiente que queremos hacer es mover al payaso a una nueva posición aleatoria tras cada clic que se de sobre el. 49
- 50. Esto hará el juego más difícil pero a la par más divertido. En la pestaña Move esta la acción que debemos de poner, para realizar esto y se llama Jump to a ran dom position, al ponerla aparecerá esta ventana: Las opciones de defecto están bien, ahora presiona “OK” para cerrar la ventana. Finalmente, nosotros queremos que el payaso se mueva en una nueva dirección y que aumente la velocidad un poco, cómo fue indicado en el documento de diseño. Para esto nosotros usaremos de nuevo la acción con las ocho flechas rojas para configurar el movimiento (el que anteriormente fue usado para dar movimiento al payaso). Arrastra de nuevo en la acción con las ocho flechas rojas, pon un valor a la velocidad de 0.5 y haz un clic en la opción “Relative” para agregar 0.5 a la velocidad. Ya por fin está listo el Objeto del Payaso, la ventana se debe de ver así: Ya hemos definido los tres eventos más importantes. Ahora presiona “OK” para cerrar la ventana. Creando el Cuarto (pantalla del juego): Ahora ya hemos creado todos los objetos del juego, aunque eso no es todo lo que hay que hacer dentro de la creación de nuestro juego. Es hora de crear nuestro cuarto o nivel de juego en el cual se desarrollara la acción. Para la mayoría de los juegos, diseñar cuartos eficaces (llamados a menudo Niveles) es una tarea compleja porque en ellas debemos encontrar el balance y la progresión del juego. Pero para nuestro juego el cuarto será muy simple donde todos los límites del cuarto o nivel de juego, serán cubiertos con el objeto pared y dentro de esta área cubierta por los objetos pared, una instancia del objeto del payaso. Para crear el cuarto o nivel de juego, elige “Add Room” del menú “Add”. Aparecerá la siguiente ventana: 50
- 51. A la izquierda veras tres pestañas con distintos nombres, que ya se explicaron arriba. Nosotros solo utilizaremos la pestaña objects en este caso. A la derecha, veras que el cuarto o nivel de juego (room) actual, es un área gris con una cuadricula superpuesta sobre ella para ayudar a la hora de colocar sobre ella los objetos. Como los objetos de nuestro juego tienen un tamaño de 32x32 cambiaremos un poco la cuadricula, ya que si no, no coincidirán. Para este fin, en la parte superior del formulario, cambia los valores de cuadricula de 16 a 32. Veras que las líneas de la cuadricula están mas separadas ahora, tras realizar el cambio. Para añadir instancias de un objeto en particular, pulsa en el botón con el dibujo del menú. Elige el objeto obj_pared. Ahora usa el ratón para colocar instancias de la pared dentro de las cuadriculas en los bordes de l cuarto o nivel de juego. Seguramente necesites agrandar la ventana o utilizar las barras de scroll para ver el cuarto o nivel completo. Si mantienes la tecla <Shift> pulsada mientras mueves el ratón, se añadirán múltiples instancias del objeto seleccionado en el cuarto. Si cometes un error puedes usar el botón derecho para borrar las instancias de objeto que no querías colocar. Finalmente elige el objeto obj_payaso y coloca una instancia en el centro del cuarto. Eso es todo, tu cuarto o nivel de juego esta terminado. Así que cierra el formulario con el botón OK que aquí es representado como una palomita verde, en la parte superior izquierda de la ventana Bien echo, ya tienes casi por completo tu juego finalizado, la ventana del cuarto o nivel terminado debería de verse más o menos así: Ahora debes comprobar si tu juego esta preparado y listo para ser jugado. Los s prites y sonidos están añadidos, los objetos del juego y el primero (y único) nivel en el que el juego se desarrolla también ha sido creado. ¿Qué nos falta por hacer? Ahora es momento de probarlo y guardarlo. Guardar el juego es una tarea tan simple y muy similar a la de cualquier otro programa de Windows. Selecciona el comando S ave desde el menú File, selecciona la carpeta o ubicación, donde se guardara y dale un nombre descriptivo un nombre. Los juegos creados con el Game Maker obtienen una extensión .gm6. (Esto es para la versión 6 de Game Maker.) Ten presente que no puedes jugar directamente con los archivos de juego. 51
- 52. Puedes solamente cargarlos en Game Maker y una vez abiertos con el Game Maker, jugarlos. M ás adelante veremos cómo hacer un juego ejecutable, es decir un .exe para que cualquier persona independientemente de que tenga o no instalado el Game Maker pueda jugar a tu juego. En seguida necesitaremos probar el juego. Las pruebas son cruciales. Es obvio que lo tienes que probarlo tú mismo, pero deberías también consultar a otras personas para que lo prueben y te den su opinión y comentarios sobre lo que esta bien y lo que le falta. Realizar pruebas es sencillo: selecciona el comando Run normally desde el menú Run, o simplemente presiona la flecha verde que aparece en la barra de herramientas. La ventana de diseño se ocultara, y el juego será cargado, si no cometiste ningún error, el escenario aparecerá en la pantalla del juego con el payaso moviéndose dentro de ella. Prueba haciendo clic en el payaso y ve si el juego se comporta como esperábamos, el juego se vera así, pero puedes hacer que luzca de varias formas, todo es resultado de tu imaginación: Deberías escuchar los sonidos correctos y ver que la velocidad del payaso va en aumento conforme más veces se le atrape. Para finalizar el juego, presiona la tecla (Esc) o haz clic en el botón de cierre en la esquina superior derecha de la ventana. Y la ventana de diseño reaparecerá. Como te darás cuenta el diseño del cuarto o nivel de juego puede cambiar conforme a la que esta expuesta arriba a la izquierda, las combinaciones son infinitas y solo limitadas por tu capacidad creativa, pero recuerda que se est aba desarrollando algo sencillo, guarda los cambios realizados hasta el momento, para eso solo da clic en la barra de herramientas sobre el icono que representa un disquete, se te pedirá un nombre y la ubicación de donde deseas guardarlo, dale alguno que sea correspondiente al tipo de juego que estés creando en nuestro ejemplo yo lo guarde con el nombre de atrapa al payaso. Ahora es tiempo de mejorar el juego. Deberías preguntarte por ejemplo lo siguiente: ¿La velocidad inicial es correcta? O debería ser más rápida...? ¿La aceleración es la adecuada? O piensas que la aceleración es casi imperceptible y hace aburrido al juego...? ¿El tamaño del escenario es el indicado? O quizás si lo hiciésemos más grande obtendríamos mejores resultados...? ¿Seleccionamos las imágenes y sonidos adecuados para el juego? O tal vez si nos atreviéramos a hacer nosotros nuestros propios gráficos, y recursos el juego podría haber quedado mejor...? ¿El fondo es el adecuado, o se podría ver mejor? Si no estás feliz con el resultado, cambia aquellos aspectos del juego que según tú podrías mejorar, y ante todo ten siempre presente esta norma, que para mí personalmente, es la regla número 1 para cualquier programador de juegos que se precie de serlo: Al realizar cualquier juego, debemos de hacer muchísimas pruebas mientras ultimamos los detalles, por eso nuestra destreza y habilidad para con el juego aumenta progresivamente, ya que lo jugamos una y otra vez, y a la larga, este nos parece extremadamente sencillo. Esto no quiere decir que el juego en verdad sea sencillo, para otras personas ya que has de recordar que el programador de juegos crea juegos para otras personas no para el mismo, por consiguiente se han de tener en cuenta las opiniones de las personas que prueben el juego y cambiar aquellos aspectos que nos sugieran. Solo así nuestro juego estará perfectamente balanceado. Felicitaciones. Hiciste tú primer juego, y aún cuando este ejemplo no merezca ser tal vez distribuido le falta algo muy importante, supongamos que ya hemos realizado un juego más completo y que queremos presentarlo y darlo a nuestro amigos, o distribuirlo por Internet, si lo dejamos tal y como nuestro ejemplo, nuestro amigos nos preguntaran que como se juega, que botones se deben de utilizar, y en que consiste el juego, aquí no habría mucho problema y tu de forma oral les podrías dar esa información pero si lo distribuyes por Internet, y lo descarga alguna persona de otro 52
- 53. país, o región de tu país, piensa como le darías esta información, quizá en un bloc de notas, si puede ser, pero porque no darle esta información dentro del mismo juego. 19.5.- Brindando informaci ón al usuario del juego: Recuerda que sería bueno que hicieras y brindaras con tu juego, una breve y concisa explicación de cómo se debe jugar tu juego, de que se trata, y debieras de indicar que se debe de hacer uso del ratón y que botón se debe presionar, como en nuestro ejemplo, o que teclas usar, o si se juega con un jostick que botones se deben de usar, para esto sirve la opción Game Information que se encuentra en el árbol de recursos del Game M aker; que te parece si vemos como hacer esto, puesto que como tu creaste el juego tu sabes como se juega y que controles se deben de usar, pero a las personas que se los proporciones de una forma o otra, no lo sabrán y tal vez tengan que estar adivinando como jugar tu juego, y si no lo descubre terminen por dejarlo y no jugarlo aún cuando pudiera ser un excelente juego. Aquí te enseñare como crear una ventana de presentación sencilla para el juego y como crear, la información del juego de forma muy sencilla: (Si cerraste el programa da doble clic en el icono del Game M aker para ejecutar el programa, y de la barra de herramientas utiliza el icono representado por una carpeta con una flecha verde, para buscar y cargar el proyecto de juego que ya hayas guardado, y búscalo en la ruta de acceso donde lo guardaste, selecciónalo, y da clic en el botón abrir, al parecer no paso nada pero si te fijas en el árbol de recursos veras que las carpetas hora muestran el signo de más delante de ellas y en el marco de la ventana aparece el nombre de nuestro proyecto). Suponiendo que aún tienes, la ventana de inicio del Game M aker abierta, y aún estas trabajando con nuestro ejemplo cargado en ella lo que tienes que realizar para agregar una ventana de presentación en el proyecto de nuestro juego, es crear un nuevo cuarto o nivel de juego, da clic entonces en el menú Add, o un clic derecho sobre la carpeta Rooms, y selecciona Add Room. Y un nuevo cuarto o nivel de juego será puesto dentro de la carpeta rooms, y aparecerá abajo del cuarto que ya teníamos creado para nuestro juego, como queremos que al iniciar el juego se muestre este nuevo cuarto o nivel de juego, simplemente lo arrastramos con el M ouse mientras presionamos el botón izquierdo, a la posición del otro cuarto y se vera de la siguiente forma (En mi caso ya nombre cada uno de los cuartos o niveles de juego). Como segundo paso damos doble clic sobre la opción Game Informatión, para agregar hay la explicación de cómo se debe jugar el juego, al dar doble clic en esta ventana nos aparecerá la siguiente ventana, que es más como un procesador de texto: En esta ventana agregamos toda la información que queramos proporcionar al jugador de la manera más clara y breve posible. En esta ventana puedes seleccionar el color de fondo, trata de usar uno que no sea demasiado agresivo con la vista de los usuarios o sea usa colores suaves, puedes cambiar el tamaño y color de la fuente (Tipo de letra) utilizada, si estas conforme con su contenido solo te resta dar clic en el icono con una palomita en color verde, o guardar desde el menú File. Cierra la ventana. 53
- 54. Bien ahora vamos a decorar al cuarto o nivel de juego, que en mi caso he nombrado Presentación del juego, esto puede ser con una simple imagen de fondo que cubra toda el área (o con un video esto se vera más adelante), entonces tenemos que diseñar el fondo, una vez diseñado lo cargamos en nuestro proyecto de juego, vamos a necesitar también otras dos imagen que funcionara como botones. En mi caso are algo sencillo será una imagen de un rectángulo o cuadrado negro con la palabra información o ayuda del juego, y otra con la palabra iniciar. Entonces una vez que tenemos nuestros recursos comenzamos cargando la imagen de fondo para lo cual damos clic en el menú Add o clic derecho con el M ouse sobre la carpeta Backgrounds y seleccionamos Add Background. Ahora nos dirigimos a la carpeta Rooms, y seleccionamos el cuarto o nivel de juego Presentación del juego, seleccionamos la pestaña Background, deshabilitamos la opción Draw background, y seleccionamos el fondo que nosotros diseñamos del menú desplegadle (el que tiene un pequeño cuadrado blanco con azul), el resultado se vería más o menos así: Ahora vamos a colocar nuestros botones de Información y ayuda del juego, y el de Iniciar el juego. Estos los vamos a usar como objetos del juego, por lo tanto cargamos las imágenes correspondientes en la carpeta de los Sprites, les damos su nombre correspondiente, y una vez cargadas nos dirigimos a la carpeta Objects donde crearemos un objeto para cada una de las imágenes, dándoles también un nombre descriptivo por ejemplo Botón_Información y Botón_Inicio. Lo que queremos que suceda es que cuando el jugador de clic con el botón izquierdo del M ouse en el botón Información ap arezca la información donde se explica como jugar el juego, en que consiste y si quieres quien creo el juego, así como brindarle información de que para quitar la ventana de información deberá presionar la tecla de ESC, o simplemente cerrar la ventana y que cada que necesite consultar esta puede presionar la tecla F1. Y para cuando de clic con el botón izquierdo del M ouse, sobre el botón Iniciar el juego, comience el juego. Entonces vamos a programar los eventos y las acciones necesarias para que suceda todo esto, comenzando con el objeto Información, en el cual le agregaremos el evento M ouse Left Button, y como acciones le agregaremos el botón show the game info, de la pestaña M ain2. Y se debería de ver así. Eso sería todo para este botón así que damos clic en OK. Y continuamos con el botón inicio del juego, que al igual que el anterior botón necesitamos que al dar clic izquierdo con el M ouse sobre el botón Inicio, nos lleve a la pantalla de juego; entonces programamos los eventos y acciones necesarias para que esto suceda, como evento seleccionamos M ouse Left Button, y como acciones pondremos la acción condicional If next room exists, y la acción Go to next room, (esta ultima acción nos permite seleccionar un efecto de transición entre un cuarto o nivel de juego y el otro, lo dejamos con la opción sin efectos, dando clic sobre el botón OK, pero si 54
- 55. gustas puedes ver que sucede con cada una de las opciones que hay aparecen) ambas en la pestaña M ain1, el resultado se debería de ver así: Damos clic en el botón OK, para cerrar la ventana, nos falta ahora agregar estos objetos a la pantalla de presentación del juego, seleccionamos entonces el cuarto o nivel de juego, representando por este cuarto, y colocamos a nuestro gusto los botones que hemos creado, solo nos resta probar el funcionamiento del juego, así que damos clic en la flecha verde de la barra de herramientas, para observar los resultados en cada uno de los botones. Hemos terminado por el momento con este sencillo ejemplo de cómo crear tus juegos, continuemos con el manual, para que vayas entendiendo más sobre el uso del Game M aker. 20.- Distribuyendo el juego: Con la información de los capítulos anteriores puedes comenzar a crear tus juegos. Una vez que hayas creado un buen juego probablemente quieras darlo a otras personas para que lo jueguen. Puedes distribuir libremente y en la forma que desees los juegos que crees con el Game M aker. Incluso puedes venderlos. (Lee el acuerdo de licencia adjunto si no lo has hecho para más información al respecto). Básicamente hay tres diferentes formas en las que puedes distribuir tus juegos. La manera más fácil es simplemente dar el archivo *.gmd que contiene el juego. Sin embargo la otra persona debe tener el Game M aker. (No se te permite distribuir el Game M aker con tu juego pero ellos pueden bajarlo gratuitamente desde el sitio Web). Además, la otra persona puede hacer cambios al juego, y tal vez tú no desees esto. La segunda forma es crear un ejecutable del juego. Esto puede hacerse seleccionando la opción Create Executable en el menú File. Se te pedirá un nombre para el ejecutable que contendrá el juego. Indica un nombre donde será guardado, y presiona OK. Y tendrás un juego ejecutable que puedes dar a quien tú quieras. Puedes configurar el icono para el juego ejecutable en la ventana Game Options. Esto se vera más adelante. (Si tu juego usa algún otro archivo debieras copiarlos a la carpeta que contiene el ejecutable del juego). Ahora puedes distribuir este archivo a otras personas (tal vez quieras comprimirlo antes). La tercera opción es crear un archivo de instalación. Hay varios programas de libre uso y sin costo para la creación de instaladores disponibles en la red. Lo primero es crear una versión ejecutable del juego y luego emplear el instalador para crear una instalación. Cómo se haga esto, depende del programa para crear instaladores que emplees. 21.- Uso avanzado del Game Maker: Esta sección te da información sobre aspectos más avanzados del Game M aker. Comencemos con la información sobre las diferentes partes del Game M aker en modo avanzado: 21.1.- Modo avanzado: Hasta ahora hemos considerado las opciones más simples de Game M aker. Pero hay muchas más posibilidades. Para habilitarlas debes ejecutar Game M aker en M odo Avanzado (Advanced Mode). Es fácil de cambiar. En el Menú File, da clic en el ítem Advanced Mode. (Para ver los cambios debes reiniciar Game M aker guardar tu juego y volver a cargarlo si es que tenias un proyecto de juego). Cuando comience Game M aker en Advanced Mode, la siguiente ventana de proyecto se mostrara: Contiene todo lo que estaba en S imple Mode, pero hay un número de recursos adicionales, botones e ítems de menú. También, como veremos en los siguientes capítulos los diferentes recursos tienen opciones adicionales. Allí analizaremos los diferentes ítems del menú. 55
- 56. 21.2.- File (Menú Archi vo en modo avanzado): En el menú file puedes encontrar comandos adicionales: Merge Game (Combinar juego): Con este comando puedes fusionar todos los recursos (imágenes, sonidos, objetos, cuartos, etc.) de otro juego al juego actual que estés creando, esto es muy útil si quieres reutilizar (por ejemplo sistemas de menú). Algo muy importante nota que todos los recursos tienen un nuevo identificador (id), lo cual podría causar problemas si los piensas usar con scripts. Es tu responsabilidad de asegurarte que todos los recursos en los dos archivos tengan nombres diferentes, de otra manera, podrían ocurrir problemas al momento de correr el juego. Preferences (Preferencias): Aquí puedes establecer un número de preferencias acerca del uso del Game M aker, las cuales serán recordadas entre las diferentes ejecuciones del Game M aker. A continuación se muestra una lista de estas preferencias. Debajo del menú Preferencias (Preferents) en el menú archivo, puedes establecer el número de preferencias que serán mantenidas entre cada ejecución del Game M aker. Las siguientes preferencias pueden ser establecidas: Show recently edited games in the file menu (Mostrar los juegos recientemente editados en el menú archivos): Si este campo está verificado los ocho proyectos de juegos editados más recientemente son mostrados en los archivos recientes en el menú archivo (file). Load last opened file on startup (Cargar el último proyecto realizado al iniciar): Si está seleccionado cuando ejecutes Game M aker el último archivo abierto más recientemente se abre automáticamente. Keep backup copies of files (Crear copias de respaldo): Si está seleccionado el programa guarda una copia de seguridad de tu juego con la extensión gb0-gb9. Puedes abrir estos juegos en Game M aker. Se te recomienda que por lo menos uses una copia de seguridad para tu trabajo. Maximal number of backups (Máximo número de copias): Aquí puedes indicar cuantas (1-9) copias de seguridad, diferentes deberían ser recordadas por el programa. Show progress while loading and saving files (Muestra una barra de progreso cuando cargue o salve un archivo): Si está seleccionado, cuando cargues o guardes un archivo una barra de progreso es mostrada. At startup check for, and remove old temporary files (Al iniciar verifica y remueve archivos temporales): Game M aker y los juegos creados con él, crean archivos temporales. Normalmente son removidos automáticamente pero a veces, por ejemplo cuando el juego se colapsa, se quedan ocultos. Si esta opción está verificada, Game M aker comprueba si dichos archivos existen y los remueve al inicio. Run games in secure mode (Ejecutar en modo seguro): Si está seleccionado, cualquier juego creado con Game M aker que se ejecuta en tu computadora no permitirá ejecutar programas externos o cambiar o eliminar archivos en un lugar diferente de la localización del juego. (Este es un método de seguridad contra troyanos aún que el éxito no está garantizado). Verificando esto significa que los juegos que utilizan archivos externos etc. no se ejecutarán correctamente. Esta opción solo funciona mientras Game M aker este en ejecución. Así que si ejecutas el juego independiente de Game M aker, por ejemplo como un ejecutable, NO es ejecutado en modo seguro. Show the origin and bounding box in the sprite image (Muestra el origen y el límite de la caja de la imagen): Si está seleccionada, en el formulario de propiedades de la imagen (sprite), en la imagen del sprite, las cajas de origen y limitación para el sprite son indicadas. In object properties, show hints for actions (En las Propiedades del objeto, mostrar su descripción para las acciones): Si está seleccionada, en el formulario de las propiedades del objeto, cuando sostienes el M ouse sobre una de las acciones, una descripción es mostrada. When closing, remove instances outside the room (Cuando se cierre, remueve las instancias que estén fuera del cuarto): Si está seleccionada, el programa te alerta cuando hay instancias o tiles fuera de un cuarto, o nivel de juego (room) y te permite eliminarlos. Remember room settings when closing the form (Recuerda la configuración del cuarto al cerrarlo): Si está seleccionada, un número de opciones del cuarto, o nivel de juego, como mostrar la rejilla, borrar los objetos subyacentes, etc. son recordados cuando editas el mismo cuarto, o nivel de juego después. S cripts and code and colors (Colorear los scripts con colores): Ve el capítulo sobre scripts para más información acerca de estas preferencias. Image editor (Editor de imágenes): De forma predeterminada Game M aker usa un editor de imágenes incluido. Si prefieres algún otro programa de edición de imágenes aquí puedes especificarlo para usar ese programa para editar las imágenes (Recuerda que lo puedes realizar por fuera del Game M aker, y cargar la imagen ya editada al juego). External sound editors (Editor de sonidos): Puedes indicar aquí cuál editor de sonido externo usaras para los diferentes tipos de sonido (Nota que Game M aker no incluye un editor de sonido así que si no especificas el editor aquí no podrás editar los sonidos, pero lo podrás seguir realizando por fuera del Game M aker si lo prefieres y después cargar los sonidos). 56
- 57. 21.3.- Edi t (Menú Edi tar en modo avanzado): En el menú editar (Edit) puedes encontrar los siguientes comandos adicionales: Add group (Agregar Gru po): Los recursos pueden ser agrupados juntos. Esto es muy útil cuando haces juegos largos. Por ejemplo, puedes poner todos los sonidos relacionados a cierto objeto en un grupo o sea dentro de una carpeta que estará dentro de la carpeta de sonido, o puedes agrupar todos los objetos que son usados en un nivel en particular. Este comando crea un nuevo grupo en el tipo de recurso actualmente seleccionado. Se te pedirá un nombre. Los grupos pueden de nuevo contener grupos, etc. Como está indicado abajo puedes arrastrar recursos en los grupos. Find Resource (Buscar Recurso): Con este comando escribes en el nombre de un recurso y abres el formulario de propiedades correspondiente. Show Object Information (Mostrar información del objeto): Usando este comando puedes obtener un vista preeliminar de todos los objetos en el juego, así como sus eventos y acciones; no se muestran o imprimen los Scripts si estos existen en un juego, para copiar estos con su información correspondiente tendrías que abrirlos y copiar y pegar en el bloc de notas de Windows, por ejemplo. 21.4.- Add (Menú Agregar en modo avanzado): En este menú puedes agregar recursos adicionales; fíjate que en la barra de herramientas hay un botón que representa a cada una de los recursos, y se te muestra un modo abreviado por teclas para realizar estos comandos con el uso del teclado (se te recomienda aprender estos comandos, para ahorrar tiempo, aun que no es una obligación). 21.5.- Scripts (Menú de Escrituras en modo avanzado): Import S cripts (Importar un scripts): Puede ser usado para importar scripts útiles de archivos. Export S cripts (Exportar un scripts): Puede ser usado para guardar tus scripts en un archivo, para ser usado por otros o en otros juegos. Cuando seleccionas un recurso de script sólo este script es guardado. Cuando seleccionas todos los scripts en el grupo son guardados. Cuando seleccionas la raíz de un recurso (o un tipo diferente de recurso) todos los scripts son guardados. Esta opción del menú también está disponible cuando haces clic derecho en un script o un grupo de scripts. Show Built-in Variables (Mostrar la lista de variables): M uestra una lista ordenada de todas las variables incluidas, tanto globales como locales. Se mostraran al final del manual. Show Built-in Functions (Mostrar la lista de Funciones): M uestra una lista ordenada de todas las funciones incluidas. Se mostraran al final del manual. Show Constants (Mostar la lista de Constantes): M uestra una lista ordenada de todas las constantes incluidas y las constantes definidas en las opciones del juego. Se mostraran al final del manual. Show Resource Names (Mostrar la lista de los nombres de los recursos): Muestra una lista ordenada de todos los nombres de recursos. Puedes hacer clic en un nombre para abrir el recurso en particular para editarlo. Search in S cripts (Buscar en los scripts): Puedes buscar una cadena en todos los scripts. Puedes dar clic sobre uno de los lugares reportados para moverte hasta hay, para editar o hacer cambios. Check Resource Names (Verificar los nombres de los recursos): Hace una comprobación de todos los nombres de recursos. Los nombres serán reportados si no son correctos, si hay nombres de recursos duplicados o cuando un nombre de recurso es el nombre de una variable, función o constante. Puedes dar clic sobre un nombre para abrir el recurso en particular para editarlo. Check All S cripts (Verificar todos los scripts): Verifica todos los scripts en busca de errores. Puedes dar clic sobre uno de los lugares reportados para moverte hasta hay, y editar o hacer cambios. 22.- Uso avanzado de las Imágenes (Sprites): Un número de posibilidades avanzadas existen para crear tus propias imágenes (sprites): Información sobre las diferentes opciones avanzadas de las imágenes puede ser encontrada en las siguientes páginas: 22.1.- Uso avanzado del edi tor de i mágenes del Game Maker: Hasta ahora hemos cargado las imágenes desde archivos. Pero también es posible crearlas y modificarlas desde el Game M aker. Para hacerlo, abre la ventana de propiedades del sprite haciendo doble clic en uno de sus sprites (o creando uno nuevo). Ahora presione el botón con la etiqueta “ Edit S prite”. Un nuevo formulario aparecerá mostrando todas las subimágenes del que está compuesto el sprite, o una sola imagen; si no esta cargada ninguna imagen se vera una nueva ventana con un solo cuadro en un color verde. El formulario de edición se verá de la siguiente manera: 57
- 58. A la derecha veras las imágenes que forman el sprite; fíjate que todas las subimágenes tienen el mismo tamaño, aún que en algunos casos no pasa esto, a la izquierda se ve una vista previa de la animación o la imagen (si no ves la animación o imagen da clic en la casilla S how Pre view). Debajo de la pantalla de animación se puede cambiar la velocidad de la animación (la velocidad es solo para la vista previa, la velocidad del objeto en el juego, dependerá de la velocidad del cuarto) y el color de fondo, de esta forma tendrás una idea de cómo se vera la imagen en tu juego. El editor de imágenes (sprites) contiene varios comandos para crear o cambiar el sprite, todos son manejados a través del menú, algunos están más directos en la barra de herramientas. Algunos comandos trabajan sobre las imágenes de forma individual, y es necesario que primero este seleccionada alguna subimagen. 22.2.- File (Menú Archi vo del edi tor ): El Menú File contiene un número de comandos relacionados con cargar y guardar sprites. New (Nuevo): Crear uno nuevo, una imagen (sprite) vació. Debes indicar el tamaño de la imagen (sprite). Create from file (Crear desde archivo): Crear el sprite desde un archivo. M uchos tipos de archivos pueden ser usados. Crean una imagen que consiste de una imagen simple, excepto los Gif animados que se separaran en subimágenes. Por favor fíjate que el color de la transparencia es tomado del píxel de la esquina inferior izquierda, no de la transparencia del archivo gif. Add from file (Añadir desde archivo): Añade una imagen (o imágenes) desde un archivo a la actual imagen (sprite). Si la imagen no tiene el mismo tamaño puedes elegir el lugar donde colocarlo o reducirlo. S ave as Gif (Guardar como gif): Guarda la imagen sprite como un gif animado. S ave as Strip (Guardar como una tira cómica): Guarda el sprite como una tira cómica (Strip) de mapa de bits (*bmp) con una imagen al lado de la otra con su respectivo orden. Create from S trip (Crear desde una tira cómica): Te permite crear una imagen (sprite) desde una tira cómica (strip). Ve más abajo para más información. Add from S trip (Añadir desde una tira cómica): Usa este para añadir imágenes desde una tira cómica (strip). Ve más abajo para más información. Close saving changes (Cerrar guardando cambios): Cierra el formulario y salva los cambios hechos en la imagen (sprite). Si no quieres guardar los cambios, da clic en el botón de cerrar la ventana. 22.3.- Edi t (Menú Edici ón del editor): El Menú Edit contiene un número de comandos que trabajan con la selección actual de la imagen (sprite). Puedes cortar hacia el portapapeles, pegar una imagen desde el portapapeles, borrarlo y mover una imagen (sprite) hacia la derecha o izquierda en la secuencia. Finalmente, hay un comando para editar imágenes individualmente usando el editor interno del Game M aker. 22.4.- Transform (Menú transformación del edi tor ): En el Menú Transform puedes realizar un número de transformaciones para las imágenes. Mirror horizontal (Espejo horizontal): Voltea o hace un reflejo de la imagen horizontalmente. Flip Vertical (Espejo vertical): Voltea o hace un reflejo de la imagen verticalmente. Shift (Cambiar): Aquí puedes modificar las imágenes en una cierta cantidad de píxeles ya sea en forma horizontalmente o verticalmente. Rotate (Rotar): Puedes rotar las imágenes 90 grados, 180 grados, o cualquier otra cantidad. En el último de los casos puedes elegir la calidad. Experimenta para encontrar los mejores efectos. Resize Canvas (Redimensionar el contenedor de imágenes): Aquí puedes cambiar el tamaño del lienzo o contenedor de imágenes. También puedes indicar donde se ubicara la imagen vieja en el nuevo contenedor. S tretch (Reducir o agrandar): Aquí puedes reducir o agrandar la imagen a un nuevo tamaño. Puedes indicar el factor de la escala y la calidad. S cale (Escalar): Este comando escala la imagen (pero no el tamaño de la imagen). Puedes indicar el factor de la escala, la calidad y la posición de la imagen actual en la escala. 58
- 59. 22.5.- Image (Menú i mágenes del editor): En el Menú imágenes puedes realizar un número de operaciones con las imágenes. Cycle left. (Ciclo a la izquierda): Hace un ciclo de animación hacia una posición a la izquierda. Esto efectivamente comienza la animación hacia la izquierda. Cycle Right (Ciclo a la derecha): Hace un ciclo de animación hacia una posición a la derecha. Black and White (Blanco y negro): Convierte una imagen en tonos de blanco y negro (no afecta el color de transparencia). Colorize (Colorisar): Aquí puedes cambiar el color de las imágenes. Utiliza la barra de desplazamiento para elegir los diferentes colores. Colorize Partial (Colorización Parcial): Se cambia el color de una parte de la imagen, se puede seleccionar un rango de color y entonces indicar un nuevo color, con el cual se reemplazara este (por ejemplo si quisiéramos cambiar el color de los pantalones de nuestro personaje). Shift Hue (Cambiar el matiz): Otra forma de cambiar el color de las imágenes, pero esta vez el color se cambia de acuerdo a un monto indicado dando efectos bastantes interesantes. Intensity (Intensidad): Cambia la intensidad dando valores a la saturación y al brillo de la imagen. Fade (Desvanecer): Debes especificar un color y un monto. El color de la imagen se ira desvaneciendo y tomando el nuevo color elegido. Transparency (Transparencia): Aquí puedes indicar un nivel de transparencia. Esto hará un número de píxeles transparentes. Blur (Difuminado): Difuminando la imagen vemos como los colores se mezclaran un poco, haciéndolos más vagos. M ientras más alto sea el valor, habrá mayor difuminado de la imagen. Crop (Recortar): Esto hace que la imagen se reduzca tanto como sea posible. Esto es muy útil, en las imágenes grandes que consumen mucha memoria de video ya que, a mayor imagen, mayor memoria de video usa Game M aker. Tienes que dejar un pequeño borde alrededor de la imagen para evitar problemas de transparencia. Experimenta con estos comandos para obtener la imagen (sprite) que tú quieres. 22.6.- Animati on (Menú Ani maci ón del editor): Con el Menú Animation podrás crear nuevas animaciones p artiendo de la animación actual. Hay muchas opciones y debes experimentar un poco con ellas para crear los efectos que quieres conseguir. Tampoco olvides que siempre puedes guardar las animaciones y después añadirlas. También siempre puedes añadir imágenes vacías y eliminar las que desees. Haremos un pequeño recorrido a través de las diferentes posibilidades. Set Length. (Cambiar longitud): Aquí puedes cambiar la duración de la imagen. La animación se repetirá para crear la cantidad de imágenes que indiques (Normalmente deberás buscar un múltiplo de la cantidad de imágenes que utilizas). S tretch (Aumentar o reducir): Este comando también cambia la duración de la animación. Pero ahora, las imágenes serán duplicadas o removidas hasta obtener la duración correcta. Así que, si aumentas el número de imágenes la animación será más lenta y si lo reduces será más rápida. Reverse (Reversa): Como imaginas, este comando le da un sentido inverso (a la izquierda) a la animación. Esto significa que se reproducirá de manera inversa o en reversa. Add Reverse (Añadir reversa): Esta vez la animación inversa será añadida, duplicando el número de imágenes. Es muy útil para hacer que un objeto vaya de derecha a izquierda, cambiar su color y reestablecerlo, etc. A veces deberás borras algunas imágenes para que la animación sea correcta. Translation sequence (Secuencia de movimiento): Crea una animación en la que la imagen se mueve levemente en cada imagen, se debe de especificar un número de imágenes y la cantidad total a moverse en forma horizontal o vertical. Rotate Sequence (Secuencia de translación): Crea una animación en la cual la imagen rota o gira. Puedes elegir en el sentido del reloj o en contra. Especifica el número de imágenes y la cantidad de grados del ángulo (360º es el giro completo). Nota: (Quizás necesites redimensionar el lienzo contenedor del sprite para asegurarte que la imagen este visible durante la rotación). Colorize (Colorizar): Crea una animación que cambia la imagen a un color en particular. Fade to color (Desvanecer hacia un color): Crea una animación que decolora la imagen hacia un color en particular. Disappear (Desaparecer): Hace que una imagen desaparezca usando pantallas de filtro (screen-door- transparncy). Observación de traducción: “sreen-door-transparency” se refiere a ir colocando sobre la imagen capas de filtro, que dependiendo del grosor permite ver menos o más a través de ellas. 59
- 60. Shrink (Encoger hasta desaparecer): Encoge la imagen hasta hacerla desaparecer. Debes indicar la dirección hacia donde desees hacer desaparecer la imagen. Grow (Agran dar): A granda la imagen desde el vacío. Flatten (Aplanar): Aplana la imagen hacia una dirección dada, normalmente hacia abajo. Raise (Aumentar): Aumenta la imagen en una dirección dada, normalmente hacia arriba, o a la derecha. Overlay (Mezclar): M ezcla la animación con otra animación o un archivo de imagen. Morph (Transformar): Transforma la animación hacia otra o una imagen de un archivo. Fíjate que al transformar trabajaras mejor si las dos animaciones cubren la misma área en la imagen. De otra manera, ciertos píxeles desaparecerán y otros aparecerán de forma repentina. Los dos últimos comandos son particularmente muy poderosos. Por ejemplo, para hacer explotar un objeto, añade un número de copias y luego un número de imágenes vacías. Entonces mézclalos con una animación de una explosión. (Asegúrate que el número de imágenes concuerde). Alternativamente se ira trasformado en una explosión). Con algo de práctica podrás hacer sprites grandiosos. 23.- Los Strips o Sprites (Tiras Cómicas): Nota de traducción: S trip es un concepto técnico usado en animación y aproximadamente se podría traducir como (Tira cómica). Como indicamos arriba, normalmente las imágenes son almacenadas en archivos gif o en tiras cómicas, con distintos formatos que pueden ser .bmp, .jpg, .png, etc. Una tira cómica (strip) es un dibujo grande que almacena todas las imágenes en un correcto orden. El único problema es que el tamaño de las imágenes individuales no es almacenado en la imagen. M uchas tiras cómicas (strips) se encuentran disponibles en la Web, en un solo archivo. Por ejemplo, en la imagen de al lado, la tira cómica (strip) tiene cuatro animaciones diferentes, para las cuatro direcciones a las que puede moverse el personaje. Para seleccionar imágenes (sprites) individuales de estos archivos, puedes seleccionar create from strip y seleccionar en un solo paso las imágenes que necesites para crear tu animación (ve más abajo) o Add from strip en el Menú File del Editor de imágenes. Para agregar una nueva imagen a la imagen que ya tienes cargada. Después de indicar la tira cómica (strip) apropiada veras el siguiente formulario: A la derecha puedes ver la tira cómica (strip) que has seleccionado. A la izquierda puedes indicar un número de parámetros que especifican las imágenes en las que estas interesado. Fíjate que uno o más rectángulos en la imagen indican las imágenes que seleccionaste. Los siguientes parámetros pueden ser especificados (aclaración el número correspondiente al parámetro, esta hasta la parte posterior izquierda para ayudarte a ubicar cada uno de ellos, esto no es parte de la ventana): 1. Number of images. (Número de imágenes): Es el número de imágenes que deseas extraer o tomar, desde la tira cómica (strip). 2. Images per row (Imágenes por fila): Cuántas imágenes se tomaran en cada fila. Por ejemplo, determinando 1 estará seleccionando una sola imagen. 3. Image width (Ancho de imagen): El ancho de cada imagen individual. 4. Image height (Alto de imagen): El alto de cada imagen individual. 5. Horizontal cell offset (Offset horizontal de celda): Si no deseas seleccionar la imagen superior izquierda, debes indicar cuántas imágenes se deben saltar horizontalmente. 6. Vertical cell offset (Offset vertical de celda): Aquí puedes indicar cuántas imágenes se saltan verticalmente. 7. Horizontal píxel offset (Offset horizontal de píxel): Algunas veces existe un espacio adicional en el ángulo superior izquierdo. Aquí puedes indicar esta cantidad de espacio (en píxeles) 8. Vertical píxel offset (Offset vertical de píxel): Cantidad vertical del espacio extra (en píxeles). 9. Horizontal separation (Separación horizontal): En algunas tiras cómicas (strips) existen líneas vacías entre las imágenes. Aquí indicarás la cantidad de píxeles que se saltan entre las imágenes. 10. Vertical separation (Separación vertical): Cantidad de píxeles verticales que se saltan entra imágenes. Una vez que selecciones el conjunto de imágenes correcto, presiona OK para crear tu imagen (sprite). 60
- 61. Nota: Recuerda que solo tienes permitido usar imágenes de otros, si tienes el permiso o si son de libre uso si es que piensas venderlos, una vez más te invitamos a que crees tus propias imágenes. Observación: Un buen programa que te puede ayudar a realizar tus sprites de forma sencilla es el Chara Set M aker, el cual lo puedes descargar desde la comunidad del Game M aker, para lo cual debes de estar registrado. 23.1.- Edi tando subi mágenes indi vi duales: También puedes editar individualmente las subimágenes. Para esto selecciona una subimagen y elige Edit image del Menú Image. Esto abrirá el pequeño editor de imágenes interno de Game M aker. Por favor, recuerda que se trata de un programa limitado para tratar imágenes pequeñas y no exactamente para crear nuevas aún cuando se pueden crear desde este editor. Por eso, es mejor usar un programa de edición más completo y usar las opciones de cortar o copiar y pegar para insertar la imagen dentro de Game M aker, como podría ser el GIMP o el Paint.Net. El formulario muestra la imagen en el centro y un número de botones con operaciones básicas de dibujo a la izquierda. Aquí tú puedes hacer zoom, ampliando o reduciendo, dibujar píxeles, líneas, rectángulos, textos, etc. Fíjate que el color depende de lo que selecciones con el botón derecho o izquierdo del M ouse. Para algunas herramientas de dibujo puedes seleccionar opciones (como el tamaño de la línea o si desees el borde visible o no). Existe un botón que permite cambiar el color de algunos píxeles por otro. Este editor es muy útil para cambiar el fondo que será usado como transparencia, sobre todo si no es todo de un mismo tono de color. En la barra de herramientas, algunos botones especiales permiten mover los píxeles en una dirección particular. También puedes ocultar o mostrar una cuadricula cuando la imagen es amplía (Trabaja solamente con un factor de por lo menos 4 aumentos). A la derecha de el formulario puedes seleccionar el color que va a ser usado (uno con el botón derecho del M ouse y otro con el izquierdo). Hay cuatro formas de cambiar el color. Primero que todo, puedes dar clic con el botón del M ouse (derecho o izquierdo) en uno de los 16 colores básicos. Fíjate que hay una caja especial de color que contiene el color del píxel inferior izquierdo de la imagen que es usado como color de transparencia si la imagen es transparente. Puedes usar este color si deseas que una parte de la imagen sea transparente. La segunda manera es dar clic a la imagen con cambio de color. Aquí puedes elegir entre muchos más colores. Puedes mantener algunos de los botones del M ouse oprimido para ver el color que estas eligiendo. Tercero, puedes dar clic con el botón izquierdo del M ouse en las cajas indicando el color izquierdo o derecho. Una caja de dialogo de colores aparecerá para elegir el color. Finalmente, puedes usar la herramienta gotero y hacer clic sobre la posición en la imagen para copiar el color que allí existe. En el menú puedes encontrar los mismos comandos de imagen y transformación que están disponibles en el editor de imágenes. Sin embargo solo se aplican a la imagen actual (Cuando un sprite tiene múltiples imágenes, los comandos que cambian el tamaño, como strech, no están disponibles). También puedes guardar la imagen como una imagen bmp. Hay dos comandos adicionales que se encuentran en el Menú Image: Clear (Limpiar): Limpia la imagen con el color izquierdo (Que automáticamente convierte la imagen en transparente). Gradient fill. (Cambio gradual de color): Con este comando puedes rellenar la imagen con un cambio gradual de color (No muy útil para hacer imágenes (sprites), pero puede ser usado para fondos (backgrounds) utilizando el programa de dibujo interno del Game M aker). Fíjate que no hay un mecanismo para seleccionar partes de una imagen. También algunas rutinas elegantes de dibujo no están disponibles. Para esto deberías usar un programa de edición de dibujo más avanzado (o el Paint que viene con Windows). La forma más fácil de hacer esto es copiar la imagen en el portapapeles. Ahora en tu programa de edición de dibujo, usa pegar para obtener la imagen. Luego puedes volver a pegar la imagen en Game M aker, y así obtenerla la imagen modificada y actualizada. 23.2.- Configuración opciones avanzadas de las imágenes: En Advanced Mode, en el formulario de propiedades del sprite hay un número de opciones avanzadas que aquí trataremos. En primer lugar hay opciones relacionadas con el control de colisiones. Si dos instancias se encuentran un evento de colisión es generado. Las colisiones son controladas de la siguiente manera. Cada imagen tiene una caja o contenedor que la limita. Esta caja límite contiene las partes no transparentes de todas las subimágenes. Cuando las cajas se superponen se verifican y controlan los píxeles de las subimágenes para ver si se superponen. Esta operación consume bastantes recursos en cuanto a memoria se refiere. Así que, si no estas interesado en una colisión precisa 61
- 62. para cierta imagen, desactiva la casilla Precise collision checking (Control de colisiones precisas). En este caso solo se verifica la caja que rodea a la imagen. También puedes cambiar las propiedades de dicha caja. Aún que es difícilmente requerido, pero a veces querrás hacer una caja más pequeña, con lo cual las colisiones que se generan en los bordes de la caja no serán totalmente controladas. Los bordes de una imagen pueden verse algo duros, o burdos. Para evitar esto se puede marcar la caja etiquetada S mooth Edges (S uavizar bordes). En este caso los píxeles al borde de la imagen esto es, píxeles vecinos a los píxeles transparentes se dibujan parcialmente transparentes. Esto puede hacer que luzca un poco mejor. (No uses esto cuando el sprite es parte de una figura más grande, porque aparecerá una línea transparente entre las partes). El efecto de esta opción es solo visible en el juego, no en el editor de imágenes. Durante el juego, las imágenes se convierten en texturas. Las texturas deben ser movidas a la memoria de video (de la tarjeta gráfica) antes de ser usadas. Cuando la caja Preload texture (precargar textura) está marcada, esto pasa inmediatamente cuando el juego se carga, así no hay ninguna demora durante el transcurso del juego. Si hay muchas imágenes grandes que no serán usados al comienzo, podríamos quitar la marca a esta opción. Game M aker entonces moverá las texturas a la memoria de video y las cargará cuando sean requeridas. Finalmente, se puede indicar el origen de las imágenes. Este es el punto de la imagen que corresponde con su posición. Cuando se pone una instancia en una ubicación particular, el origen de la imagen es ubicado ahí. Por defecto es la esquina superior izquierda de la imagen, pero a veces es más conveniente usar el centro o algún otro punto importante. También se puede elegir un origen fuera de la imagen. Puedes también ajustar el origen de la imagen de forma manual haciendo clic en la imagen. Cuando el origen se muestra en la imagen. Nota al hablar del origen nos estamos refiriendo a la cruz que indica como se alineara la imagen en la cuadricula, del cuarto o nivel del juego. Las imágenes pueden ser almacenados en dos lugares: en la memoria de video y en la memoria standard. La memoria de video se encuentra en la tarjeta grafica y generalmente es más rápida. Así que si tienes muchas instancias de una imagen tal vez preferirás almacenarla ahí. Pero el monto de la memoria de v ideo esta limitado, dependiendo de la tarjeta grafica que el jugador tenga. Así que te recomendamos no almacenar las imágenes muy grandes en la memoria de video. Algunas imágenes quizás las uses en uno o dos niveles de tu juego. Es un poco incomodo mantener estas imágenes en la memoria de video todo el tiempo. En este caso puedes activar la casilla Load only on use (Cargar solo en uso). Así ahora la imagen es cargada en el momento en que se le necesite. Al terminar el cuarto, o nivel de juego es descartada y se libera memoria. Para juegos grandes con muchas imágenes es importante manejar cuidadosamente cuales imágenes son cargadas y cuales almacenadas en la memoria de video. (También puedes cargar y descartar imágenes desde lenguaje de programación del Game M aker, como se vera más adelante). 24.- Uso avanzado de los sonidos y la música: Cuando añades un recurso de sonido (sound) a tu juego hay un número de aspectos que puedes indicar. Estos están solo disponibles en Advanced Mode, al agregar un sonido (sound) en modo avanzado aparecerá le siguiente ventana: Sin importar los botones para cargar, guardar, y reproducir ahora hay algunas opciones más que serán tratadas aquí. Tres tipos de sonidos son los que puedes utilizar y pueden ser cargados, Los sonidos normales del juego son de dos tipos predefinidos, para archivos M idi se recomienda que se usen para música de fondo ya que solo se puede reproducir uno a la vez, así que si estas escuchando uno y entra otro midi el primero es detenido, y los archivos .wav que se recomiendan para todos esos sonidos que se reproducen constantemente en tu juego (ejemplo los rebotes de una pelota, la destrucción de una nave, etc.). En este formato es posible reproducir múltiples sonidos al mismo tiempo, incluso un mismo sonido se puede reproducir varias veces, sin que se allá terminado de reproducir el primero. Puedes indicar el número de búferes. Este número indica el número de veces que un sonido puede ejecutarse simultáneamente. Por ejemplo, cuando tienes algún sonido de explosión y un número de explosiones deben escucharse simultáneamente, querrás incrementar este número para que varias explosiones se escuchen simultáneamente. Ten cuidado, ya que los búferes múltiples consumen (dependiendo de la tarjeta de sonido) más memoria. Los sonidos mp3 se recomiendan también como música de fondo, recuerda que estos archivos necesitan ser descomprimidos lo cual toma un poco de tiempo en el proceso y tal vez hagan más lento tu juego; el hecho de que el tamaño del archivo sea menor no significa que use menos memoria, a parte no todas las computadoras los soportan, por lo cual es hasta posible que tu juego no corra en ciertas computadoras. En segundo lugar, puedes indicar algunos efectos de sonido, como coro o eco (sólo en la versión registrada del Game M aker). Puedes seleccionar cualquier combinación. Puedes inmediatamente escuchar los resultados. (Cuando estés usando código en lenguaje de programación del Game M aker (GM L) puedes incluso cambiar los parámetros de estos efectos). También puedes indicar los sonidos que se prepararan para realizar efectos de sonido. Los sonidos 3D para los cuales puedes aplicar opciones de 3D a través 62
- 63. de funciones especiales (Sólo los necesitaras para efectos de sonido (sound) muy avanzados). Esos efectos, como cambiar el canal de audición y cambiar el volumen, podrán solo ser usados desde el código del lenguaje de programación. Estos requieren más recursos así que piensa si deberás vale la pena poner estos sonidos en tu juego. Game M aker no tiene un editor interno de sonidos (sounds). Pero en las preferencias (Preferentes) puedes indicar los editores externos que quieras para editar tus sonidos. Si lo indica, puedes presionar en el botón Edit S ound para editar los sonidos que estés usando. (La ventana de Game M aker se ocultara mientras edites tus sonidos y se reestablecerá cuando cierres el editor de sonidos). Lo más recomendable es que los edites primero y luego los cargues al Game M aker. 25.- Uso avanzado de los fondos: Además de importarlos desde archivos existentes, también tienes la posibilidad de crear tus propios fondos. Para este fin, presiona el botón Edit Background (Editar Fon do). Se abrirá el programa de dibujo que viene incluido en el que puedes crear o editar tus fondos. Es importante remarcar que éste no es un programa sofisticado de diseño. Para realizar tareas de diseño más avanzadas y disponer de herramientas de dibujo más sofisticadas utiliza algún programa especializado en ello. Hay una opción que es particularmente útil, en el menú Image (Imagen) encontrarás un comando llamado Gradient Fill (Relleno Degradado); Con esta opción se pueden crear muy buenos fondos con un degradado de color. 26.- Uso avanzado de los objetos: Cuando se añade un objeto nuevo en modo avanzado, se pueden configurar al gunas opciones más avanzadas. 26.1.- La Profundi dad: Antes que nada, se podrá fijar la profundidad (depth) de las instancias del objeto en cuestión. Cuando éstas se dibujan en pantalla, se muestran en orden de acuerdo a su profundidad (depth). Las instancias de objetos con mayor profundidad (depth) se dibujarán primero y aquellas con menor profundidad (depth), al final. Cuando varias instancias de objeto tienen la misma profundidad (depth), se dibujan en el orden en que fueron creadas. Si te quieres asegurar que un objeto se encuentra encima de los demás dale una profundidad negativa, si se quiere que siempre se encuentre siempre por debajo de los otros objetos, dale una profundidad positiva muy grande. También se puede cambiar la profundidad (depth) de una instancia de objeto en particular durante la ejecución del juego utilizando la variable depth, con el lenguaje de programación del Game M aker. 26.2.- Los objetos persistentes: En segundo término, se puede hacer persistente a un objeto. Un objeto persistente (persistent object) seguirá existiendo aún si se pasa de un cuarto, o nivel de juego a otro. Solamente desaparecerá cuando sea destruido o eliminado definitivamente. De este modo, solo es necesario colocar una instancia del objeto en el primer cuart o, o nivel de juego, y continuará apareciendo en todos los cuartos, o niveles de juego. Esto es muy útil cuando, se tiene un personaje principal que se mueve de un cuarto, o nivel de juego, a otro (por ejemplo M ario Bross). La utilización de objetos persistentes (persistent objects) es un mecanismo poderoso pero también puede producir fácilmente errores. 26.3.- Los objetos padres: Todos los objetos pueden tener un objeto padre. Cuando un objeto tiene a otro como su padre, hereda el comportamiento de éste. Dicho de otra manera, el objeto es una especie de variante del objeto padre. Por ejemplo, si se tienen cuatro pelotas distintas, nombradas pelota1, pelota2, pelota3 y pelota4, y todas se comportan (interactúan) de la misma forma pero tienen una imagen distinta, se puede hacer al objeto pelota1 padre de las otras tres; De modo que sólo es necesario especificar eventos y acciones para un objeto: en este caso pelota1. Los otros objetos heredarán los eventos y actuarán exactamente de la misma forma. Además, cuando se ejecutan acciones a instancias del objeto padre también se aplicarán a los hijos. De forma que si se destruyen todas las instancias del objeto pelota1 también se destruirán las instancias de los objetos pelota2, pelota3, y pelota4. Esta opción como te darás cuenta ahorra mucho trabajo. Con frecuencia varios objetos deben comportarse de manera casi idéntica pero con algunas diferencias pequeñas. Por ejemplo, un monstruo podría moverse arriba y abajo y el otro hacia la izquierda y la derecha. Para el resto de las acciones ambos tendrían el mismo comportamiento. En este caso casi todos los eventos deberían tener las mis mas acciones, excepto una o dos que tendrían que ser distintas. En este caso podemos hacer a un objeto el padre del otro. Pero también debemos definir algunos eventos para el objeto hijo. Estos eventos se sobrepondrán a los eventos del padre. De forma tal que mientras un evento del objeto hijo contenga acciones, éstas se ejecutarán en lugar, de las del mismo evento del objeto padre. Si además se requiere ejecutar el evento del padre, se puede llamar al evento heredado, usando la acción apropiada. De hecho, es una buena práctica en tales casos crear un objeto base, por ejemplo un objeto pelota0. Este objeto contiene todo el comportamiento por defecto pero nunca se utiliza en el juego. Todos los objetos pelota tienen a este objeto base como su padre. Los objetos padre pueden así mismo tener padres, y así sucesivamente. (Obviamente no 63
- 64. está permitido crear círculos). De ésta forma se p uede crear una jerarquía de objetos. Esto es extremadamente útil para mantener tú juego estructurado y es ampliamente recomendado aprender a utilizar éste mecanismo. También hay otra utilidad de los objetos padre. Permite heredar el comportamiento en colisiones para otros objetos. Permítame explicar esto con un ejemplo. Supongamos que tenemos cuatro objetos paredes distintas. Cuando una pelota golpea la pared ésta debe de rebotar y cambiar su dirección. Este cambio debe especificarse en el evento colisión de la pelota con la pared. Debido a que hay 4 distintas paredes nesecitariamos escribir código en 4 eventos distintos de colisión para la pelota. En cambio, cuando se tiene un objeto base y esté es padre de las 4 paredes, sólo se debe especificar el evento colisión con éste objeto base. Las demás paredes al tener sus eventos de colisión ejecutarán el mismo evento. Esto, igualmente ahorra mucho trabajo. Tal como se indica, dondequiera que se utiliza un objeto padre, se involucrarán a sus descendientes (si existen). Esto sucede cuando, en una acción, se indica que ésta debe aplicarse a instancias de un objeto determinado. Lo mismo sucede cuando se utiliza la sentencia with( ) en código. Y funciona cuando se llaman a funciones como instance_position, instance_number, etc. Finalmente, sucede cuando se hace referencia a variables en otros objetos. En el ejemplo anterior, cuando se fija la variable pelota1.speed=10 este cambio es también aplicado a los objetos pelota2, pelota3 y pelota4. 26.4.- Las Máscaras: Cuando dos instancias de objeto, hacen colisión o chocan ocurre un evento colisión. Para decidir en qué circunstancias se interceptan dos instancias, se utilizan las imágenes de ambas. Esto es suficiente en la mayoría de los casos, pero en ocasiones se desea tomar las colisiones de forma distinta. Por ejemplo, si se está creando un juego isométrico, los objetos tienen típicamente una altura (para darles una apariencia en 3D). Pero de igual forma los puedes utilizar en juegos de 2D. Pero para las colisiones, sólo se requiere usar la parte que se supone entra en contacto con el alguna parte de la imagen, de acuerdo a la imagen utilizada. Este efecto puede lograrse creando una imagen separada que se utiliza como máscara de colisión para el objeto. Piensa por ejemplo en un tanque de guerra, este tendrá que moverse por el cuarto o nivel de juego, en busca de enemigos, en cierta dirección, pero al presionar algún botón, o tecla definida la torre del tanque se debe de mover sobre su eje, para rotar y apuntar al enemigo que intenta destruirlo, esto solo se logra con las mascaras, pero cuesta algo de trabajo aprender a usarlas correctamente. Ejemplo de dos imágenes para crear un objeto con mascara. La imagen que se usara como mascara Carro del Tanque. Torre del tanque. Imagen Final. 26.5.- Información del Objeto: El botón S how Information (Mostrar Información), que aparece debajo de la ventana de propiedades de los objetos en modo avanzado, brinda una visión general de toda la información concerniente al objeto con el cual se esta trabajando, la cual puede imprimirse. Esto es muy útil en particular cuando se pierde una visión integral de todas las acciones y eventos del objeto, o se quiere saber su programación, (No contiene el código de programación en si, digamos que solo te muestra, el nombre de cada acción que has empleado) veamos como ejemplo, la información que nos brinda este botón de los eventos y acciones que obtuvimos al crear nuestro payaso en el juego de ejemplo, la información se presentara en ingles, tal y como lo muestra esta ventana de información y se agregara una traducción delante de cada renglón en color verde. Nota Importante: Esta información aparece solo mientras realizas tu juego, o en los archivos de ejemplos, o en los juegos que son editables y que puedes conseguir en Internet, para lo cual es necesario que tengas el programa del Game M aker. Algo más los scripts no se imprimen si estos existen, solo se menciona que existen y que se deben de ejecutar estos tipo de archivos, si quieres guardarlos, busca información de cómo hacerlo en el capitulo referente a los scripts, o simplemente cópialos y pégalos en cualquier editor de texto. Information about object: obj_payaso //Información del objeto: obj_payaso Sprite: spr_payaso // Imagen: spr_payaso Solid: false // Sólido: falso Visible: true //Visible: verdadero Depth: 0 //Profundidad: 0 Persistent: false Persistente: falso Parent: <no parent> // Padre: (No padre) Mask: < same as sprite > Mascara (Sin mascara) Cre ate Eve nt: //Crear Evento 64
- 65. start moving in directions 111101111 with speed set to 4 //Iniciar moviéndose en dirección 111101111 con velocidad fija a 4 Collision Event with object obj_pared: //Evento colisión con el obj_pared bounce not precisely against solid objects // rebote no preciso, contra objetos sólidos play sound snd_rebote; looping: false // reproducir el sonido snd_rebote; repetir falso Mouse Event for Left Pressed: Evento para cuando se presione el botón izquierdo del Mouse set the score relative to 10 // Fijar la puntuación relativa a 10 play sound snd_atrapado; looping: false // reproducir el sonido snd_atrapado; repetir falso move to position (0,0) // moverse a una posición (0,0) start moving in directions 111101111 with speed set relative to 0.5 // Iniciar movimiento in dirección 111101111 con una velocidad fija relativa a 0.5 Nota: Terminando de ver todo lo referente a las acciones avanzadas, veremos un tema que nos ayudara a comprender, mejor lo que todo esto significa, y como lo podremos usar y aprovechar. 27.- Acciones avanzadas: En el modo avanzado hay un número adicional de acciones disponibles, que serán descritas en esta sección. 27.1.- Acciones de Movi miento avanzadas: Algunas acciones de movimiento adicionales están disponibles en el modo avanzado. Las siguientes acciones son añadidas a la pestaña move: Set a path for the instante (Establecer un camino o trayectoria para la instancia del objeto): Con esta acción puedes especificar que la instancia de un objeto, debería seguir un camino o trayectoria (path) en particular. Defines el camino o la trayectoria que debe ser seguido y la velocidad en píxeles por paso. Cuando la velocidad es positiva la instancia del objeto, empieza en el inicio del camino o trayecto ria. Si es negativo empieza al final. Después debe de indicar el comportamiento debe tener el objeto al finalizar el camino o trayectoria, esto es, que debería pasar cuando el final de un camino o una trayectoria es alcanzado. Puedes detener el movimiento, reiniciar desde el principio, reiniciar desde la posición actual, o invertir el movimiento. Finalmente puedes indicar que el camino o trayectoria debe ser visto como absoluto, esto es, la posición será como se indicada en el camino o trayectoria -esto es muy útil cuando tienes diseñado el camino o trayectoria en un lugar particular en el cuarto, o nivel de juego - o relativo, en este caso el punto de inicio del camino o trayectoria es colocado en la posición actual de la instancia. Ve el capítulo sobre caminos o trayectorias (paths) para más información. End a path for instante (Detener o parar el camino o la trayectoria para la instancia del objeto): Usa esta acción para detener el movimiento de la instancia de objeto al seguir un camino o trayectoria. Set a path position (Establecer la posición en el camino o la trayectoria): Con esta acción puedes cambiar la posición actual de la instancia del objeto en el camino o trayectoria, esta debe de tener un valor entre 0 y 1 (0=inicio, 1=fin). Set speed of path (Establecer la velocidad del camino o la trayectoria): Con esta acción puedes cambiar la velocidad de la instancia del objeto en el camino o trayectoria. Una velocidad negativa mueve la instancia hacia atrás a lo largo del camino o la trayectoria. P onerlo a 0 sirve para detener el movimiento temporalmente a lo largo del camino o trayectoria. Move towards a point (Moverse hacia un Punto): Esta acción debe estar puesta en el evento paso, para dejar a la instancia tomar un movimiento hacia una posición indicada. Cuando la instancia ya está en la posición establecida no se moverá más, al menos que establezcas otras acciones. Especificas la posición hacia donde debe de moverse, la velocidad con la cual se moverá, esto es, el tamaño del paso, y si el movimiento debería detenerse cuando golpeé una instancia sólida o cuando se golpeé cualquier instancia. S tep toward a point avoiding object (Moverse a un punto evitando los objetos): Esta es una acción de movimiento muy poderosa. Deberá estar colocada en el evento paso. Como la acción anterior permite tomar una dirección hacia una posición indicada. Pero en este caso la acción intentara evitar los obstáculos. Cuando la instancia del objeto debería moverse, sobre de otra instancia sólida (o cualquier instancia) cambiará la dirección del movimiento para intentar evitar la instancia del objeto y moverse alrededor de ella. El acercamiento no está del todo garantizado para funcionar, pero en la mayoría de los casos se moverá la instancia de manera efectivamente hacia el destino. Para casos más complicados, hay funciones de planeamiento de movimiento. Especificas la posición a mover, la velocidad con la cual debe moverse, esto es, el tamaño del paso, y si el movimiento debería evitar instancias sólidas o cualquier instancia. 65
- 66. 27.2.- Acciones princi pales avanzadas main2: Algunas acciones adicionales están disponibles en el modo avanzado. Las siguientes acciones son añadidas a la pestaña main2: Set a time line (Establecer una línea de tiempo): Con esta acción estableces una línea de tiempo (time line), en particular para una instancia de un objeto. Puedes indicar la línea de tiempo (time line) y la posición inicial dentro de la línea de tiempo (0 = inicio). También puedes usar esta acción para terminar una línea de tiempo escogiendo (No Time Line) como valor. Nota: la línea de tiempo se tiene que crear primero, para más información ve al capitulo de las líneas de tiempo más adelante. Set the time line position (Establecer la posición de la línea de tiempo): Con esta acción puedes cambiar la posición en la línea de tiempo actual (absoluta o relativa). Esto puede ser utilizado para saltar ciertas partes de una línea de tiempo o para repetir ciertas partes de esta. Por ejemplo, si quieres hacer una línea de tiempo que se repita, en el último momento o sea al finalizar, agrega esta acción para establecer la posición de repetir a 0. También puedes utilizarla para esperar que algo pase. Tan sólo agrega la acción de pregunta (if), si no es verdadero, establece la posición relativa de la línea de tiempo a -1. Show a video file (Mostrar un video): Con esta acción puedes mostrar un archivo o película de video el cual deberá estar en el formato .avi. Especificas el nombre del archivo y si debería ser mostrado en pantalla completa o en una ventana. Asegúrate de que el archivo de video exista. Deberás distribuirlo con el juego o ponerlo en un archivo de datos y exportarlo a la hora de crear el ejecutable del juego, si no se producirá un error al momento de reproducir el video. Replece a sprite from a file (Reemplazar una imagen desde un archivo): Esta acción puede ser utilizada para reemplazar una imagen desde un archivo. Indicas la imagen que quieres reemplazar, y el tipo del archivo, por el cual la remplazaras y el número de subimágenes a utilizar en la imagen, cuando la cargas de un archivo (.bmp o .jpg). Para un archivo .gif el número de subimágenes es determinado automáticamente, basándose en el número de subimágenes que contiene el archivo .gif. Otras opciones para la imagen, por ejemplo si es transparente o no, no son cambiadas. Puedes usar esta acción para evitar almacenar todas las imágenes dentro del programa mismo. Por ejemplo, al principio de un nivel puedes reemplazar imágenes por las imágenes del personaje que quieras usar. No cambies las imágenes en el momento en el que están siendo usadas en una instancia de objeto dentro de un cuarto, o nivel de juego. Esto podría dar efectos no deseados con las acciones de colisiones. Esta acción sólo está disponible en la versión registrada. Replace a sound from a file (Reemplazar un sonido desde un archivo): Con esta acción puedes reemplazar un sonido desde el contenido de un archivo. Especificas el sonido y el tipo del archivo (.wav .midi .mp3). Esto evita tener que estar almacenando todos los sonidos dentro del juego mismo. Por ejemplo, puedes utilizar diferentes piezas de música de fondo y escoger la que quieras reproducir. No cambies un sonido mientras otro se este reproduciendo. Esta acción sólo está disponible en la versión registrada. Replace a background from a file (Reemplazar un fondo desde un archivo): Con esta acción puedes reemplazar un fondo desde el contenido de un archivo. Especificas el fondo y el tipo del archivo (.bmp o .jpg). Esto evita tener que estar almacenando todos los fondos dentro del juego mismo. No cambies un fondo (background) que esté visible. Esta acción sólo está disponible en la versión registrada. 27.3.- Acciones de control avanzadas: Algunas acciones adicionales para tener más control dentro de lo que pasa en el juego están disponibles en el modo avanzado; las siguientes acciones están disponibles en la pestaña control: Execute a script (Ejecutar un script): Con esta acción puedes ejecutar un script que hayas añadido al juego. Puedes especificar el script y como máximos 5 argumentos para el script. Ve más adelante para mayor información sobre los script. Call the inhererited event (Llamar el evento heredado): Esta acción sólo es útil cuando el objeto tiene un objeto padre. Llama al evento correspondiente en el objeto padre, para ser usado en el objeto hijo. 66
- 67. 27.4.- Acciones de di bujo avanzadas: La siguiente acción de dibujo esta disponible en el modo avanzado dentro de la pestaña draw. Set the font (Establecer la fuente o tipo de texto): Con esta acción puedes establecer la fuente o tipo de texto (fonts), así como su tamaño y color, que será usada para escribir el texto que se podrá ver en la pantalla del juego. Debe de ser de los tipos de fuentes o tipos de texto (fonts), que hayas agregado a la carpeta Fonts en el árbol de recursos. Si escoges (No font) se utilizará por defecto la fuente o tipo de texto Arial con un tamaño a 12 píxeles, en color negro. 28.- Particle Actions (Acciones de las partículas): Un conjunto de acciones que se ocupan del uso de las partículas (particles), se encuentra dentro de la pestaña extra. Estas acciones sólo están disponibles en la versión registrada del Game Maker. Los Sistemas de Partículas (Particle System) están dedicados a crear efectos especiales; las partículas son elementos pequeños (representados por un píxel o una figura pequeña). Dichas partículas (particles) se mueven alrededor del juego de acuerdo con las acciones programadas y pueden cambiar de color mientras se mueven; muchas partículas (particles) juntas pueden crear efectos de fuegos artificiales, flamas, lluvia, nieve, etc. El Game M aker contiene un sistema de partículas (particle system), extenso que puede ser accesado por medio de funciones, y lenguaje de programación. Un sistema de partículas (particle system) más limitado (pero no por eso menos interesante), puede ser utilizado por medio de las acciones descritas a continuación. Un sistema de partículas (particle system) puede manejar partículas (particles) de diferentes tipos, después de crear el sistema de partículas (particle system), la primera cosa a hacer, es especificar los tipos de partículas (particles). Usando las acciones (actions) que serán descriptas a continuación puedes especificar hasta 16 tipos de partículas (particles); cada tipo tiene una forma, tamaño, un color inicial y un color final, el color cambia lentamente desde el inicial hasta el final. Las partículas (particles) tienen un tiempo de vida limitado, en el tipo especificas el tiempo de vida mínimo y máximo de las partículas (particles). Las partículas (particles) también tienen una velocidad (speed) y una dirección, y finalmente, la gravedad y la fricción pueden emplearse en las partículas (particles). Después de especificar los tipos de partículas (particles) debes de crearlas o colocarlas en el cuarto, o nivel del juego, también puedes eliminar un número de partículas (particles) de un tipo en particular desde un lugar o puedes crear un flujo constante de partículas (particles) que irán apareciendo. El sistema de partículas (particle system) puede tener hasta 8 emisores, y a estos puedes indicarles que eliminen o dejen fluir las partículas. Para que comprendas esto mejor, aquí esta el conjunto de acciones completas, se recomienda que experimentes con todas ellas para conseguir el tipo de efecto que desees. Create the particle system –must be called first- (Crear el sistema de partículas – Debe ser llamado Primero-): Esta acción crea un sistema de partículas (particle system). Debe ser llamado antes de que cualquier acción pueda ser utilizada. Sólo necesitas llamarla una vez. Puedes especificar la profundidad a la cual las partículas (particles) se dibujarán. Si usas una profundidad positiva muy alta las partículas (particles) aparecerán abajo de las instancias de los objetos. Si usas una profundidad negativa aparecerán en frente de las instancias de los objetos. Destroy the particle system (Destruir el sistema de partículas): Esta acción destruye el sistema de partículas (particle system), liberando toda la memoria utilizada por este. No olvides llamar esta acción (por ejemplo cuando te mueves a otro cuarto, o nivel de juego), porque los sistemas de partículas (particle system), utilizan mucho almacenamiento de memoria, y podrían alentar el juego, ya que siguen activos hasta que los destruyes. Clear all particles in the system (Remover todas las partículas del sistema): Esta acción remueve todas las partículas (particles) que son actualmente visibles. No detiene los emisores (emitter) de modo que partículas (particles) nuevas, tal vez sean creadas de nuevo, si tienes emisores (emitter) de flujo. (Ver abajo para información sobre los emisores (emitter). Create a type of particle (Crear un tipo de partícula): Con esta acción creas un tipo o estilo de partícula (particle). Puedes elegir uno de los 16 tipos o estilos disponibles. Para el tipo o estilo de la partícula (particle), puedes especificar su forma o la imagen que se utilizará para dicha partícula (particle). Si especificas una imagen, la imagen será utilizada. Si fijas la imagen a ninguna imagen, la forma de la partícula (particle) será utilizada. Hay un número específico de formas incorporadas muy interesantes. También indicas su tamaño mínimo y máximo (cuando aparece se utiliza la partícula (particle) con un valor al azar entre estos límites). Finalmente especificas el aumento de tamaño en cada paso el juego. Para una disminución, utilizar un valor negativo. Observa que solamente un tipo de la partícula (particle) está creado, no una 67
- 68. partícula (particle) real. Para esto necesitas los emisores (emitters). (Ver abajo para información sobre los emisores (emitter). Set the color for particle type (Establecer el color para el tipo de partículas): Una partícula (particle) puede tener un color (de preferencia debes de omitir el color es blanco). Con esta acción puedes fijar el color que se utilizará para un tipo en particular. Debes indicar a que tipo de la partícula (particle) se le definirá el color. Especificas después cómo se aplicara el color. O un color al azar entre dos colores dados, o si el color comienza con el primer color y que gradualmente, sobre el curso de la vida de la partícula (particle), el color cambie al segundo color. Ambos colores deben ser especificados. F inalmente puedes indicar la transparencia. Especificas la transparencia en el momento que se crea la partícula (particle) y cuando finalice. La transparencia cambia lentamente entre estos valores. Es normalmente agradable disminuir el valor alfa sobre el curso de la vida de una partícula (particle), para obtener mejores efectos. Set the life time for a particle type (Establecer el tiempo de vida para un tipo de partícula): Una partícula (particle) vive por un tiempo limitado de pasos en el juego. Después de esto desaparece o es destruida. Con esta acción especificas el tiempo de vida de un tipo de partícula (particle). Puedes dar dos valores límites y el tiempo de vida actual es escogido al azar entre ellos. Set the motion for a particule type (Establecer el movimiento para un tipo de partícula): Con esta acción puedes establecer la velocidad y dirección de un tipo de partícula (particle). De nuevo especificas dos límites y el valor actual es escogido al azar entre ellos. Por ejemplo, para hacer que la partícula (particle) se mueva en una dirección al azar, da como valores 0 y 360 para los límites de la dirección. También puedes especificar una fricción. Esta cuenta es sustraída desde la velocidad en cada paso del juego, hasta que llega a 0 (Puedes hacer que una partícula (particle) acelere su velocidad usando una fricción negativa). Set the gravity of a particule type (Establecer la gravedad para un tipo de partículas): Con esta acción estableces la gravedad y la dirección de gravedad para un tipo de partícula (particle) en especial. Recuerda que 270 grados es una dirección hacia abajo. Create secondary particles (Crear partículas secundarias): Esto es un poco más complicado. Las partículas pueden crear otras partículas (particles), durante su tiempo de vida y cuando mueren. Con esta acción puedes especificar esto. Puedes definir el tipo y número de partículas (particles) que deben ser creadas durante el tiempo de vida de la partícula (particle), o cuando la partícula (particle) muera. Se muy cuidadoso aquí. Puedes crear fácilmente números enormes de partículas (particles) de esta forma, iras haciendo más lento el juego, y al sistema de forma considerable. Para el número de partículas (particles) secundarias que se crearan puedes usar un valor negativo. Un valor negativo X significa que en cada paso del juego, una partícula (particle) es creada con la probabilidad de -1/X. Así que por ejemplo, si quieres generar una partícula (particle) secundaria cerca de cada 4 pasos, usa un valor de -4. Las partículas (particles) secundarias son geniales para crear efectos como colas de partículas o partículas en explosión. Create a particle emitter (Crear un emisor de partículas): Esta acción crea un emisor (emitter) de partículas (particles). Las partículas son generadas por los emisores (emitters). Puedes tener hasta 8 emisores (emitters). Escoge el emisor (emitter) y especifica la figura que será usada, su tamaño y su posición. Destroy an emitter (Destruir un emisor): Esta acción destruye el emisor (emitter) indicado. Nota que las partículas (particles) existentes que vinieron desde este emisor (emitter) no son removidas hasta que termina su tiempo de vida. Burst a number of particles from an emitter (Crear un número de partículas desde un emisor): Incluso si ya definiste un tipo de partícula (particle) y un emisor (emitter), no hay partículas (particles). Aún tienes que indicarle y dar la orden al emisor (emitter) para que genere las partículas (particles). Con esta acción le indicas a un emisor (emitter) en específico que genere un número determinado de partículas (particles) de un tipo dado. Todas estas partículas son generadas de una vez. Para el número de partículas que serán creadas, puedes usar un valor negativo. Un valor negativo X significa que en cada paso del juego una partícula es creada con la probabilidad de -1/X. Así que por ejemplo, si quieres generar una partícula con 25 por ciento de probabilidad, usa un valor de -4. S tream particles from an emitter (Dejar de fluir desde un emisor): Con esta acción le indicas a algún emisor (emitteer), que deje fluir un número determinado de partículas (particles). En cada paso del juego, este número de partículas es generado, conduciendo a un flujo continuo de partículas. El emisor (emitter) seguirá fluyendo las partículas hasta que lo destruyas o le digas que fluya 0 partículas. Para el número de partículas que se dejaran de fluir, puedes utilizar un valor negativo. Un valor negativo X significa que en cada paso del juego, una partícula es creada con la probabilidad de -1/X. Así que por ejemplo, si quieres generar una partícula cerca de cada 4 pasos, usa un valor de -4. 68
- 69. 28.1.- Ejempl o de cómo crear partículas sin usar el lenguaje de programación del Game Maker: Ahora veamos un ejemplo para la creación de partículas, sin necesidad de usar el lenguaje de programación del Game M aker, usando solamente las acciones de Arrastrar y Soltar, que vimos anteriormente, como es solamente un ejemplo para conocer como hacer uso de estas acciones no haremos los procedimientos de la idea global del juego, ni diseñaremos el documento de diseño una vez explicado esto y recalcando que en tus proyectos de juegos siempre debes de realizarlos para facilitarte la creación de tus juegos iniciemos con nuestro ejemplo: Lo primero es crear un objeto control, sin imagen (sprite) y definimos lo siguiente: 1.- Primero, debemos definir el sistema de partículas. Esto es muy parecido a los eventos de las alarmas, también hay un número definido de sistemas para las partículas. Por default es 0 (cero). Nota: definir el sistema de partículas, es obligatorio sino, no habrá partículas. 2.- Ahora vamos a definir algunos aspectos. Estos son el Tipo (la forma de la partícula, en mi caso yo elegí spark), el tamaño mínimo yo lo puse a 0 y máximo yo lo puse a 1, algo muy importante aquí es que no puedes dejar los 2 valores en 0, forzosamente tienes que dar un valor mayor a 0, de lo contrario no verás el efecto de las partículas. 3.- Ahora definiremos el tiempo de vida de la partícula. Esto es especificando e l valor mínimo y el valor máximo de tiempo que tendrá de duración en la pantalla, yo los puse a 10 y 30 respectivamente. 4.- Por último, vamos a definirle la velocidad mínima y máxima, la fricción y la dirección mínima y máxima hacia donde se moverán, la velocidad mínima la puse a 3.la máxima a 4, la fricción a 0, la dirección mínima en 270, y la máxima en 180. Bueno, ahora que hemos definido nuestros tipos de partículas, pero ¿Eso es todo? la respuesta es NO. Ahora nos falta un paso muy importante para completar nuestro sistema de partículas. Esto es, crear un emisor (emitter), ¿Emisor? ¿Qué es esto? Bueno, para hacerlo fácil, un emisor, no son más que las coordenadas en donde se van a crear las partículas. (Es como si fuera un objeto invisible del que "brotaran" las partículas. Se define de la siguiente forma: 5.- Lo primero es crear el emisor (emitter), especificándole las coordenadas en donde será creado ( x- min, x-max, y-min, y-max, en mi caso yo puse estos valores en xmin=0, xmax=640, ymin=0, ymax=480) 6.- Ya para terminar, debemos especificar la cantidad de partículas que se van a crear en determinado momento. Eso es todo, en este ejemplo yo puso el evento de que al p resionar la tecla espacio, el punto rojo se mueva hacia arriba, para chocar con la pared, y que cuando la imagen del punto rojo choque o colisione con la pared, se destruya el punto rojo y, se creen 5 partículas, pero tu puedes agregar las que quieras pero se prudente, recuerda que a mayor cantidad de partículas, mayor uso de la memoria, así al chocar el punto rojo me estará creando las partículas solicitadas en la posición indicada. Sin embargo, aún que sencillo, es necesario que se tomen en cuenta varios aspectos. Lo primero: es que si queremos que un objeto se convierta en partículas. Es necesario que el emisor sea creado desde el objeto mismo (Como en nuestro ejemplo). Esto es, que el objeto por ejemplo al desaparecer o ser destruido (producto de una colisión) cree el emisor, en el punto de la colisión. De lo contrario y si esto se pone por ejemplo en el control del objeto, será más difícil definir que el emisor se cree en donde el objeto fue destruido. Sobre todo si el objeto se está moviendo. Lo segundo: si un objeto va a estallar, siempre en un determinado lugar, podemos crear el emisor (emitter) en ese punto. (Obviamente, que concuerde con el impacto del objeto). Hasta aquí seria todo con respecto a creación de partículas. Pero que te parece si vemos ahora como crear las subpartículas. 69
- 70. 28.2.- Creando l as Subpartículas: Bueno, creo que la pregunta obligada es. ¿Qué demonios es eso de las subpartículas? ¿Otro término raro del Game M aker, para confundirnos? La respuesta es simple. Las subpartículas, no son más que partículas que se crean a partir de otras partículas, ya sea dentro del periodo de vida de las primeras o cuando estas llegan a su fin de vida. Para que quede más claro, imagina que quieres hacer el efecto de fuegos artificiales. Bueno lo primero sería crear una partícula que simule ser el cohete. Acto seguido querrás que a cierta altura esta partícula, explote convirtiéndose en partículas o subpartículas más pequeñas, quedando así, el efecto completo. Una vez más lo haremos sin necesidad de programar en el lenguaje interno de programación del Game M aker, aquí esta la manera de hacerlo: Antes que nada, debemos tener claro que tenemos que diseñar primero el sistema de partículas, -como se explico arriba por ejemplo-. Acto seguido, debemos establecer dos diferentes tipos de partículas, La primaria y la de las subpartículas. Como dije anteriormente, se crean dos tipos de partículas independientes (cada una con sus respectivas características, tamaño, velocidad, tiempo de vida, etc.). Atención: nótese que para que sean diferentes hay que ponerlas con un tipo ("type") distinto; ejemplo: type0, type1, type2, etc. A la partícula primaria le daremos movimiento hacia arriba desde el objeto partícula, le indicaremos por medio del objeto fuegos artificiales que al presionar la tecla espacio sea destruido el objeto partícula, y se generen las subpartículas. Ahora viene la parte importante, la creación de las subpartículas como se ve arriba en la imagen. (En este ejemplo se le agrego gravedad, pero esto es opcional). Algo más, no es necesario crear dos emisores (emitter), sólo basta con uno para el primer tipo de partículas (type0) en el ejemplo lo coloqué de tal modo que se creara el emisor al apretar la tecla espaciadora (space) pero puede ser otra tecla o incluso con una acción del M ouse. Veamos las subpartículas más detenidamente. type id: Digamos que esto define a cuál tipo de partículas (particles) -type0, type1, etc-, se van a aplicar las subpartículas. Aquí hay que colocar el type de la partícula primaria. step type: Esto define el conteo de pasos (step) al tipo de las partículas en este caso usamos también el de la partícula primaria. step count: Este define que a cada cierto número de pasos de la partícula primaria type0, se iran creando las subpartículas (aconsejo dejarla en cero, de lo contrario a cada paso que de la partícula, se crearan subpartículas que alentarán al juego). death type: Este el que usaremos para indicarle al Game M aker que, cuando la partícula primaria muera o sea type0, tendrá entonces que crear las subpartículas (las subpartículas serán creadas con las características asignadas para tal fin. En este caso las del type1). death count: Por último, esto define cuantas subpartículas serán creadas cuando la primaria muera. (Pueden ser desde 1 hasta 50, 100, 200, etc). Ya para terminar, les comento que las subpartículas tienen muchas aplicaciones que pueden ser desde, como dije antes, simular juegos pirotécnicos, hasta simular fuentes de agua, etc. Todo lo que la imaginación nos dicte. Espero y estos ejemplos te sirvan y te ayuden a crear tus sistemas de part ículas, recuerda que es necesario practicar mucho, sobre todo si lo que buscas es crear las subpartículas en el punto de destrucción de una partícula, en especial. 70
- 71. Hasta aquí nuestros ejemplos, ahora vamos a seguir viendo las demás acciones que puedes encontrar en la pestaña extra; En la pestaña extra también hay un número de acciones relacionadas con la reproducción de CD S. Estas acciones sólo están disponibles en la versión registrada del Game M aker. Play a CD (Reproducir un CD): Con esta acción puedes reproducir alguna(s) pista(s) desde el drive del CD predeterminado. Puedes especificar la pista de inicio y la pista final. S top the CD (Detener un CD): Esta acción detiene la reproducción que se esta haciendo desde el CD. Pause the CD (Pausar la reproducción del CD): Esta acción Pausa la reproducción del CD que actualmente esta en reproducción. Resume the CD (Resumir el CD): Esta acción reanuda la reproducción de la pista del CD que se encuentra pausado. If a CD exists in the drive (S i hay un CD en la unidad lectora): Si hay un CD en el drive predeterminado entonces la siguiente acción será ejecutada. If the CD is playing (Si el CD se esta reproduciendo): Si un CD se está reproduciendo en el drive predeterminado entonces la siguiente acción es ejecutada. Finalmente, hay dos acciones adicionales que pueden ser útiles en ciertos juegos, sobre todo la primera. Set the Mouse cursor (Establecer el cursor del ratón): Puedes usar esta acción para reemplazar el cursor de Windows por una imagen. Puedes especificar la imagen y si el cursor del Windows debería ser mostrado (lo recomendable es que no sea mostrado, si no estarás usando dos cursores en tus juegos). La imagen puede ser animada. Notaras que la imagen sólo se mostrara en el cuarto, o nivel del juego, no en el área fuera de él, esto te puede ser útil para poner un cursor más acorde al estilo de tu juego. Open a webpage in a browser (Abrir una página de Internet): Puedes indicar una dirección de Internet con esta acción. La página Web entonces será abierta, y la computadora se conectara para mostrar el sitio o página Web. Esta página Web es abierta en el explorador predeterminado de la máquina (La acción también puede ser usada para abrir otros documentos). La ac ción no funciona en modo de prueba seguro. Esto te puede servir, si tienes tu propia pagina Web y deseas que la visiten, para que desde hay puedan descargar, los juegos que tu hayas creado, o para que visiten alguna otra pagina, como la de la comunidad del Game M aker. 29.- Conociendo la programación algorítmica en el Game Maker: Antes de contestar alguna pregunta sobre este tema, no debe quedar duda acerca de que el lenguaje del Game M aker, no es ni más ni menos que un lenguaje de programación muy completo e intuitivo (Mark Overmars se merece un gran aplauso y todo nuestro agradecimiento por su ingenio, y deseo de compartirlo con nosotros). Si bien el Game M aker nos plantea una interfaz de programación mediante la técnica Arrastrar y Soltar (Drag and Drop), las cosas se van complicando cuanto más complejo vamos haciendo nuestro juego, es por ello que muchos de nosotros debemos recurrir al lenguaje de programación del Game M aker, que nos amplia considerablemente las posibilidades. Los iconos que vemos en las pestañas de acciones en realidad representan un conjunto de instrucciones, funciones, y procedimientos en el lenguaje de programación del Game M aker; por ejemplo tenemos que para las siguientes acciones, también las podrías poner en una pieza de código de la siguiente manera: Imagen del botón Su equivalente en el lenguaje de programación del Game Maker. instance_create(x,y,objeto) Donde X,Y son las coordenadas donde se colocara el objeto indicado. instance_destroy() Esto destruirá la instancia del objeto especificado dentro del paréntesis. sound_play (nombre_del_sonido) Reproduce el sonido indicado dentro del paréntesis. 71
- 72. alarm[#]=10 Indica el tipo de alarma a utilizar [#], y en tiempo se debe de utilizar, en este ejemplo 10. lives=3 Esto establece a 3 el numero de vidas que tendrá el jugador, si queremos que aumenten o disminuyan las vidas se podría poner lives=lives+1, o lives=lives-1. Y si queremos escribir estás acciones en lenguaje de programación, debemos utilizar la acción “Execute piece of code” ó “script” (script se explicará luego). Una vez que agregamos un evento y dentro de este colocamos alguna de estas acciones, es cuando se procede con la escritura en el lenguaje de programación del Game M aker. Así que no debemos pues tener miedo a comenzar a utilizar el lenguaje de programación. Una vez que he tratado de convencerte de que cuando manejas las acciones de Arrastrar y Soltar estás en realidad programando de cierto modo en el lenguaje de programación, te darás cuenta de que no es tan difícil sino que más que nada hay que saber, para que sirve cada función ó en tal caso como se escribe una determinada acción con su equivalente en el lenguaje de programación del Game M aker. Para lo cual te recomiendo un pequeño programa que puedes conseguir en la comunidad del Game M aker previo registro por supuesto, llamado, ActionDecoder1. El cual es muy fácil de usar y una vez que tú coloques una acción con sus valores correspondientes te dará la instrucción en el lenguaje de programación del Game M aker, y como verás te puede ser muy útil para, ir conociendo el lenguaje de programación. Ahora sí comienza lo interesante. Para manejar con mayor avidez y rapidez el lenguaje se deben aprender obligatoriamente los siguientes conceptos: Variable: Una variable es en realidad un identificador que representa una dirección de la memoria RAM , y como la asignación de datos (instrucciones) a esta memoria es aleatoria, es esencial saber donde se guardan lo datos, para nosotros saber el nombre de la variable que es lo mismo. Al programador que recién comienza le interesa saber ¿Para qué sirven? Bueno, una variable nos sirve para almacenar datos que necesitemos usar con posterioridad, como por ejemplo podría ser la vida de un enemigo: Vida=10 Donde vida es el nombre de la variable, el signo de igual es la asignación que se le dio, y 10 es el valor o dato que contiene. Para utilizar una variable primero debe estar declarada en el evento create. De lo contrario cuando compilemos el juego es muy posible que nos dé un error. Existen distintos tipos de variables, sin embargo en GM L no se pueden declarar los tipos así que para simplificar las cosas los dividiremos en dos grandes grupos: las variables de Números o reales y las de Textos o cadenas. Las operaciones que se pueden hacer con variables que contengan números son las conocidas por todos (suma, resta, multiplicación, división, etc.) Continuando con el ejemplo anterior, con la variable vida podríamos hacer, que para quitarle una vida al enemigo, cuando r ecibe un disparo en un evento de colisión con un objeto llamado bala. Agregamos la acción y dentro escribimos vida = vida-1 o también lo podríamos haber escrito así: vida-=1 para restar 1 vida+=1 para sumar 1 vida*=2 para multiplicar por 2 .... Etc. Las variables que contengan texto se representan así: mensaje=‟los textos, a los que daremos el nombre de string, siempre se escriben entre comillas simples (‟) o dobles (“). Con los strings el único operador disponible es el signo + que une dos o más textos. En donde se puede hacer. mensaje+=‟ Seguimos con la explicación‟ El resultado de esta operación será que el nuevo valor de la variable mensaje se cambiara por: mensaje=‟los textos, a los que daremos el nombre de string, siempre se escriben entre comillas simples o dobles. Seguimos con la explicación‟. Fuera de los operadores existen las denominadas “funciones” que extenderán nuestra capacidad para manejar datos, con ellas podremos lograr que un texto se copie, se le quite una letra, una palabra, calcular la raíz cuadrada de un número, dibujar un rectángulo con una palabra dentro e infinidad de cosas. Pero antes de entender que son las funciones, como funcionan y cómo hacerlas nos falta adueñarnos de varios conceptos. 72
- 73. También cabe hacer una distinción entre lo que son variables locales y las que son variables globales. Una variable local solo se puede usar dentro de un mismo objeto, sin embargo pueden existir varios objetos que utilicen variables de igual nombre, pero en este caso no se referirán al mismo dato almacenado. Se puede usar una variable de otro objeto si hacemos lo siguiente: Queremos que se escriba en pantalla la vida de un “enemigo” pero queremos que lo haga un objeto llamado “drawer” ; para conseguirlo debemos hacer lo siguiente: En el evento draw de nuestro objeto “drawer” colocamos una pieza de código en la que escribiremos: draw_text(„La vida del enemigo es: ‟ + string(enemigo.vida),x,y); Con “enemigo.vida” estamos buscando el valor de la variable local “vida” del objeto “enemigo”. Con “draw_text(texto,x,y)” que es una función del lenguaje del Game M aker, escribimos en la posición x y, el texto “texto”, en este caso “La vida del enemigo es: 100” Recordemos que los strings se escriben entre comillas simples, y que además podemos sumarle otro string como es el caso del valor de la variable vida convertida en string “string(enemigo.vida)”. Luego encontramos a las variables globales, que se crean generalmente en el evento Game_start o simplemente en create, y se logra de la siguiente manera: Queremos crear una variable global, común a todos los objetos llamada noche, para lograr eso solo hay que poner la palabra global antes del punto y el nombre de la variable en nuestro caso noche. global.noche=0; Aclarado el asunto de las variables sigamos con... Programar en Lenguaje del Game Maker: Para programar en cualquier lenguaje existen tres estructuras básicas: La estructura secuencial. La estructura alternativa. y la estructura interativa o repetitiva. Durante el desarrollo de estas explicaciones se te darán algunos tips y nociones de este lenguaje. 29.1.- La estructura secuencial: La estructura secuencial es la más elemental y simple de todas y consta de instrucciones una seguida de la otra, que se ejecutan como es de esperarse, en forma secuencial o sea una tras otra. Por ejemplo en el evento create: sprite_index = spr_patito //la imagen del objeto será spr_patito sound_play(snd_glup) //reproducirá un sonido llamado snd_glup hspeed=10 // la velocidad horizontal será de 10 En el ejemplo de aquí arriba habrás notado la distinción de colores entre las distintas líneas, lo habrás notado también si has intentado escribir algo en lenguaje de programación del Game M aker. El color azul oscuro representa a las funciones propias del lenguaje. El color violeta representa a los recursos (sprites, sonidos, rooms, font, etc) que son reconocidos por el programa, de hay la importancia de poner los nombres sin espacios en blanco, haciendo el uso del guión bajo, para los nombres de los objetos, y representarlos con alguna abreviatura como (spr) para los sprites. El color azul claro representa las variables que se crean automáticamente con la creación el objeto. Algunas de estas variables son: X (la posición x en el cuarto), Y (la posición y en el cuarto), speed (velocidad del objeto, en nuestro ejemplo aparece como hspeed porque es una velocidad horizontal si fuera una velocidad vertical se escribiría (vspeed), direction (dirección del objeto.) El color verde representa a los comentarios y para escribir un comentario se debe escribir primero dos barras diagonales //, los comentarios no se ejecutan y no agregan peso al ejecutable del juego, solo te sirven a ti mientras realizas tus juegos, y vayas describiendo que es l o que realiza cada proceso de la programación de tu juego, y vayas teniendo un seguimiento total de las acciones. Las constantes, que son en realidad variables que no se pueden modificar dentro de la ejecución del programa, se ven de color café. Alguna de ellas son: Pi con valor 3.14... c_red : el color rojo ( RGB(255,0,0) ) c_white : el color blanco; c_green : el color verde; vk_left : la flecha izquierda del teclado; mb_left : botón izquierdo del Mouse; Etc... 73
- 74. 29.2.- La estructura alternati va: La estructura alternativa, lo que hace es ejecutar determinada instrucción según suceda una cosa o otra. Por ejemplo: Queremos que se reinicie el juego si se tomaron todos los bonus; dicho de otro modo, queremos que si la cantidad de objetos “bonus” es igual a cero que se reinicie el juego. Ahora en el lenguaje de programación del Game M aker y generalmente en cualquier lenguaje de programación se escribe así: if instance_number(bonus) = 0 then { game_restart(); } Y se debe de entender así: si el_numero_de_objetos(bonus) es igual a 0 entonces entonces reiniciar_juego(); terminar Nótese la estructura Si la condición (if) es verdadera entonces Se comienza con las instrucciones-funciones; instrucciones-funciones; instrucciones-funciones; terminar sino (Else) comenzar instrucciones-funciones; instrucciones-funciones; instrucciones-funciones; terminar; 29.3.-La estructura repetiti va: La estructura repetitiva es una estructura que repite un conjunto de acciones un determinado número de veces . Hay que tener cuidado con estas estructuras porque si no se usan bien se puede caer en lo que se llama un ciclo infinito y se puede congelar, o pasmar el juego o la maquina. Tenemos tres formas de aplicarlas con FOR, WHILE, REPEAT. Si queremos que se dibujen y creen 7 objetos determinados se hace lo siguiente: Con FOR sería: for (i=1 ; i=7 ; i+=1) { instance_create(x,y,pez) } De donde se desprenden las siguientes conclusiones: Se debe utilizar una variable en este caso una llamada “ i” para lograr hacer un ciclo FOR. Esta variable no necesita esta iniciada en el evento create. En primer lugar se escribe la variable que usa la estructura Separado de un punto y coma y hasta cuando se debe repetir Y en último lugar se coloca como se irá incrementando la variable Su estructura por lo tanto es: for (varible=valor ; hasta que la variable sea mayor (>),menor (<), o igual (=) a un valor; incrementándose en X unidades) comenzar instrucciones-funciones; instrucciones-funciones; instrucciones-funciones; terminar; 74
- 75. Con While sería: num=0 while num<7 { instance_create(x,y,pez); num+=1; } De donde se desprenden las siguientes conclusiones: Se puede utilizar una variable en este caso una llamada “num” para lograr hacer un ciclo While. Esta variable si necesita estar iniciada en el evento create y recibe el nombre de contador. Sin embargo no es necesario un contador para hacer un ciclo finito, se puede usar otra condición, porque esto se repetirá mientras que la condición sea verdadera. Se debe de entender así: mientras num sea menor a 7 comenzar Crear_instancia(x,y,pez); num+=1; terminar; Su estructura por lo tanto es: M ientras la condición while sea verdadera se debe de hacer comenzar instrucciones-funciones; instrucciones-funciones; instrucciones-funciones; terminar; 29.4.- Creando un jueg o con leng uaje de programación del Game Maker: Para comprobar lo antes dicho y veas que no es tan difícil ni tenebroso usar el lenguaje de programación del Game M aker vamos a realizar un ejemplo: Carga de Recursos 1) Cargamos el sprite “personaje”, y lo nombramos: spr_personaje. (Antepondremos a todos los sprites “spr” porque ayuda mucho durante la programación del juego como ya lo habrás comprobado. Asimismo los sonidos con el sufijo snd_, los room con rm_, los fondos con bkg_, las fuentes fnt_, la líneas de tiempo con tml_ ). 2) Cargamos el mismo sprite pero esta vez le cambiamos de color desde el editor interno del Game M aker. Lo llamaremos spr_bonus. ¿Qué como se hace? Editamos el sprite, seleccionamos el submenú imagen y luego damos clic, en colorize y lo cambiamos al color que queramos, así de fácil. 3) Cargamos el sprite “bonus”, y lo nombramos spr_bonus. 4) Cargamos el sonido “ glup” y lo llamamos snd_glup; 5) Cargamos el sonido “inicio” y lo nombramos snd_inicio; Creación de objetos. Creamos los objetos: obj_personaje. obj_bonus. obj_drawer. Para el Obj_personaje: Comenzamos con el evento crear: Colocamos en las acciones de eventos una pieza de código: // y Comenzamos a escribir lo siguiente: // comenzaremos por asignarle un sprite desde el mismo código: sprite_index=spr_personaje; //luego reproducimos el sonido de comienzo del juego; sound_play(snd_inicio); 75
- 76. //creamos 2 variables globales. global.tiempo = 100 global.puntaje = 0; image_speed=0.3 //la velocidad de la animación es de 0.3; Seguimos con el evento step: Colocamos en las acciones otra pieza de código. // Comenzaremos por chequear si todavía hay tiempo, y si hay haremos que valla disminuyendo. Si no hay más tiempo el jugador no puede seguir jugando y termina el juego if global.tiempo>0 { global.tiempo-=1 } else { show_message(„Termino el juego. Tu puntaje fue: ‟+string(global.puntaje)) // esta función muestra una ventana de mensaje que dice por ejemplo: //„Termino el juego Tu puntaje fue 10‟ game_restart()} // se reinicia el juego el juego // queremos que cuando el jugador salga de la pantalla simplemente aparezca en el lado opuesto de la misma para lo cual se escribiría: if x+5< 0 { x=room_width} //O sea que si se fue más allá de cero en su limite (x) aparecerá del otro lado en x =el ancho del room (representado con la función //room_width) if x-5>room_width { x=0} //y lo mismo para y if y+5<0 {y=room_height} // Pero aquí en ves de poner room width (que es el ancho del cuarto), ponemos room_height (que es el alto del cuarto) if y-5> room_height {y=0} 4 Eventos de Teclado, para cada dirección: Colocamos en las acciones otra pieza de código, para cada una de las correspondientes. //Para la tecla dirección izquierda (Left). Escribimos los siguientes valores: // a la posición actual de X le restamos 3 x-=3 //Para la tecla dirección derecha (Right). Escribimos: // a la posición actual de X le sumamos 3 x+=3 //Para la tecla dirección Arriba (Up). Escribimos: // a la posición actual de Y le restamos 3 y-=3 //Para la tecla dirección Abajo (Down). Escribimos: // a la posición actual de Y le sumamos 3 y+=3 Evento colisión con el objeto bonus: Colocamos en las acciones otra pieza de código // Si no tomo ningún bonus el sprite del personaje obj_personaje, debe ser el normal, tal y como lo definimos pero si toca uno de los objetos obj_bonus, se le sumaran 5 puntos a la puntuación y cambiara a la imagen del obj_bonus, al mismo tiempo que incrementa el valor del tiempo sumándose 18 //O sea if sprite_index=spr_personaje { global.tiempo+=10 } else { global.tiempo+=18 } 76
- 77. global.puntaje+=5 sprite_index=spr_bonus; // cambiamos el sprite por el que representa, al toma un bonus. Y usaremos una alarma 0 para que en un tiempo de 35 milisegundos se vuelva a poner el sp rite normal. alarm[0] =35 Evento alarma: Colocamos en las acciones otra pieza de código sprite_index=spr_personaje; // Así regresamos al personaje a su estado inicial Para el Objeto bonus. Asignamos al objeto el sprite: spr_bonus. Evento crear: Colocamos en las acciones otra pieza de código // Como ya habrás notado, el sprite spr_bonus es una secuencia de imágenes que nada tienen que ver una con la otra, es decir no corresponden a una animación; sino representan distintos dibujos. Para que el objeto tome como sprite cualquiera de sus sub imágenes al azar usaremos el siguiente código (code). image_single=round(random(image_number)); // Donde se lee; que la imagen única será el numero redondeado de un número aleatorio que tiene como máximo el numero de las subimágenes. Evento Colisión con el objeto obj_personaje: Colocamos en las acciones otra pieza de código // simplemente queremos que si se le toca, se elimine la instancia, y se reproduzca el sonido snd_glup. instance_destroy(); sound_play(snd_glup); Para el objeto obj_drawer, (No lleva imagen): Evento Dibujo (Draw): Colocamos en las acciones otra pieza de código // simplemente queremos que escriba en la parte izquierda de la pantalla, el tiempo de juego que nos queda draw_text(16,32,‟Tiempo: „+string(global.tiempo)) //Donde 16 es el valor de X, y 32 el valor de Y para las coordenadas donde será dibujada la palabra Tiempo más el valor de la variable global.tiempo Evento crear : Colocamos en las acciones otra pieza de código //creamos dos variables xx, e yy xx=0 yy=0 //luego queremos crear ocho objetos y lo hacemos con una estructura repetitiva for (i=0; i<=8;i+=1)// para i=0 hasta i<=8, sumando de uno en uno hacer... { xx=random(room_width);//la variable xx toma un valor cualquiera dentro del ancho de la habitación yy=random(room_height);//la variable yy toma un valor cualquiera dentro del alto de la habitación while not(place_free(xx,yy)) //mientras xx e yy no estén en un lugar libre { xx=random(room_width); // se le deben asignar nuevos valores yy=random(room_height); // se le deben asignar nuevos valores } instance_create(xx,yy,obj_bonus); //crear un bonus en la posición buscada. } Por último: Creamos ahora un cuarto o nivel de juego (room), llamado rm_nivel1, lo definimos del tamaño que queramos y colocamos los objetos obj_personaje y obj_drawer, en cualquier parte de la pantalla (Debe haber por lo menos un 77
- 78. objeto obj_personaje y un obj_drawer). Y listo juego terminado. El juego no pretende ser divertido s ino más bien mostrar como poner en práctica lo leído anteriormente. Es por eso que no se uso una idea global, aún cuando se pudo haber realizado, pero si usamos un documento de diseño, en el cual fuimos describiendo paso a paso lo que se pretendía hacer con este ejemplo, y se te mostró como poner los comentarios en tus piezas de código. Espero que halla quedado claro, y sigamos entonces conociendo como utilizar el Game M aker. 30.- Uso avanzado de los cuartos, o niveles de juego: Los cuartos, o niveles de juego (rooms) en el Game M aker tienen muchas opciones. Antes de tratar las más importantes. En este capítulo discutiremos las opciones principales. Cuando abres un cuarto, o nivel de juego en modo avanzado se verá así: Como verás, algunos botones nuevos han sido agregados a la barra. Hay botones para ordenar las instancias de objetos horizontalmente o verticalmente. Esto es útil cuando las instancias se superponen parcialmente. (Cuando llegues a agregar mosaicos o azulejos (tiles), estos botones funcionarán con los mosaicos azulejos (tiles), de igual forma que como funcionan con las instancias de objetos). También hay botones para bloquear todas las instancias o desbloquearlas. Las instancias bloqueadas no pueden ser movidas ni borradas. Esto te salva de hacer esto intencionalmente. Usando el menú con el clic derecho del M ouse (mantén presionado (Ctrl.) y haz clic derecho en una instancia) puedes incluso bloquear o desbloquear instancias de objetos individuales. Finalmente, puedes indicar si deseas usar celdas isométricas, esto es muy útil si deseas crear juegos isométricos (con apariencia o en 3D). Primero que todo las líneas de las celdas automáticamente se hacen diagonales, así las instancias se acomodan mejor. También hay dos pestañas nuevas que se d iscutirán más adelante. La información sobre las diferentes opciones avanzadas al momento de crear los cuartos o niveles de juegos se explican a continuación: 30.1.- Las opciones avanzadas de l os cuartos o ni veles de jueg o: Los bordes de los fondos, en especial cuando son transparentes, pueden parecer un poco marcados. Para evitar esto puedes marcar la casilla S mooth edges (suavizar bordes). Con esta opción los píxeles de los bordes del fondo es decir, los píxeles próximos a los transparentes, son convertidos parcialmente en transparentes. Esto puede hacer que se vean bastante mejor. Pero no hagas esto cuando los fondos vayan a ser unidos para formar uno mayor porque entonces una línea parcialmente transparente aparecerá entre ellos. Los efectos de esta opción son sólo visibles en el juego, no en el editor. Durante la partida, los fondos son convertidos en texturas. Las texturas tienen que ser cargadas a la memoria de vídeo (en la tarjeta gráfica) antes de que puedan ser utilizadas. Cuando la casilla Preload texture (precargar textura) está marcada esto ocurre inmediatamente cuando se carga el juego, así que no habrá paradas para cargarlas durante la partida. Si tienes muchos fondos grandes que no van a ser utilizados al comienzo del juego deberías desactivar esta opción. Game M aker cargará las texturas a la memoria de vídeo y lo volverá a hacer cuando las necesite. Hay dos aspectos en la pestaña settings (opciones) que no hemos descrito aún. La primera opción que aparece es una casilla nombrada Persistent (persistente). Normalmente, cuando se abandona un cuarto, o nivel de juego y posteriormente se regresa al mismo, la configuración del cuarto, o nivel del juego vuelve a sus valores iniciales. Esto está muy bien si se tienen varios niveles en un juego N.T: (Por ejemplo en juegos como el Tetris) pero no es lo que normalmente, lo que se desea en un RPG o juego de plataformas, (por ejemplo M ario Bross). En este caso, el cuarto o nivel de juego debe aparecer en el mismo estado en que se dejo la última vez que se visitó. Al seleccionar la casilla Persistent se logrará precisamente eso. El estado de los cuartos o niveles de juego será recordado y cuando se vuelva a ellos con posterioridad en el juego, éstos estarán tal y como estaban al salir de ellos. Solamente cuando el juego sea reiniciado, el estado de los cuartos o niveles de juego se reestablecerá. De hecho, hay una excepción a esto, si algunos objetos están configurados como persistentes (ver más adelante), las instancias de este objeto no permanecerán en el cuarto o nivel de juego, sino que se moverán al cuarto o nivel de juego siguiente. Después, hay un botón llamado Creation code (Código de creación). Aquí podrás escribir código en lenguaje del Game M aker (GM L), que será ejecutado al momento de crear el cuarto o nivel de juego. Esto es útil por ejemplo para, asignar valores a variables, crear algunas instancias, etc. Es muy útil comprender que es exactamente lo que sucede cuando te mueves a un cuarto o nivel de juego en particular. 78
- 79. Primero, en el cuarto o nivel de juego actual (si existiera) todas las instancias tendrán un evento salir- del cuarto o nivel de juego-. Después, los objetos no persistentes se remueven (sin generar un evento destrucción). Posteriormente, se agregan al nuevo cuarto o nivel de juego las instancias persistentes del cuarto o nivel de juego anterior. Se crean todas las instancias nuevas y se ejecutan sus eventos de creación (en caso de que el cuarto o nivel de juego no sea persistente o no hayan sido visitada antes en el juego). Cuando cuarto o nivel de juego es el primero del juego, todas las instancias tendrán un evento inicio-juego. Ahora el código de creación del cuarto o nivel de juego es ejecutado. Finalmente, todas las instancias tendrán un evento inicio-cuarto o nivel de juego. De modo que, por ejemplo, los eventos inicio-cuarto o nivel de juego, pueden emplear variables configuradas en el evento creación del cuarto o nivel del juego y en el código de creación se puede referir a las instancias en el cuarto o nivel de juego (tanto las nuevas, como las persistentes). Hay una opción más. Si se configura la preferencia correcta, al dar clic con el botón derecho del ratón en una instancia aparecerá un menú contextual. Aquí podrás usar los comandos usuales de suprimir o mover en el orden de profundidad, y también podrás indicar el código de creación de la instancia del objeto. Este código se ejecutará cuando el cuarto, o nivel de juego sea iniciado, justo antes de que el evento creación de las instancias sea ejecutado. Esto es muy útil, por ejemplo para, configurar ciertos parámetros que son específicos para las instancias de los objetos. 30.2.- Agregando Mosaicos (Tiles) a l os cuartos o ni veles de jueg o: También se pueden crear fondos llamados de mosaicos (tiles). El objeto de crear estos fondos es el siguiente: En muchos juegos querrás tener fondos atractivos. Por ejemplo, en un juego de laberintos, los muros del laberinto deberán encajar, y en un juego de plataforma querrás ver árboles, plataformas, obstáculos, etc. Con el Game M aker puedes lograr esto, definiendo muchos objetos diferentes y armar los cuartos, o niveles del juego con estos objetos. El problema, sin embargo, es que esto lleva mucho trabajo y tiempo, utiliza grandes cantidades de recursos, y provoca que los juegos se ejecuten lentamente debido a la gran cantidad de objetos distintos utilizados. Por ejemplo, para crear paredes con buena apariencia en juegos de laberintos necesitas, por lo menos, 15 objetos con distinta forma. La solución estándar, utilizada en muchos juegos, es que las paredes y otros objetos estáticos son dibujados en el fondo. ¿Pero, te preguntarás, como sabe la computadora que un objeto toca una pared si ésta, está dibujada en la imagen de fondo? El truco se logra como sigue: Solamente se crea un objeto pared en tu juego. Éste deberá tener el tamaño correcto pero no tendrá que verse bien. Al momento de crear el cuarto o nivel de juego, se coloca este objeto en todos los lugares en que halla una pared. Y haz a este objeto invisible. De forma que al momento de ejecutar el juego no se verán los objetos pared. Únicamente se verá la imagen de fondo. Pero los objetos pared, sólidos aún estarán ahí y los demás objetos reaccionarán a ellos. Puedes emplear esta técnica para cualquier objeto que no cambie su forma ni posición, y no requiera ser animado. Para juegos de plataforma, probablemente necesitarás sólo un objeto para el suelo y otro para las paredes, pero tus fondos podrán tener partes en que parezca que se camina sobre pasto, sobre las ramas de árboles, etc. Para agregar mosaicos a tus cuartos o niveles de juego, primero necesitarás una imagen de fondo que contenga los mosaicos. Algunas de éstas se proveen con Game M aker. Si quieres que tus mosaicos sean parcialmente transparentes, asegúrate que seleccionaste la opción transparente al importar la imagen de fondo. Ahora, cuando estés definiendo la imagen de fondo que usaras como tile-set para el cuarto o nivel de juego haz clic en la etiqueta tiles (mosaicos). Aparecerá una ventana como la siguiente: Puedes cambiar varias opciones de la cuadrícula. En particular puedes cambiar la anchura (tile width), y la altura (tile height), de los cuadrados. Las dimensiones que se ponen son para toda la cuadrícula, así que asegúrate de que todos los cuadrados del fondo tienen el mismo tamaño; si tienes diferentes tamaños, crea más cuadrículas. También puedes dejar un margen arriba (vertical offset), y un margen a la izquierda (horizontal offset), desde donde comienza la cuadrícula. Finalmente, la separación horizontal (horizontal sep), y la separación vertical (vertical sep), entre los cuadrados, que normalmente es "0" o "1". Aquí es necesaria una advertencia. Cuando pones bordes de separación entre las imágenes y utilizas la interposición entre píxeles (consulta las opciones globales del juego), esto puede dar resultado a "grietas" entre los cuadrados. Para evitar esto mejor asegúrate de que los píxeles que están alrededor de los cuadrados tocan con los píxeles que están justamente por dentro de éstos. Por defecto, los fondos son almacenados en la memoria de video. Esto no implica mayores complicaciones si éstos son pequeños pero cuando se utilizan fondos de dimensiones más grandes será mejor utilizar la memoria normal a cambio. Esto reducirá ligeramente la velocidad de carga del juego y del fondo mismo, pero se debe considerar que la 79
- 80. memoria de video esta limitada a la capacidad de la misma. Para no utilizar ésta, la casilla Use video memory (Usar memoria de video) no deberá estar seleccionada. También por defecto, los fondos se cargan en la memoria cuando se necesitan y se descargan de nuevo al salir del cuarto o nivel de juego. Esto ahorra grandes cantidades de memoria pero hará ligeramente más lentos los inicios de los cuartos, o niveles de juego y pueden provocar un pequeño salto cuando se cambia el fondo a la mitad de uno de ellos. Para evitar que esto suceda, no seleccione la casilla Load only on use (Cargar sólo al usar). En la siguiente Grafica ya se han colocado algunas imágenes de mosaicos (tiles), a un fondo: En la parte izquierda debajo del tile-set está el nombre que tú le diste al tile-set de mosaicos (tiles) que estas utilizado. Para seleccionar una imagen de tile-set, (Recuerda que primero debes de cargarla como si fuera un fondo, pero debes de marcar la casilla de verificación –Use as Tile-Set-) haz clic en el botón que parece ser un menú contextual debajo, de la parte que muestra la imagen de los mosaicos (tiles) y selecciona la imagen de fondo apropiada. Ahora, podrás añadir mosaicos (tiles), seleccionando la parte del mosaico (tile) deseado en la imagen de la esquina superior izquierda, y después posteriormente haciendo clic en la posición apropiada en el cuarto o nivel de juego a la derecha. Esto funciona exactamente en la misma forma en que se añaden instancias de objetos. Si la opción Delete underlying (Eliminar mosaico inferior) está seleccionada, al colocar un mosaico en un lugar donde ya exista uno se reemplazará el existente por el nuevo. Con el botón derecho del ratón se pueden eliminar mosaicos. También hay botones para agregar (Add), eliminar (Delete) y para cambiar (Change) todos los mosaicos (tiles). Utilizar mosaicos (tiles) es una opción muy poderosa que debería ser empleada siempre que sea posible. Es mucho más rápida, que utilizar objetos y las imágenes de mosaicos se almacenan sólo una vez. De modo que puedes utilizar cuartos, o niveles de juego muy grandes llenos de mosaicos (tiles), con muy poco consumo de memoria. 30.3.-El uso de l as vistas (Views) en l os cuartos o ni veles de jueg os: Finalmente, hay una pestaña titulada vistas (Views). Esto es un mecanismo para dibujar diferentes partes de tu cuarto, o nivel de juego en diferentes lugares de la pantalla. Hay muchos usos para las vistas (views). Primero, en algunos juegos quieres ver solamente una parte del cuarto, o nivel del juego y no todo el tamaño. Otro ejemplo, en muchos juegos de plataforma, la vista (view) persigue al personaje principal en todos sus movimientos. En los juegos de dos jugadores casi siempre hay la necesidad de dividir la pantalla, y mostrar en un lado a uno de los jugadores y en la otra parte al otro jugador, un tercer uso es común en los juegos en que parte del cuarto, o nivel del juego, deberá moverse con el personaje principal mientras la otra parte esta fija (por ejemplo la barra de energía del personaje, o de una nave). Cuando haces clic en la pestaña vistas (views) aparecerá la siguiente imagen: Arriba hay un botón llamado Enable the use of Views. Si quieres usar las vistas tienes que activar esta casilla de verificación. Después podrás ver una lista de hasta 8 vistas (views) que podrás definir. Debajo de la lista puedes definir la información de las vistas. Primero tienes que indicar si la vista (view) será visible cuando el cuarto, o nivel de juego comience. Asegúrate de que por lo menos una vista (view) sea visible. Las vistas (views) activadas serán visibles en negrita. Una vista (view) es definida por un área rectangular en el cuarto o nivel de juego. Esta es el área qu e será visible en la vista (view). Tienes que especificar la posición de la pantalla que usara la vista en ( view in room) y el tamaño, en la imagen la posición es X=0, Y=0, y el tamaño de la vista es de 180 tanto a lo alto como a lo ancho. Segundo, tienes que especificar 80
- 81. como será mostrada esta área en la ventana de la pantalla (Port on S creen), en la imagen con un valor de 180 nuevamente, si se agrega un valor más alto al valor del ancho o alto, la vista se ajusta a ese valor escalando la imagen, el tamaño del cuarto o nivel de juego se conserva, así que si tienes un cuarto o nivel de juego a un tamaño de 600 X 600 por ejemplo, el objeto se ira desplazando por la vista hasta cubrir el tamaño del cuarto o nivel de juego. Casi siempre la vista tiene que seguir cierto objeto (Object following). Este objeto puede ser indicado en el botón que tiene una imagen de menú contextual. Si hay varias instancias de este objeto, solamente la primera es perseguida por la vista (view) -utilizando lenguaje de programación también se puede indicar a que objeto seguir-. Normalmente el objeto principal tiene que caminar alrededor sin que la vista cambie. Puedes especificar el tamaño del borde que será visible alrededor del objeto en Hbor para la parte horizontal, y Vbor para la parte vertical. Finalmente, puedes indicar la velocidad con la que la vista va a cambia. Usa -1 si quieres que la vista cambie instantáneamente. 31.- Las fuentes (Fonts): Cuando quieres mostrar diferentes fuentes o tipos de texto (fonts) en tu juego este texto es dibujado desde una fuente o tipo de texto (font), (por defecto en tipo Arial, tamaño 12 con color negro). P ara poner fuentes o tipos de textos más de acuerdo a tu juego, podrás usar fuentes o tipos de texto (fonts), que vallan más a él estilo de juego que estas creando. Para usar fuentes o tipos de texto diferentes debes cargar los archivos de la fuente o tipo de texto. Debes de especificar un tipo de archivo de fuente o tipo de texto, en el que estés interesado en usar en tu juego. Para agregar una fuente o tipo de texto a tu juego, usa la opción Adquirir Fuente o tipo de texto (Add Font) en el menú Add o usa el botón correspondiente en la barra de herramientas, la ventana siguiente será mostrada: Como siempre deberías darle un nombre al recurso. Después podrás escoger el tipo de texto o fuente, en la opción Font. Esta es tomada de las fuentes que tienes cargadas en tu computadora. También puedes indicar su tamaño y si debería de ser negrita (Bold) o cursiva (Italic). Fíjate que las fuentes o tipos de texto grandes ocupan mucha memoria para ser almacenadas. Así es que se te recomienda que no uses las fuentes o tipos de texto con un tamaño mayor a 32 píxeles (es posible escalar las fuentes cuando el juego este ejecutándose). Un ejemplo de la fuente o tipo de texto que será usado es mostrado en la parte de abajo. Una fuente o tipo de texto típicamente consiste en 256 caracteres, numerados del 0 al 255. Pero en general solo usas una pequeña parte de estos. Así es que de forma predeterminada al usar una fuente o tipo de texto, solo se almacenan los caracteres del 32 hasta el 127. Entre más caracteres almacenes en la fuente o tipo de texto, será mayor la cantidad de memoria que usará. Puedes cambiar el rango de los caracteres usados (pero realmente no es necesario, según mi criterio). Para ver el índice de cada carácter puedes usar el M apa de caracteres que puede ser encontrado en el menú inicio de Windows en Accesorios/Herramientas de sistema. Algunos rangos estándares pueden ser indicados usando los botones: El rango Normal (Normal) que va de 32 hasta el 127, el rango completo (All) de 0 hasta el 255, el rango de dígitos (Digits), que solo contiene 10 dígitos, y el rango de letras (Letters) que contiene todas las letras mayúsculas y minúsculas. Pueden ser usados otros rangos escribiendo el índice del primero y último carácter. Si un carácter no concuerda con el rango es remplazado por un espacio en blanco. Normalmente tienes un número de distintas fuentes o tipos de texto, instaladas en tu computadora y hay muchos sitios Web de donde puedes descargar cientos más. El problema es que si las usas en tu juego y después le das tu juego a otra persona para que lo juegue hay una gran probabilidad que la otra no tenga las mismas fuentes o tipos de texto, instaladas en su computadora. Para evitar esto, Game M aker inserta todas las fuentes o tipos de texto, que quieras usar en el archivo del juego, pero solo en los juegos ejecutables. Así es que si das el juego ejecutable a alguna persona no necesitas proporcionar los archivos de la fuente o tipo de texto. Pero si le das la versión editable de tu juego a otra persona y si usaste fuentes o tipos de letras externas, mejor también proporciónale a esa persona los archivos de fuente o tipos de letras que usaste. 32.- Los Caminos o trayectorias (Paths): En la mayoría de los juegos avanzados se busca permitir a las instancias de objetos seguir ciertos caminos, o ciertas trayectorias. Aún que esto se puede hacer usando eventos de alarma, o escribiendo código en lenguaje de programación con el Game M aker, seria demasiado complicado; es por eso que existe un mecanismo más sencillo de usar para estos casos y que viene dentro del Game M aker, el recurso es llamado (Paths). La idea es bastante simple, dibujas o defines una tray ectoria o camino (path); lo siguiente es poner una acción en el evento de creación del objeto, para indicarle que siga el camino o trayectoria indicada, este capítulo explicara los caminos o trayectorias (paths) con más detalle. 81
- 82. 32.1.- Defi niendo los caminos o trayectorias (paths): Para añadir un camino o trayectoria (path) a tu juego, escoge Agregar camino o trayectoria (Add Path) en el menú Add. Aparecerá la siguiente ventana. (En este ejemplo ya se añadió un pequeño camino o trayectoria (path)). Arriba a la izquierda de la ventana puedes especificar el nombre del camino o trayectoria (path). Debajo encontrarás los puntos que influyen el camino o trayectoria (path). Cada punto tiene una posición y velocidad (indicado con sp). Dependiendo de cómo se use el camino o trayectoria (path), la posición pude ser absoluta o relativa. Absoluta implica que la instancia del objeto que usara el camino o trayectoria (path), seguirá esa ruta hasta llegar a la posición final indicada; relativa significa que la instancia del objeto, comenzara siempre en la posición de inicio del camino o trayectoria (path) y comenzara su recorrido desde ahí. La velocidad es interpretada de la siguiente manera. Un valor de 100 significa la velocidad original de la instancia. Un valor menor reduce la velocidad, un valor más alto la incrementa (esto indica el porcentaje de la velocidad real). La velocidad es intercalada entre puntos, por lo que la velocidad puede ser cambiada gradualmente. Para añadir un punto de camino o trayectoria (path) presiona el botón Add. Aparece una copia del punto seleccionado, ahora puedes indicar o cambiar la posición actual y la velocidad cambiando los valores en las cajas de edición. (En cualquier momento en que selecciones un punto en la lista, puedes cambiar sus valores). Presiona Insert para insertar un nuevo punto en el camino o trayectoria (path) a seguir después del actual, y presiona Delete para borrar el punto actual. A la derecha de la ventana verás el camino o trayectoria (path) actual, el punto rojo indica cual es el punto de control, los puntos azules son los otros puntos de control, el cuadro verde indica, la posición en donde comenzara el camino o trayectoria (path). También puedes cambiar el camino o trayectoria (path) usando el ratón. Da un clic sobre cualquier parte de la imagen para agregar un punto de control. Da clic en un punto de control existente y arrástralo para cambiar su posición. Cuando mantienes (Shift) mientras das un clic, insertas un nuevo punto de control. Finalmente, puedes usar el botón derecho para borrar puntos de control. (Nota que de esta manera no puedes cambiar la velocidad). Normalmente los puntos de control, serán alineados con la cuadricula, se pueden cambiar los parámetros de la cuadricula, en la barra de herramientas superior, también se puede indicar en donde la cuadricula será visible y donde no. Si deseas una posición más precisa o exacta, mantén presionada la tecla (Alt) mientras agregas o mueves puntos de control. Puedes influir la forma del camino o trayectoria (path) de dos maneras. Primero puedes usar un tipo de unión o conexión entre los puntos de control. Puedes escoger entre líneas rectas o curvas; segundo se puede indicar si queremos que el camino o trayectoria (path) sea cerrado o no. También, puedes indicar que pasa cuando se llega al último punto del camino o trayectoria (path). Existen varias opciones. La más común es continuar moviéndose hacia el primer punto, cerrando el camino o trayectoria (path). También puede dejar de moverse, brincar al primer punto, o regresarse por el mismo camino o trayectoria (path). La opción final reinicia el camino o trayectoria (path) desde la posición actual. De esta manera el camino o trayectoria (path) va a continuar, repitiéndose. Sólo se muestran las primeras cinco repeticiones, pero el camino o trayectoria (path) continúa después de esto. En la barra de herramientas hay un importante número de controles. De izquierda a derecha encontramos los siguientes: El primer botón indica que nuestro camino o trayect oria está listo y se desea cerrar el formulario, manteniendo los cambios. Si se quiere descartar los cambios, presione la cruz para cerrar la ventana. El siguiente es el botón que regresar al último cambio realizado. La siguiente serie de botones en la barra de herramientas, permite borrar el camino o trayectoria (path) creando uno nuevo, el otro permite invertir el orden, y regresar por el camino o trayectoria (path), invertir el camino o trayectoria (path), hacer un reflejo en forma horizontal, darle vuelta en forma vertical, rotarlo, y escalarlo. Los siguientes son botones para cambiar la vista del camino o trayectoria (No el camino o trayectoria (path) en sí mismo; la vista del área actual se indica en la barra de estado al final). Como se indicó antes, después se pueden establecer o cambiar los valores de unión y cuando debe de ser mostrar la cuadrícula. Finalmente 82
- 83. hay un botón para indicar que se desea poner un cuarto, o nivel de juego en especial, como si de un telón de fondo se tratara para el camino o trayectoria (path). Usando esto se puede fácilmente poner y ajustar el camino o trayectoria (path), en un lugar específico del cuarto, o nivel de juego, por ejemplo en una pista de carreras, así más tarde dentro del juego la instancia del objeto seguir á la ruta correcta. (Esto solo tiene sentido cuando se usan caminos o trayectorias (paths) absolutos. Vea a continuación) 32.2.- Asignando caminos o trayectori as (paths) a l os objetos: Para asignar un camino o trayectoria a una instancia de un objeto se debe de poner la acción camino o trayectoria (path) en algún evento, por ejemplo en el evento crear. En esta acción deberás especificar el camino o trayectoria (path) a partir del menú desplegable. También hay otros valores que pueden ser cambiados. Se debe indicar el camino o trayectoria (path) a seguir y la velocidad en píxeles por paso. Cuando la velocidad es positiva, la instancia comienza al principio del camino o trayectoria (path). Si es negativa comienza al final. Recuerda que cuando se definió el camino o trayectoria (path), se especificó la velocidad actual como relativa. También existe una acción para cambiar la velocidad con la que se ejecuta el camino o trayectoria (path). Se podría, por ejemplo, usar esto para detener una instancia o acelerarla a través del camino o trayectoria (path). Observe que la velocidad normal de la instancia del objeto, se ignora (actualmente puesta a 0) cuando se ejecuta el camino o trayectoria (path). También cosas como la gravedad y la fricción no influyen, el movimiento a lo largo del camino o trayectoria (path). Lo siguiente es especificar el comportamiento al final, esto es, que debería pasar cuando se encuentra el final del camino o trayectoria (path). Se puede elegir entre detener el movimiento y finalizar el camino o trayectoria (path). También se puede reiniciar el camino o trayectoria (path) desde el comienzo, esto es, la instancia retrocede, saltando hacia la posición donde comienza el camino o trayectoria (path), y desde ahí se parte. Una tercera opción es reiniciar desde la posición actual, esto es, la instancia continúa por el camino o trayectoria (path) de nuevo, pero ahora con este nuevo punto de partida (esto es lo mismo que sí el camino o trayectoria (path) está cerrado). Finalmente se puede elegir en poner el movimiento en reversa, haciendo que la instancia retroceda a través de todo el camino o trayectoria (path). Observe que también ocurre un evento al final del path. Finalmente se puede indicar donde el camino o trayectoria (path) debe ser absoluto o relativo. Un camino o trayectoria (path) absoluto se ejecuta en el lugar donde fue definido. La instancia del objeto se ubica en el punto de inicio y desde ahí se mueve. (En la posición final cuando la velocidad es negativa). Esto es útil, por ejemplo, cuando tenemos una pista de carrera dentro de la cual se ha definido un camino o trayectoria (path). Al elegir el camino o trayectoria (path) relativo, las instancias comienzan ejecutando el camino o trayectoria (path) desde la posición en que están. Útil cuando una instancia deba hacer un movimiento local. Por ejemplo, la nave espacial del juego Space Invaders puede hacer un giro particular desde la posición en que se encuentre. Cuando se desee ubicar la instancia del objeto en un punto diferente a lo l argo del camino o trayectoria (path) se puede usar una acción para encontrar la posición del camino o trayectoria (path). La posición del camino o trayectoria (path) siempre estará entre 0 y 1, donde 0 indica la posición de partida y 1 la posición final. Observe que en cada paso la variable dirección está puesta en forma automática en la correcta dirección a lo largo del camino o trayectoria (path). Se puede usar esta variable para elegir la orientación correcta de la imagen (sprite). Cuando se usen scripts o piezas de código se tendrá un mejor control sobre la manera en que se ejecuta el camino o trayectoria (path). Hay una función de comienzo del camino o trayectoria (path) para la instancia del objeto. La variable path_position indica la posición actual en el camino o trayectoria (path) (entre 0 y 1 como se indicó más arriba). La variable path_speed indica la velocidad a través del camino o trayectoria (path). La variable path_scale se puede usar para escalar el camino o trayectoria (path). Un valor de 1 es el tamaño original. Un mayor valor indica que se debe de agrandar el camino o trayectoria (path), un valor menor lo hace más pequeño. La variable path_orientation indica la orientación en la cual el camino o trayectoria (path) debe ser ejecutado (en grados en la dirección de las manecillas del reloj). Esto posibilita ejecutar el camino o trayectoria (path) en una orientación diferente (por ejemplo moviéndolo arriba y abajo, como también a la izquierda y a la derecha. También hay una variable para controlar comportamiento final. Finalmente hay varias funciones que manejan las propiedades del camino o trayectoria (path), por ejemplo las coordenadas “x” y “y” en una cierta posición, y hay funciones para crear caminos o trayectorias (paths). También hay funciones que crean caminos o trayectorias (paths) libres de colisiones para que una instancia logre alcanzar la meta. Vea la sección de lenguaje del Game M aker para mayores detalles. Se preguntará que pasa cuando la instancia del objeto colisiona o choca, con otra dentro del camino o trayectoria (path). Básicamente lo mismo que pasa cuando la instancia está en movimiento. Cuando encuentra una instancia sólida, choca y retrocede a su ubicación previa. Si las instancias que se encuentran no son sól idas, siguen sus caminos, pero se ejecuta el evento de colisión y se revisa donde ocurrió este. Si no es este el caso, y la otra instancia es sólida, nuestra instancia se detendrá (asumiendo que hay un evento de colisión ya definido). La variable path_position no se incrementa. Cuando la instancia que bloquea el camino desaparece, la nuestra continuará a través del camino o trayectoria (path). Para el manejo de colisiones la variable path_position puede ser útil ya que contiene la posición previa del camino o trayectoria (path), entonces podemos cambiar la posición en el camino o trayectoria (path) cambiando esta variable, evitando el avance a lo largo del camino o trayectoria (path). 83
- 84. 32.3.- El evento fin del camino o de la trayectoria (Path): Como se describió anteriormente, se puede indicar que debe de pasar cuando la instancia alcanza el final del camino o trayectoria (path). En ese preciso momento ocurre el evento End of Path (final del path). Puede encontrarlo dentro de Other Events (otros eventos). Por ejemplo, podríamos destruir la instancia o hacer que comience en un nuevo camino o trayectoria (path), o que lo repita, etc. 32.4.- Un ejempl o de caminos y trayectorias: Hagamos un ejemplo, para comprender mejor todo esto, será algo sencillo, como lo que hemos venido haciendo solo para conocer mejor, el funcionamiento del Game M aker y sus funciones. Lo primero que necesitaremos en este caso es una imagen, para eso ocuparemos algo como una pelota que viene en la carpeta de sprites, en el Game M aker, entonces cargamos la imagen, con el botón load desde su ubicación y se escoge la pelota de tu gusto hay 3 para escoger, y como ya sabemos se vera así: Nota: si te fijas, bien en la imagen de a lado verás que la cru z que indica co mo se van a alinear las imágenes a las cuadriculas de los cuartos o niveles de juegos, no esta donde normalmente está, esto es porque presione el botón de centrar (Center), para mostrarte que no siempre es mejor dejar las cosa como están establecidas, pero si deseas que la posición sea otra solo coloca el cursor del Mouse sobre la cruz y muévela a la posición que tu desees. Das clic en OK y ahora te diriges a la carpeta paths y das clic derecho y seleccionas crear path, o te vas a menú Add, Add Path y de las dos formas llegaremos a la ventana que se vio arriba, crea un camino cualquiera o copia el del ejemplo recuerda solo es una práctica por el momento: Si aquí no ves el cuadro verde es porque el punto rojo esta sobre él. Solo nos resta dar en el botón de confirmación el que tiene una palomita verde, y ya quedo trazado nuestro camino o trayectoria, ahora vamos a los objetos y creamos un objeto a partir de la imagen que seleccionaste de la pelota o lo que sea que hayas puesto y en los eventos pones el evento de crear y vas a la pestaña de la derecha M ove y pones la acción set a path for instance. El resultado se debería de ver como en la siguiente imagen. 84
- 85. Al arrastrar y soltar la acción del path nos aparece la imagen que se encuentra a la izquierda, aquí nos pide path o sea el nombre del path que vamos a usar, la velocidad, yo la puse en 3, lo que pasará al terminarse el path, yo puse continuar desde el inicio, y lo últ imo lo deje co mo estaba, para que fuera un path relativo. Ahora solo nos resta crear nuestro cuarto o nivel de juego, y colocar el objeto que creamos en la posición de inicio del path en mi caso fue X=64 y Y=64. y se vería así. Solo nos resta guardar los camb ios en el cuarto y poner en marcha el juego, y veamos si la pelota sigue el camino que le trazamos. Si es así te felicito ya sabes ahora como crear tus caminos y trayectorias, pero recuerda que debes de practicar mucho, para realizar este proceso y que tus objetos sigan correctamente, los caminos o trayectorias que tu les indiques, pero como te habrás dado cuenta no es muy difícil conseguirlo. 33.- Las líneas de Tiempo (Time Line): Para crear una línea de tiempo (time line), elige Agregar Línea de tiempo (Add Time Line) en el menú Add. Se abrirá una nueva ventana, La cual es bastante parecida a la ventana de propiedades de los objetos. A la izquierda podemos cambiar el nombre de la línea de tiempo (time line) y agregar, eliminar y modificar los momentos. A su derecha, está la lista de momentos. Esta lista especifica los momentos en el número de pasos del juego (steps) que han transcurrido desde su asignación. M ás a la derecha, la lista de acciones asignadas a cada momento, y la lista de todas las acciones. 85
- 86. Para añadir un momento, pulsa el botón Add. Escribe el número de pasos que prefieras (el número de pasos, desde la asignación de la línea de tiempo (time line)) y se creará el momento. Ahora puedes arrastras acciones como si se tratara de un objeto. Para eliminar un momento pulsa Delete, para cambiar el tiempo del momento, pulsa Change, y para borrar todos los momentos, pulsa Clear. Con el botón Merge puedes mezclar todos los momentos en uno solo. Con el botón S hift puedes sumar o restar un valor de tiempo a todos los momentos que quieras. Ten cuidado con no crear momentos con tiempo negativo, ya que nunca se ejecutarán. Estas líneas de tiempo (Time lines) nos son de gran ayuda ya que en muchos tipos de juegos, algunas cosas deben suceder en ciertos momentos del tiempo. Puedes intentar hacer esto mediante eventos de alarmas, pero si hay muchos puntos en los que va a suceder algo, la cosa se complicará. Las Líneas de tiempo (Time lines) están pensadas para esto. En una línea de tiempo (time line) puedes especificar qué cosas, quieres que ocurran y en qué momento. Puedes usar todas las acciones disponibles que ya hemos conocido arriba. Una vez que creas una línea de tiempo (time line), puedes asignarla a un objeto. Dicho objeto ejecutará las acciones indicadas, y en los momentos indicados. 33.1.- Ejempl o de cómo usar las líneas de tiempo: Explicaremos como usar las líneas de tiempo con un ejemplo, que yo he creado, esperando te ayude a manejar las líneas de tiempo. Nuestro ejemplo tratara de una aldeana en mí caso, que se tendrá que mover al aparecer en la pantalla del juego 50 pasos a la izquierda, al llegar al paso 50 tendrá que cambiar de dirección hacia arriba y caminar otros 50 pasos, al llegar al paso 100 (suma los primeros 50 pasos y los 50 pasos que camino hacia arriba y de hay sale el paso 100), tendrá que cambiar de dirección hacia la derecha otros 50 pasos, y al llegar a los 150 pasos, cambiar nuevamente su dirección hacia abajo, moviéndose otros 50 pasos, para dar un total de 200 pasos, y al llegar a este punto detendremos su movimiento. Bien lo primero será conseguir un sprite, o crearlo con el programa Chara Set Maker, que si recuerdas lo mencionado arriba te sirve para crear sprites, yo en mi caso conseguí un sprite de una aldeana, que parece caminar en las 4 d irecciones. Así que una vez que tenga tu sprite, ya sea que lo hayas conseguido o lo hayas creado, y tengas abierto el Game Maker, nos disponemos a crear nuestros sprites animados, para eso seleccionas la opción de adquirir, para que se habrá la ventana de propiedades de los sprites, y en lugar de dar clic en el botón Load sprite, le das clic al botón Edit sprite, te aparecerá entonces la ventana del editor de sprites vacía, y te diriges al menú File, de hay seleccionas la opción de Create fro m strip, y ajustas las med idas al tamaño de tu personaje, posteriormente en numero de imágenes (number of i mages) pones 4, y en imagines por fila (images per row) pones también 4, para que de un solo paso obtengas la animación de la dirección en la que se este moviendo el personaje, das clic en el botón OK, y te regresara a la ventana del editor del Game Maker con la animación ya co locada, solo te resta dar clic en la palo mita verde, si la imagen luce bien para tu gusto, procedes de igual forma con las otras 3 animaciones. Creamos entonces la línea de t iempo, para nuestro personaje, para eso dirígete a la carpeta de las líneas de tiempo, o da clic en Add, y selecciona la opción adecuada. Te aparecerá la ventana de propiedades de las líneas de tiempo que ya vimos arriba, y co menzaremos a trabar en ella. Bien en mi caso yo le puse como nombre a la línea de tiempo t ml_ejemplo, después le di la orden de agregar un mo mento presionando el botón Add, me apareció la siguiente ventana: Pid iéndome que ingresara el mo mento, en que seria llevada la acción, que se va ha programar, yo le di el valor de 1, para que iniciara el movimiento de forma in med iata mi personaje, pero tu puedes indicarle el tiempo que consideres apropiado. Y al el step 0 arrastre la acción de movimiento con las flechas azules, y en donde dice direction le di un valor de 180, y en s peed un valor de 3, para que el movimiento inicial fuera hacia la izquierda, como lo 86
- 87. describimos arriba. Agregamos, entonces otro momento, y le damos como valor 50, y como queremos que se mueva hacia arriba, en dirección le damos un valor de 90 y en la velocidad lo dejamos en 3, pero ahora agregamos la acción de cambiar sprite, que es el que tiene un pac man rojo, y le indicamos que queremos cambiarlo por la imagen que parece que camina hacia arriba. A l llegar al paso 100 hacemos lo mismo indicamos la dirección a 0, la velocidad en 3, y cambiamos el sprite por el que camina hacia la derecha, al llegar al paso 150 damos una dirección de 270 con una velocidad de 3 y cambiamos el sprite por el que camina hacia abajo, y al llegar a paso 200, simplemente dejamos los valores de dirección y velocidad en 0, y colocamos la acción de cambiar el sprite, damos los siguientes valores a la imagen que se mueve hacia abajo, en subimagen damos un valor de -1 y en velocidad ponemos 0; esto hará que cuando nuestro personaje llegue al final del camino se quede parado en esa posición sin hacer ningún otro movimiento más. Ahora vamos a crear nuestro objeto que dará vida al personaje para eso seleccionamos Add object, por cualquier método de los que ya se vio, y seleccionamos como imagen al personaje que se mueve hacia la izquierda, en eventos pondremos el evento de creación, y de la pestaña M ain2 arrastramos a la ventana de acciones la de establecer una línea de tiempo, la del reloj de arena, nos aparecerá una ventana pidiendo el nombre de la línea de tiempo, en nuestro ejemplo se llama tml_ejemplo, la agregamos y dejamos el valor de 0 como esta, damos clic en el botón OK y eso seria todo. Ahora solo nos resta crear nuestro cuarto o nivel de juego agregar nuestro objeto en una posición adecuada, y aceptar los cambios en el cuarto o nivel de juego. Y corremos nuestro ejemplo, si todo salio como tenia que ser nuestro personaje se comenzara a mover hacia la izquierda, cambiando su dirección y de imagen en el momento indicado hasta llegar al final de la línea de tiempo. Nota (Si ves que tu personaje camina muy rápido esto lo puedes resolver, muy fácilmente cambiando la velocidad del cuarto o nivel de juego, en la pestaña settings, cambias el valor de speed por una menor a 30, debo decirte que, esto esta bien para nuestro ejemplo, pero si tu cambias esta velocidad en un juego, quizás otras imágenes que hayas agregado a ese juego se ejecuten de forma más lenta, la otra opción seria duplicar, el numero de imágenes de tu personaje, en el editor de imágenes, para realizar esto tienes que escoger por ejemplo la sub imagen 0, en el menu edit del editor, seleccionar la opción copiar, y después 2 o más veces la de pegar, esto agregara mas imágenes de la que estas copiando para dar un movimiento mas natural al personaje y haces lo mismo con todas las demás subimágenes, e imágenes del personaje, hasta que consigas el movimiento deseado y no parezca que va corriendo con la velocidad de 30 que trae por default el Game M aker para los cuartos o niveles de juego). Existen dos acciones de objeto relacionadas con las líneas de tiempo (time line). De las cuales te daremos información a continuación, una ya la usamos en el ejemplo pero es bueno que sepas bien que es lo que hace: 87
- 88. Set a time line (Fijar una línea de tiempo): Con esta acción asignas alguna línea de tiempo (time line), creada a un objeto. Debes indicar la línea de tiempo (time line), que se va a asignar y el tiempo en el que empezará, siendo 0 el comienzo de la línea. Esa acción también puede servirte para detener una línea de tiempo, seleccionando como línea de tiempo (No Time Line). Set the time line position (Fijar la posición de la línea de tiempo): Con esta acción puedes cambiar el momento de la línea de tiempo (time line), que se está ej ecutando. Puede usarse para saltar a ciertas partes de una línea de tiempo (time line), o para volver atrás. Para hacer un bucle (o sea que se repita una y otra vez), puedes hacer que al terminar la línea de tiempo (time line), se ejecute esta acción y se ponga el momento 0. La posición puede ser absoluta o relativa, por lo que si ponemos en un momento esta acción con valor –1 relativo, la línea de tiempo se detendrá. Esto puede ser útil, por ejemplo, en un juego de naves, para esperar a que se hayan destruido todos los enemigos para crear más. 34.- Scripts: Como ya se había mencionado antes; el Game M aker tiene su propio lenguaje de programación. Si sientes que ya estás familiarizado con Game M aker y quieres extenderlo al máximo, deberías empezar a usar este lenguaje. Hay dos formas de usar dicho lenguaje. En primer lugar puedes crear scripts, los cuales son pedazos de código a los que puedes dar un nombre. Puedes verlos en el árbol de recursos y pueden salvarse y cargarse desde un archivo. Pueden usarse también para crear una librería y extender aún más las posibilidades de Game M aker. En segundo lugar, puedes añadir una acción de código y escribir directamente cualquier código. Añadir acciones de código es lo mismo que escribirlos como scripts, con algunas diferencias, como que en las acciones no puedes usar argumentos. Las acciones de código, ni tienen nombre ni pueden usar argumentos. También tienes el cuadro de texto para indicar a qué objeto se aplicara el script. Luego solo tienes que introducir el texto igual que en una pieza de código. En este capítulo nos concentraremos en los scripts. Antes que nada, el lenguaje usado en un script es el lenguaje interno de Game M aker, (En adelante lo llamaremos GM L). Los scripts tienen variables que se dan al llamar al código. Son los llamados argumentos, que también son llamados parámetros. Para ejecutar un script en un evento, puedes usar la acción de script o la de código. Si eliges la de script, puedes dar valores para los 5 posibles argumentos. Si necesitas usar un script dentro de un código, se hace de la misma manera que se llama a una función del Game M aker. En este caso puedes dar hasta 16 argumentos. Los scripts pueden devolver un valor. Esto es útil para construir métodos matemáticos. (La palabra clave return se usa para esto). No se ejecutará ningún código después de que se devuelva un valor. Cuando un script devuelve un valor, puedes usarlo como una función que le da valores a otras acciones. Para crear un script al juego, elige Add S cript del menú Add. Aparecerá la siguiente ventana (en el ejemplo hay un pequeño script que calcula el producto de dos argumentos). (Este es el editor de scripts que incluye el Game M aker. En las preferencias puedes elegir un editor externo). Arriba a la derecha puedes indicar el nombre del script. Tienes un área de edición o escritura donde puedes escribir el código. Fíjate que en la parte inferior de la ventana, hay una sección donde cuando comiences a escribir tu código aparecerán todas las funciones, variables y constantes relacionadas a lo que estés escribiendo, y que usa el Game M aker. Esto te proporciona una pequeña ayuda extra. Puedes dar doble clic en una de estas funciones, variables o constantes para añadirla, o usa (Ctrl.) + P, para obtener el mismo resultado. Puedes hacer desaparecer esta lista en las preferencias (pero no se te recomienda hacerlo durante un tiempo hasta que te familiarices bien con el lenguaje de programación del Game M aker). El editor tiene muchas propiedades, disponibles en los botones de arriba (puedes pulsar el botón derecho del M ouse para ver algunos comandos alternativos): M últiples deshacer y rehacer. M ueve el cursor automáticamente para alinearse con la línea anterior (puede ser cambiado en preferencias). Tabuladores inteligentes que tabulan hasta el primer carácter (no espacio), en la línea anterior (puede ser cambiado en preferencias). Use (Ctrl.) + I para mover la línea elegida hacia la derecha, y (Shift), (Ctrl.) + I para moverla a la izquierda. Buscar y reemplazar. Usa (Ctrl.) + up, down, page-up, o page-down para moverte por el script sin cambiar la posición del cursor. Usa F4 para abrir el recurso en el que se encuentra el cursor (solo funciona en scripts). Posibilidad de guardar y cargar scripts en y desde archivos de textos. También tienes un botón con el que puedes verificar que el script, no tiene errores de escritura o que no haya alguna inexistencia de funciones usadas. Como ya habrás notado, algunas partes del código se colorean. El editor colorea las 88
- 89. funciones, variables, constantes, objetos, etc. Que reconoce. El color te ayuda a evitar errores, porque ves inmediatamente si has escrito mal un nombre o si estás usando una palabra reservada para una variable, de hay que tienes que darle nombres descriptivos a tus objetos. Los colores de código pueden ser algo lentos. En las preferencias puedes activar o desactivar esta opción. También puedes cambiar el color que aparecerá en los distintos tipos de palabras reconocidas. Puedes cambiar la fuente y el tamaño usado en los códigos (Si algo sale mal solo presiona la tecla F12 dos veces para desactivarlo y volverlo a activar, con los parámetros pre definidos). Los script son extremadamente útiles para extender las posibilidades de Game M aker. Esto sin embargo requiere que hagas los scripts muy bien. Los scripts pueden agruparse en librerías y añadirse a tu juego. Para importar una librería, usa Import scripts del menú file. Para salvar tus scripts usa Export scripts, en el mismo menú. Las librerías de script son simples archivos de texto (solo que con extensión .gml). Intenta no editarlos ya que tienen una estructura especial. Se incluyen librerías con algunos script muy útiles. (Para no sobrecargar el peso de un archivo, borra los script importados que no vayas a usar). Cuando escribes códigos siempre puedes tener errores. Comprueba siempre si has cometido dichos errores con el botón apropiado, no esta de más. Cuando se da un error durante el juego, aparece un mensaje indicando el script y la posición. Rara vez te saldrá el texto "Unexpected error occurred during the game". Este error se suele dar por errores de Windows o en el hardware. También puede deberse a la falta de memoria RAM disponible. Es decir, estos errores no tienen que ver nada con el Game M aker. Si quieres comprobar las cosas de mejor forma, utiliza el modo "debug". Aparecerá una ventana donde podrás ver y modificar las variables y propiedades del juego. En el menú Run puedes pausar el juego, reproducirlo paso a paso, y reiniciarlo. En el menú Watch puedes ver y cambiar el valor de ciertas variables. Usa Add para añadir una variable a la lista, y podrás ver su valor. Esto puede servirte para ver si el juego está haciendo las cosas como debe. Puedes ver muchas expresiones. Puedes salvarlo para usos futuros (por ejemplo, si corriges algo del juego). En el menú Tools puedes ver los comandos con más información. Puedes ver una lista de los objetos existente, todas las variables globales (bueno, las más importantes) y una variable local de cualquier instancia. También puedes ver los mensajes enviados con show_debug_message(str). También puedes dar comandos al juego y cambiar su velocidad. Es muy importante que aprendas a usar este menú para cuando desees hacer juegos muy complicados o largos. Para agregar un script, que ya hayas creado a tus juegos, dirígete a la pestaña de control y arrastra la acción del script, se te mostrara la siguiente ventana donde, deberás colocar el nombre del script, que deseas usar, y te dará la posibilidad de ingresar hasta 5 argumentos en esta forma de uso, una vez que selecciones el script apropiado y si no estas interesado en darle algún argumento por que quizás no es necesario, solo te resta dar clic en el botón OK. 35.- Terminando tú juego en modo avanzado: Cuando desees distribuir tu juego, es mejor que te asegures que posea todos los ingredientes necesarios para que sea un buen juego. También deberías proveer información sobre el juego, configurar correctamente las opciones, y tener cuidado con la velocidad. Esta sección trata estos aspectos. Información y recomendaciones sobre como finalizar tu juego puede ser encontrada en a continuación: 35.1.- Información del juego: Como lo ya lo vimos e hicimos antes, un buen juego le da al jugador algún tipo de información de cómo se debe jugar el juego. Esta información normalmente es mostrada cuando el jugador presione la tecla F1 durante el juego, cosa que le debes de informar. Para crear la información del juego, haz doble clic en Game Information, que se encuentra en el árbol de recursos a la izquierda de la pantalla, como ya se vio antes al crear la ventana de presentación para nuestro juego de ejemplo. El editor del Game M aker se abrirá y hay podrás editar la información del juego. Recuerda que puedes usar diferentes fuentes, colores y estilos y que también puedes usar un color de fondo distinto al establecido, es hora de conocer un poco más acerca de este editor. 89
- 90. En el menú File puedes modificar una serie de opciones. Aquí puedes indicar el título de la información del juego durante el mismo. También puedes indicar la posición (usa -1 para una posición centrada), y el tamaño de la ventana y si el usuario tiene permitido modificarlo. Puedes incluso elegir si el juego continuara su curso mientras esta ventana está visible (cosa que no se recomienda en la mayoría de los juegos), Una opción interesante es la de simular (mimic) a la ventana principal Cuando esta opción esté activada, la ventana de ayuda será mostrada exactamente en la misma posición y en el mismo tamaño que la ventana principal. Como resultado parecerá que la ayuda, se ve en la ventana principal del juego. Elige un color de fondo correcto para obtener un buen efecto visual. Para que el jugador salga de esta ventana debe presionar Escape, y seria una buena idea d arle la indicación de que debe presionar la tecla (ESC) para salir de la ventana de información y , ya sea el momento que pueda continuar o comenzar con el juego. Recuerda que es bueno hacer la información lo más breve, pero precisa. También podrías agregar tu nombre o sobre nombre, ya que tú creaste el juego, en algunos casos tal vez usaste piezas de códigos o scripts de otras personas, así que seria bueno darles sus créditos y lo puedes hacer aquí. Todos los archivos de ejemplos proveen en la información del juego información del mismo y como fue creado. S i quieres lograr una ayuda más imaginativa, deberás usar tu propio mecanismo para brindar al jugador la información del juego, como por ejemplo, hacer un cuarto dedicado a eso, donde el jugador puede aprender como jugar, tu juego. 36.- Opciones de configuración global del juego: Hay un número de configuraciones que puedes hacer para tu juego. Estos cambios pueden ser como modificar la forma de la ventana, fijar algunas opciones sobre los gráficos, tratar con opciones de interacción, la imagen de carga, constantes e información sobre el creador del juego. También puedes indicar aquí cuales archivos deberían ser incluidos en el archivo auto-ejecutable, y como deberían ser controlados los errores si alguno llegar a surgir. Estas configuraciones pueden ser modificadas haciendo doble clic en Global Game Settings en el árbol de recursos a la izquierda de la pantalla. Está dividido en un número de pestañas. (Algunas opciones están solamente disponibles en advanced mode). La información sobre las diferentes opciones se explicara en las siguientes páginas: 36.1.- Graphics: En esta pestaña puedes definir un número de opciones que tienen que ver con la apariencia grafica de tu juego. Es normalmente útil verificar todos los efectos de estas opciones porque tienen un efecto significativo en el diseño del juego. Recuerda que todos los usuarios tienen diferentes ordenadores. Asegúrate de que las opciones puedan funcionar en la mayoría de las computadoras de las demás personas. S tart in fullscreen mode (iniciar en modo de pantalla completa): Cuando activas esta opción el juego se ejecuta en pantalla completo. Desactivada se ejecuta en el tamaño que elegiste para la ventana. S caling (Escalado): Aquí puedes indicar que pasara cuando la ventana es más grande que el cuarto, o nivel del juego o cuando el juego se esta ejecutándose en pantalla completa. El cuarto, o nivel de juego es dibujado con el tamaño indicado. 100 indica ningún cambio en la escala. Usualmente lo usas cuando tus imágenes y cuartos, o niveles de juego son muy pequeños. La segunda opción es scale the room con esto llenas la pantalla, pero mantienes la misma relación en su aspecto. (Relación alto-ancho). La tercera opción es escalar hasta que la pantalla, este totalmente llena. Esto puede dar lugar a distorsiones en la imagen del juego, especialmente cuando el usuario cambie el tamaño de la ventana. Interpolate colors between píxels (Alinear los píxeles de colores): Cuando activas esta opción, los colores de los píxeles en imágenes, fondos, y mosaicos, que no están alineados con los píxeles en la pantalla serán interpolados. En particular se da cuando son escalados, rotados o colocados en posiciones no integradas. Interpolar hace los movimientos más suaves pero puede 90
- 91. dar un efecto borroso. También en los mosaicos se pueden tener brechas entre ellos si no están bien diseñados. Color outside the room region (Cubrir con un color, la región fuera del cuarto, o nivel del juego): Cuando el cuarto no cubre completamente la ventana, hay un área que no es usada. Aquí puedes especificar el color del área. Allow the player to resize the game window (Permitir al jugador definir el tamaño de la ventana): Con esta opción activada el usuario puede cambiar el tamaño de la ventana del juego posicionando el cursor a los costados de la ventana, y arrastrarla hacia adentro o afuera, para hacerla más chica o grande. Let the game window always stay on top (Colocar la ventana de juego en primer plano): Activada esta opción, el juego se ubica delante de otras ventanas (primer plano). Don't draw a border in windowed mode (No dibujar los bordes, ni la barra de titulo). Cuando actives esta opción, la ventana no tendrá borde ni barra de titulo. Don't show the buttons in the window caption (No mostrar los botones de la barra de titulo): Esta opción elimina los botones de cerrar ventana, minimizarla o maximizarla. Display the cursor (Mostrar el cursor): Indica si el puntero del M ouse será visible. Desactivarlo es normalmente rápido y mejor. (Puedes fácilmente crear tu cursor como un objeto más en el Game M aker). Freeze the game when the form looses focus (Congelar el juego, hasta que se regrese a el): Si el jugador ingresa a otra aplicación o realiza alguna acción fuera del juego, el juego se pausa hasta que el usuario regrese a la ventana del juego nuevamente (S e te recomienda habilitarla una vez terminados tus juegos). 36.2.- Resoluti on: En esta pestaña puedes definir la resolución con la que se ejecutara el juego. Por defecto la resolución no es cambiada. Pero algunas veces querrás ejecutar el juego en resoluciones más bajas o también indicar la frecuencia de actualización del monitor. Si quieres cambiar la resolución primero activa la opción llamada Set the resolution of the screen. Hay tres cosas que puedes cambiar. Primero que todo es la profundidad de color. Esto indica el número de bits usados para representar el color de un píxel. M uchos ordenadores solo tienen para 16-bit o 32-bit pero las computadoras antiguas soportan algunas veces 8-bit y 24-bit. El Game M aker solo trabaja correctamente en 16-bit y 32- bit; 32-bit representa muy bien las imágenes, pero consume más memoria y tiempo de proceso. Si quieres que tu juego funcione en la mayoría de ordenadores de bajas prestaciones cambia la profundidad de color a 16-bit. Segundo, la resolución de pantalla, el número de píxeles (horizontalmente y verticalmente) visualizados en la pantalla. Cambiar la resolución es útil cuando tus cuartos o niveles de juego, son muy pequeños. En este caso ayuda reducir la resolución de la pantalla. Observa que también afecta el funcionamiento de otras aplicaciones. Esto puede dar problemas en particular con bajas resoluciones. En general es mejor cambiar la resolución cuando el juego se esta ejecutando en pantalla completa. El Game M aker cambia automáticamente a la resolución anterior cuando el juego sea cerrado por el usuario. Finalmente puedes cambiar la frecuencia de actualización. Esto indica cuantas veces por segundo la imagen debe de ser actualizada. Si la velocidad del cuarto, o nivel de juego es mayor que la frecuencia de refrescado no todas las imágenes serán visibles. Funciona mejor si la frecuencia es un múltiplo de la velocidad del cuarto. (Si especificas una frecuencia que es muy alta la frecu encia no será modificada). Otra opción es "Use sincronización to avoid tearing" (usar sincronización para evitar roturas). Esto requiere de una explicación. Una visualización (entendida como imagen o conjunto, no necesariamente estáticas) es redibujada un número de veces por segundo, dependiendo de la frecuencia de actualización. Sin un cuarto o nivel de juego es dibujado a medias durante el refresco, la parte superior de la visualización aún mostrara la imagen antigua mientras la parte baja muestra la nueva imagen. Esto es llamado tearing (rotura). Para evitarlo, puedes seleccionar esta opción. En este caso la imagen del nuevo cuarto o nivel de juego será solamente copiada a la pantalla cuando el refresco sea finalizado. El próximo refresco mostrara la nueva imagen completa. Así sincronizamos el dibujado con el refresco. La desventaja es que tendremos que esperar a que se termine el refresco. Y puede haber un conflicto entre el tiempo interno del juego y la sincronización. Si quiere hacerlo mejor, asigna una frecuencia a un número redondo (por ejemplo: 60) e indica la velocidad del cuarto a 9999. Ahora el juego se ejecutara exactamente con 60 frames por segundo sin rotura. 36.3.- Other: En esta pestaña puedes definir un número de acciones adicionales. Primero puedes definir algunas teclas para ciertas acciones por defecto: Let <Esc> end the game Cuando lo habilitas, al presionar la tecla Escape termina el juego (Como ya te habrás dado cuenta viene predeterminada para realizar la opción de cierre). En los juegos más avanzados normalmente no quieres que esto pase de inmediato, porque tal vez quieras hacer algunos procesos (como guardar) antes de terminar el juego. En este 91
- 92. caso, deshabilita esta opción y provee tu propia acción para la tecla escape. (Dar un clic sobre la cruz de la ventana también genera un evento de la tecla escape.) Let <F1> show the game information (Mostrar la información del juego: Cuando está habilitado, presionando la tecla F1 muestra la información del juego, nuevamente tu podrías espesificar alguna otra tecla para este propósito. Let <F4> switch between screen modes (Activar los modos de cambio de pantalla): Si lo habilitas, la tecla F4 cambiará entre pantalla completa y el modo ventana. Let <F5> and <F6> load and save the game (S alvar y guardar un juego): Cuando está habilitado, el jugador puede usar F5 para guardar la situación actual del juego, y F6 para cargar la última situación del juego guardado. Game Process Priority También puedes indicar la prioridad del proceso del juego. Est a prioridad indica cuanto tiempo de procesador esta siendo asignado al juego. En modo normal, el sistema operativo trata de asignar tiempo de procesador a cada proceso que lo necesita de forma razonable. El más alto (Highest), indica que la mayoría del tiempo esta asignado al juego, haciéndolo funcionar más rápidamente (Los procesos de Windows asociados al ratón no podrían llegar a moverse, de forma adecuada en equipos antiguos, o con bajas prestaciones). Usa esto con cuidado. 36.4.- Loading: En seta pestaña puedes indicar lo que debe suceder cuando se cargas el juego. Primero puedes especificar una imagen propia de carga dando clic en el botón (Change Image). Después puedes indicar si se mostrará una barra del proceso de cargado en la parte baja de la imagen. Tienes tres opciones. Que no se muestre una barra de progreso, que se muestre la barra que está por defecto o puedes especificar dos imágenes: El fondo de la barra de cargado ( back image) y la imagen en primer plano (front image). Estas se ajustarán para obtener el tamaño adecuado. (En este caso debes de especificar ambas imágenes, no sólo una.) Es posible indicar que la imagen de carga deba ser transparente. En este caso el píxel inferior izquierdo es usado como color transparente. También la translucidez alfa puede ser indicada. Un valor de 0 determina que es completamente transparente. Un valor de 255 determina que es completamente opaco. (Ambos sólo trabajan bajo Windows 2000, XP, o posterior.) Después, puedes dar clic en el botón (Change icon) para indicar un icono que tu hayas creado y quieras usar, como icono en el juego ejecutable. S ólo puedes usar un icono de 32x32 píxeles. Si intentas seleccionar otro tamaño de icono obtendrás una advertencia, de que no es posible usar esa imagen. Finalmente puedes cambiar el identificador único del juego (Game Identifique). Este identificador, se usa para registrar los puntajes más altos y los juegos salvados. Si piensas liberar una versión de tu juego y no quieres usar los puntajes anteriores, debes cambiar este número (recuerda que mientras lo probabas obtuviste puntuaciones y tal vez guardaste algunos juegos, como parte del proceso de pruebas). 36.5.- Constants: Bajo esta pestaña puedes definir las constantes globales que pueden ser usadas en todos los scripts y piezas de código, o como valores para las acciones. Cada constante, tiene un nombre y un valor. Los nombres deben seguir las mismas reglas que las variables, o sea, que deben comenzar por una letra o guión bajo y enseguida consistir de letras dígitos o guiones bajos. Piensa que es altamente recomendable hacer todas tus constantes fácilmente distinguibles. Una convención usual es usar sólo letras mayúsculas y guiones bajos. Un valor de una constante debe ser una expresión constante. Es decir, que es o un número o una cadena de texto (entre comillas) o es una expresión. La expresión es evaluada antes que cualquier cosa suceda en el juego. Como por ejemplo no puede hacer referencia al escenario actual, instancias o scripts. Pero puedes obtener la recopilación de las constantes y nombres de recursos. Puedes agregar una constante usando el botón Add y borrarla usando Delete. Puedes cambiar a una constante el nombre o un valor haciendo clic en ella. Hay también botones para borrar todas las constantes, o para ordenarlas por nombre. 92
- 93. 36.6.- Include: Como se ha indicado antes, puedes crear versiones ejecutables de tu juego. Algunas veces tu juego podrá usar archivos adicionales. Por ejemplo podrías, querer incluir archivos de video o de texto que son usados en el juego. En algunos casos más avanzados, querrás agregar DLLs o imágenes y sonidos que serán cargados durante el funcionamiento del juego. Puedes proveer esto conjuntamente con el archivo ejecutable pero es algunas veces más fácil incluirlas en el archivo del juego. En este caso sólo un archivo necesita ser distribuido. Puedes indicar los archivos que quieres incluir en el ejecutable aquí. En la parte superior del formulario hay una lista de archivos a incluir. Usa Add para seleccionar archivos para agregar a la lista (puedes seleccionar múltiples archivos). Usa Delete o Clear para remover archivos de la lista. (Realizando esto los archivos no son incluidos en el archivo .gm6, sólo sus nombres. Cuando envías algo más el editable .gm6 debes también enviar los archivos a incluir.) Los archivos en la lista son empacados y guardados en el ejecutable que es creado. Cuando el juego está corriendo estos son desempacados y pueden ser accesados desde el juego. Es importante determinar dónde ocurre esto. Hay dos posibilidades que puedes elegir. En la situación por defecto, los archivos son desempacados en el directorio donde el archivo ejecutable está almacenado. (Esto es también el directorio de trabajo del juego). El juego usa los nombres de archivos para acceder a ellos (no son requeridas rutas). Esto trabaja bien si el ejecutable está almacenado por ejemplo en el disco duro, pero posiblemente podrá fallar si está almacenado en un dispositivo de sólo lectura, como puede ser un CD. La segunda posibilidad es indicar que los archivos deben ser desempacados dentro del directorio temporal que es creado durante el funcionamiento del juego. Si seleccionas esta opción necesitarás proveer la ruta al directorio temporal cuando uses el nombre archivo durante el juego. Esta ruta puede ser obtenida usando la variable de construcción temp_directory. No olvides agregar la reincidencia en este caso. Como por ejemplo reproducir un archivo de video puedes verlo en la siguiente pieza de código: { show_video(temp_directory+' movie.av i',true,true); } Realiza esto porque este directorio temporal es removido una vez el juego ha finalizado. Como por ejemplo no puedes almacenar juegos salvados o información especial en este caso. Sólo escoge esta opción cuando quieras correr el juego desde un CD o cuando no escribas ningún archivo con tu juego. Si un archivo que es desempacado ya existe éste normalmente no es escrito. Puedes cambiar esta opción marcando Overwrite existing files (Sobre escribir archivos existentes). También, cuando el juego ha terminado los archivos normalmente no son removidos (a menos que estén en el directorio temporal de trabajo que es removido completamente). Puedes cambiar esto marcando Remove at game end (Remueve todos los archivos del juego). Una nota de advertencia. Si tú estás probando tu juego, el directorio de trabajo del juego es el directorio donde esta el archivo .gm6 almacenado. Si incluyes archivos son también almacenados aquí y si eliges removerlos al final del juego piensa que ¡podrías también perder el archivo .gm6 ¡Por eso no almacenes esos archivos junto con el archivo .gm6! 36.7.- Errors: Aquí puedes apreciar un número de opciones que tienen que ver con la forma en que los errores son reportados. Display error messages (Muestra los mensajes de error): Si lo habilitas, los mensajes de error se muestran al jugador (excepto en modo exclusivo) En la versión final de tu juego deberías deshabilitar esta opción. Write error messages to file game_errors.log (Escribir y guardar todos los mensajes de error): Si lo seleccionas, todos los mensajes de errores son escritos en un archivo llamado game_errors.log dentro de la carpeta del juego. Abort on all error messages (Ignorar todos los mensajes de error): Normalmente ciertos errores son fatales, mientras otros pueden ser ignorados. Cuando habilitas esta opción todos los errores son considerados fatales y el juego es terminado. En la versión final del juego deberías habilitar esta opción. Treat uninitialized variables as 0 (Verificar que no se usa una variable sin valor): 93
- 94. Un error común es utilizar una variable antes de que tenga un valor asignado. Algunas veces esto es difícil de evitar. Cuando habilitas esta opción, las variables sin inicializar no reportarán un error pero se les asignará el valor de 0. Aún que debes tener cuidado. Esto significará que ya no serás informado de errores de escritura. 36.8.- Info: En esta pestaña, indicas el nombre del autor del juego (o sea el tuyo). La versión del juego (por defecto aparece 1.00), y alguna información acerca del juego. Además se muestra la fecha de la última modificación del juego (esta no la puedes modificar). Esto es útil si estás trabajando con varias personas en un juego o haciendo una nueva versión. Esta información no es accesible mientras se ejecute el juego, solo puede ser vista en los archivos editables o de ejemplos. 37.- Conside raciones de Velocidad: Si estas haciendo juegos complicados probablemente querrás hacerlos lo más rápidos posible. Si bien el Game M aker esta diseñado para que los juegos se ejecuten lo más rápido posible, depende mucho de como diseñes tu juego. Es muy fácil hacer juegos que usen mucha memoria. En esta parte, daremos algunos consejos para hacer tus juegos mucho más rápidos y ligeros. Primero, fíjate muy bien en las imágenes y fondos que usas. Las imágenes animadas consumen mucha memoria y dibujar muchas imágenes lleva mucho tiempo. Entonces haz tus imágenes lo más pequeñas posible. Elimina cualquier área invisible alrededor de la imagen -el comando crop (cortar) en el editor de imágenes lo hace automáticamente-. Lo mismo se puede aplicar a las imágenes de fondo. Si utilizas el modo de pantalla completa, asegúrate de que el tamaño del cuarto, o nivel de juego no sea más grande que el tamaño de la pantalla. M uchas tarjetas de video pueden aumentar imágenes de forma eficiente, pero resultan más lentas al disminuirlo. Desactiva el cursor siempre que te sea posible. Reduce la velocidad de dibujado de los gráficos (lo que se conoce como redibujado de pantalla). También presta atención al uso de muchas vistas. Ya que cada vista existente, en el cuarto, o nivel del juego es redibujada. Además de los gráficos, hay otros aspectos que tienen influencia en la velocidad del juego. Asegúrate de que utilizas el mínimo de instancias de objeto posible. Destruye las instancias de objetos que no se necesiten a lo largo del juego o para un próximo cuarto, o nivel de juego. También lleva mucho tiempo ejecutar las acciones en los eventos paso y dibujar. A menudo las cosas no necesitan ser comprobadas en cada paso. La interpretación de código es razonablemente rápida. También, algunas funciones y acciones toman mucho tiempo; en particular esas que verifican todas las instancias de objetos -por ejemplo la acción rebotar (bounce)-. Piensa también en como tratas los eventos de colisión. Normalmente tienes dos opciones. Los objetos que no tienen eventos de colisión son mucho más fáciles de manejar, entonces preferentemente trata las colisiones en aquellos objetos que solo tengan algunas instancias. Ten cuidado cuando usas archivos de sonidos largos. Ya que estos consumen mucha memoria y se pueden llegar a comprimir mal. Verifica tus sonidos y deja solamente los que realmente te serán útiles. Finalmente, si quieres hacer un juego que mucha gente p ueda jugar, asegúrate de probarlo en distintos ordenadores, nuevos o de bajas prestaciones. 38.- El Lenguaje de programación del Game Maker: Game M aker contiene un lenguaje de programación propio. Este lenguaje de programación te da mucha más flexibilidad y control que las acciones estándar. Este lenguaje es denominado GM L (The Game M aker Language), y a partir de aquí al referirnos a él lo haremos como GML. Hay diversos lugares donde puedes escribir códigos con este lenguaje. Primero que todo, cuando def ines un script. Un script es un programa en lenguaje del Game M aker. También cuando agregas una acción de código. Además, puedes hacerlo en la creación de código del cuarto, habitación o nivel del juego ( Room Creation Code). En este capítulo describiremos la estructura básica de los programas con Lenguaje de programación del Game M aker (GM L de ahora en adelante). Cuando quieras usar programación con el GM L, hay algunas cosas que debes de tener en cuenta. Para empezar, para todos tus recursos (imágenes, objetos, sonidos, etc.) deberán usar nombres que empiecen con una letra y solo consistan de letras, dígitos y guiones bajos “ _”. Ya que de otra forma, no podrás referirte a ellos de forma fácil con en el GM L. Asegúrate de que todos los recursos tengan nombres diferentes. También ten en cuenta de no nombrar a ningún recurso con palabras claves, porque son palabras reservadas por el 94
- 95. lenguaje de programación (como por ejemplo if, else, other, self, all, global, etc.). Estas palabras claves se pueden ver más abajo. Información sobre el lenguaje del Game M aker, en general puede ser encontrada en las siguientes páginas: 38.1.- Un programa: Un programa consiste en un sistema de instrucciones, llamadas bloques, un bloque consiste de una o más declaraciones. Un programa debe comenzar con el símbolo de apertura de llave “{” y finalizar con el símbolo de cierre de llave “}”. Entre estos símbolos se ponen los bloques de instrucciones. Cada uno de los bloques se deben separar con punto y coma “;”. La estructura global de todo programa es entonces: { <declaración>; <declaración>; ... } Hay un número de diversos tipos de declaraciones, que serán vistas más adelante. 38.2.- Explicaci ón sobre las variables: Antes de continuar y debido a que hemos llegado a uno de los conceptos más importantes a aprender, si queremos realizar juegos más completos o complejos, trataremos de explicar, lo que son las variables de forma sencilla, podemos decir que una variable es un nombre que hace referencia a un valor. Una muy buena analogía o comparación, es la que compara a una variable con un cajón de un archivero con una etiqueta en su parte delantera; esa etiqueta es el nombre de la variable, con el que la usamos. El contenido del cajón es el valor al que hace referencia el nombre de esa variable. Pero, ¿Cuál es el sentido de las variables? o mejor ¿para qué podemos querer usar una variable? Bueno, la respuesta es que las variables nos permiten realizar programas más complejos que puedan llegar a ser modificados con facilidad mediante su buen uso y entendimiento. Pensemos, por ejemplo, en un programa que permita elegir el nivel de juego; tenemos que programarlo para que sea cual sea la respuesta del jugador, el juego en sí no cambie. Esto se puede solucionar incrementando la velocidad del juego, controlado por la computadora desde una variable cuyo valor cambia (o varía) de acuerdo al nivel elegido por el jugador. También podemos usar variables cuando queremos realizar cálculos que estén basados en una fórmula, como por ejemplo el área de un círculo; sabemos que dicha área se calcula usando la fórmula área =r2 x pi donde r es el radio del círculo. Por lo tanto el área del círculo varía al cambiar el valor de r; en este ejemplo r es una variable. El Game M aker utiliza las variables más importantes de un juego de una forma casi transparente; así la cantidad de puntos que obtiene el jugador, la cantidad de vidas o la cantidad de energía son variables que son usadas de una forma automática y casi transparente para el jugador. Pero ¿qué pasa si en vez de un jugador tenemos que llevar los puntos, la energía o las vidas de dos jugadores? Bueno obligatoriamente tendremos que hacer uso de las variables. 38.3.- Particulari dades de l as variables en el Game Maker: En el Game M aker no es necesario d eclarar las variables antes de usarlas; esto quiere decir que, a diferencia de la gran mayoría de los lenguajes de programación, no tenemos primero que usar una orden para que el Game M aker sepa que existe una variable con ese nombre, sino que podemos directamente darle a la variable un valor y el Game M aker fabrica el cajoncito. Y le pone el nombre que nosotros le hemos dado. Hay dos tipos de valores que podemos guardar en las variables del Game M aker: las de números (reales) y las de texto o cadenas (string). Las variables numéricas nos servirán para almacenar números tales como cantidad de vidas, disparos que nos quedan o monstruos que debemos derrotar. Las variables de texto o cadena (string) sirven para guardar palabras o conjuntos de caracteres (inclusive números de tipo cadena, que son los que llevan comillas simples o dobles), pero considerados como mensajes, no como valores con los cuales hacer cuentas. No hace falta configurar nada para que sea una variable real o de texto (string), depende simplemente de lo que le des o asignes como valor. Hay un número de variables internas dentro del Game M aker, algunas son generales como M ouse_x, o M ouse_y, las cuales indican la posición actual del cursor. Una variable tiene un nombre que debe de comenzar una letra; y puede contener solo letras, números y el guión bajo “_”. (Si ya sé que lo estoy repitiendo mucho pero es importante que lo recuerdes). Las variables como ya se dijo pueden ser de dos tipos de acuerdo al alcance que tienen, es decir, qué objetos o instancias la pueden usar: si no declaramos nada la variable sólo se puede usar en la instancia en la que aparece. Para poder usar la variable entre distintas instancias de diferentes objetos tenemos que declarar que es una variable global; esto lo hacemos cuando le damos un nombre, después de la palabra global y un punto, en vez de poner pelota ponemos por ejemplo global.pelota. Nosotros usaremos casi siempre variables globales (de preferencia, en algunos casos pueden no ser convenientes, pero en la gran mayoría de las ocasiones lo puede ser), nuestras variables serán globales para que todas las instancias de los objetos las puedan utilizar; así podríamos poner por ejemplo: 95
- 96. global.nombre global.vidas1 Veamos algunos ejemplos, para crear una variable lo único que debes de hacer es un código como este: variable_cualquiera = 0 -- real, ya que es un número variable_cualquiera = „Hola mi amigo‟ --- (string) ya que usa letras En el caso de que pongas: variable_cualquiera = '0' ---también será una cadena (string), debido a las comillas que tiene el cero, estas pueden ser simples como en el ejemplo o dobles “” recuérdalo. M aneras de modificar una variable: Atención antes de emplear las variables recuerda que tienes que darles un nombre. No puedes relacionar una variable del tipo cadena (string) con una variable real (numérica) ya que son variables distintas. Nota: Lo que aparece en verde es solo un comentario no realiza ninguna acción, y te lo marco de esta manera, porque al momento en que utilices los scripts o piezas de código así es como podrás agregar comentarios sobre las acciones que estas realizando dentro de tu juego, ya que al poner las dos líneas inclinadas //, estarás indicando al Game M aker que todo lo que siga después de estas líneas es un comentario. Ejemplo: a = 0 //a es igual a cero b = 1 //b es igual a 1 c = a+b // c es igual a + b (esto hará que la variable c sea = 1) Puedes sumar -- c = a+b restar --- c = a-b multiplicar --- c = a*b dividir --- c = a/b y muchas cosas más. Con las cadenas (strings), puedes usar la suma también, por ejemplo: a = 'hola' b='a' c = 'todos' d = a+b+c (el resultado seria d = a 'hola a todos'). Como se dijo antes también las variables pueden ser globales, las cuales afectan a todos los objetos y cuartos, o niveles de juego, o locales que solo afectan a un objeto. Para que una variable sea global tendrás que poner algo como esto global.pelota = 0. ATENCIÓN: No es lo mismo (pelota) que (global.pelota), son variables distintas como ya se menciono arriba. Si ponemos solo pelota, la variable es local y solo afecta a ese objeto, llamémoslo objeto0. Si quisiéramos sumar una variable local por ejemplo con una variable local del objeto0 y el código estuviese en un objeto de nombre objeto1 el código a poner seria este: Variable = global.a + objeto0.b Por ultimo uno de los scripts que te deben de interesar para manejar variables son estos: Variablereal = get_integer(str,def) variablestring = get_string(str,def) El primero es para una variable real, y el segundo para una cadena (string), donde pones (str) tienes que poner el mensaje que se muestra como por ejemplo '¿Que edad tienes?' o '¿Cual es tu nombre?', y en (def) es el valor que por default que se mostrara 'pon aquí tu nombre' o '0'. 96
- 97. Una vez que se ha tratado de explicar que son y como se declaran las variables continuemos, con un ejemplo dentro de un juego primero: Vamos a crear una carrera donde dos hombres corran de izquierda a derecha hasta llegar a una meta; el primero en llegar será, como corresponde, el ganador y el programa nos tiene que hacer saber quien fue el ganador. Antes que nada comenzaremos desarrollando la idea del juego, como se explico en las páginas iniciales de este manual, recuerda que al hacer esto nos puede ahorrar mucho tiempo. 38.4.- Uso de las Variables en los juegos (Ejemplo): Comencemos con la planeación y descripción del juego: Hay una pista y dos corredores que comienzan sin moverse a la izquierda de la pantalla; al presionar el botón izquierdo del M ouse estos personajes salen corriendo y se mueven al azar, de forma que no podemos saber quien ganará. Al cruzar la línea de llegada el programa nos tiene que decir quien ganó y, luego de dos segundos, debe volver a poner a los personajes en la posición inicial. Usaremos variables para que, una vez que uno de los corredores haya llegado a la meta, la carrera se acabe y se reinicie el juego. Otra variable que usaremos es la que contendrá el nombre del ganador para poder mostrarlo en la pantalla al finalizar la carrera. Primero agregaremos el fondo, que será una imagen de una pista de carreras, (tienes que crearla), puede ser una línea verde solamente pero lo suficientemente gruesa o ancha para que entren nuestros dos competidores. Continuamos definiendo las imágenes que vamos a usar, que serán tres, para cada uno de los competidores (¡son animados, para que parezca que van corriendo!) y uno para el botón de Inicio. En cuanto a los objetos que vamos a agregar, serán cuatro, ya que tenemos que poner uno por cada competidor, uno para el botón Inicio y un objeto Control, que será el que mueva a los corredores y verifique a ver si alguno de ellos llegó a la meta. Definimos, pues, un objeto (recuerda puedes darle el nombre que quieras a mi se me ocurrieron estos), Pepe con la imagen sprPepe; el otro objeto, Tito con la imagen sprTito, un objeto inicio con la imagen sprInicio y un objeto control, sin imagen. Lo interesante de este juego es que los corredores (Tito y Pepe) no tienen eventos, ni acciones definidas; donde sí programaremos los eventos y las acciones, es en los objetos Inicio y Control. El objeto Inicio será un botón que al ser presionado tocará el sonido comenzar_carrera, y creará un objeto control y le dará un valor inicial a las variables. Usaremos una variable para saber si alguno de los corredores llegó a la meta, por lo tanto parece razonable llamarla global.llego; esta variable sólo tomará dos valores posibles: 0 si nadie llegó a la meta y 1 cuando un corredor pase la línea de llegada (que está ubicada en nuestro ejemplo a los 600 píxeles). La otra variable será para guardar el nombre del ganador de la carrera, entonces, le llamaremos global.ganador; tendrá como valores posibles, (nada) o los nombres de los corredores (Pepe y Tito). Como todo esto tiene que pasar cuando el jugador presione el objeto Inicio, programaremos el evento botón izquierdo del M ouse (Event LeftButton) para el objeto Inicio como se ve en la siguiente figura: La acción Create instance (Crear una instancia) es la bombita de luz o foco, que aparece en primer lu gar en la pestaña main1. -la segunda solapa- y, al ser arrastrada a la lista de acciones, nos muestra una ventana, donde podemos elegir de qué objeto vamos a crear la instancia del objeto y en qué punto de la pantalla lo haremos. En nuestro caso crearemos una instancia del objeto control, que como no tiene imagen (sprite) asociado no será visible y por lo tanto no nos interesará modificar el punto de creación. En lo que respecta a las variables, hay tres acciones que tratan el manejo de ellas y que se encuentran en la pestaña de control, la cuarta. Estas acciones son: Darle o fijar un valor a una variable (Set the value of a variable). Verificar si una variable tiene un valor (If the value of variable is). M ostrar el valor de una variable (Show the value of variable). 97
- 98. Usaremos en este evento, la acción de Set the value of a variable (Darle o fijar un valor a la variable) fíjate en la imagen de arriba para identificar la acción si no recuerdas cual es. Al ser arrastrada a la lista de acciones, muestra una ventana donde se le puede dar el nombre y el valor a la variable, como se ve en la figura de al lado. De esta forma vamos definiendo las dos variables y, una vez que el objeto. Inicio nos quedó como en la figura superior, lo cerramos y pasamos al objeto control, que es el más complicado. En el objeto control la mayor parte de las acciones las ejecutaremos en el evento paso (Event Step), que es un evento que se ejecuta cada vez que el programa da un paso -y en general da 30 pasos por segundo, a menos que tu lo modifiques-, o sea que las acciones que pongamos en este evento se estarán ejecutando constantemente. Bien ¿Qué queremos que haga el objeto control? Pues queremos que mueva a los competidores una cantidad de pasos al azar, que luego de haberlos movido verifique si pasaron de la meta y, en caso de que así sea, que termine esta carrera y reinicie el juego. Es importante que la verificación de la llegada, sea realizada para los dos competidores por separado; repetimos el código cambiando un corredor por el otro. La acción de moverse tiene que tener estas particularidades: Se mueve al objeto Pepe (y luego lo haremos con el objeto Tito) Se mueve hacia la derecha La velocidad es al azar hasta un máximo de seis ver la siguiente imagen. Repetimos para el objeto Tito. Hay dos variables propias del Game M aker que permiten saber la posición de cada objeto en la pantalla: “ x” y “y”. Para poder usarlas ponemos el nombre del objeto, luego un punto y finalmente x o y. Ejemplo: Pepe.x es la posición horizontal del corredor Pepe Nuestro objeto control debe de ir quedando así 98
- 99. Una cosa que se me estaba pasando en la acción de movimiento tienes que poner la velocidad como random(6), para que sea una velocidad al azar con un máximo de velocidad de 6, y debes indicar a que competidor se le dará esta velocidad, entonces esta acción te debe de quedar como se ve en la imagen siguiente: Tenemos que verificar ahora si Pepe llegó a la meta primero; para esto usaremos otra de las acciones relativas a las variables (en la solapa .code): If a variable has a value (si la variable tiene un valor). Esta acción pertenece al grupo de las condiciones, aún que se encuentra en otra pestaña: permite realizar una acción o conjunto de acciones sí y sólo sí (if) una variable tiene un cierto valor. La condición que tiene que cumplirse es que la variable Pepe.x tiene que, ser igual o mayor que (=>) 600 (que es donde está la línea de llegada); por lo tanto, sí (if) Pepe.x es igual o mayor (=>) a 600, quiere decir que Pepe llegó a la meta. Arrastramos la acción condicional al objeto control y nos pregunta el nombre de la variable le ponemos (Pepe.x), el valor con el que la queremos comparar (600) y la forma de la comparación, que puede ser M enor que (<), Igual a (=), o M ayor que (>). Elegimos M ayor que (>) (Larger than), para nuestro ejemplo como se ve en la siguiente figura: A continuación queremos que, si se cumple la condición (Pepe llegó a la meta) se guarde en la variable ganador el nombre de Pepe y se ponga en la variable llego el valor 1 para indicar que alguien llegó a la meta y por lo tanto la carrera se tiene que terminar. Como hay que realizar dos acciones si se cumple la condición tenemos que usar un bloque: Nota: Podemos agrupar acciones para que se ejecuten al cumplirse una condición usando bloques. Estos bloques se comienzan y terminan con los íconos que se muestran al lado y que están en la solapa control. Por lo tanto, luego de la condición, comenzamos un bloque. A continuación le damos el valor antes dicho a cada una de las dos variables -son dos órdenes diferentes- y finalmente cerramos el bloque. Debería quedar como se ve en la siguiente figura: Observa que en la variable global ganador el valor Pepe esta escrito entre comillas, esto es así para que aparezca el nombre del ganador, ya que si solo pones Pepe, el resultado será el ganador es 1, o 2 dependiendo quien llegue a la meta primero, así que si quieres ver el nombre de tu competidor ponlo entre comillas. De forma totalmente similar debería, quedar la parte de de nuestro corredor llamado Tito, cambiando Pepe por Tito: Nos falta verificar si alguien llegó a la meta, para lo que hemos creado la variable global.llego; tenemos que ver si esta variable vale 1, lo que indicar ía que alguno de los competidores finalmente cruzó la meta. Si global.llego vale 1 queremos reproducir el sonido snd_llego, esperar dos segundos y finalmente reiniciar el juego. 99
- 100. Como tenemos que realizar varias acciones en el caso de que global.llego valga 1 usaremos una vez más un bloque. En el evento step, del objeto control. Tanto la acción de esperar como la de reiniciar el juego están ubicadas en la pestaña .main2. (La tercer pestaña). Al poner la acción de Pausa (sleep) nos pregunta cuantos milisegundos queremos que espere el programa antes de continuar con la siguiente acción; como queremos que espere dos segundos, ponemos 2000. La acción reiniciara el juego no requiere parámetros, sólo la agregamos y ya está. Terminamos el bloque con el icono de finalizar bloque y toda esta sección debe quedar como en la figura de a lado: Nos está faltando que el programa muestre el nombre del ganador una vez que este cruzó la meta; para esto, y siempre que tengamos que mostrar algún valor en la pantalla, usaremos el evento Draw (Dibujar) en este caso dentro del objeto control. Queremos que aparezca la palabra Ganador en una posición determinada de la pantalla y, a continuación, el nombre del ganador; antes de escribir una palabra en la pantalla vamos a cambiar el tipo y tamaño de la letra para que lo que escribamos allí sea fácilmente visible, o si deseamos usar otro tipo de letra, distinto al preestablecido. Tanto para cambiar el tamaño y tipo de la letra como para escribir un mensaje en la pantalla debemos usar las acciones que aparecen en la pestaña draw. (Dibujar, la última solapa comenzando desde arriba), como se ve en la figura siguiente: Al arrastrar la acción cambiar el tipo de letra simplemente elegimos el tipo de letra que hallamos añadido anteriormente en la carpeta fuentes o dejamos la que viene por defecto, seleccionamos el tamaño que nos agrade (o que entre en el espacio que tenemos, que no siempre es lo mismo), también puedes cambiar el color que se usara para dibujar el texto, seleccionando la acción Set the color, ahí eliges el color que más te agrade para tu juego, mientras que cuando arrastramos la acción de escribir un mensaje se abre una ventana (la de al lado derecho) donde escribimos el mensaje que queremos y le indicamos en qué coord enadas deseamos ubicar el mensaje; ponemos los valores x = 192 y y = 304 en mi caso, esto hará que el texto sea dibujado en esta área del cuarto, o nivel del juego. Como se ve al lado: La acción de mostrar el valor de una variable está, como ya hemos visto, en la pestaña control y tiene el nombre de Draw the value of a variable (Dibujar el valor de una variable). En realidad es muy similar a mostrar un mensaje, con la diferencia de que en vez de un mensaje tenemos que mostrar una variable, como se ve en la figura siguiente, en la que yo e puesto las coordenadas x=340 y y=304 para que aparezca después de las palabras El ganador es: 100
- 101. Una vez que hemos agregado todas nuestras acciones en el evento Draw se debería de ver de la siguiente forma. Para poder considerar que el juego está terminado escribimos la información del juego y ya está, ¡a disfrutarlo! El resultado de todo esto se vería más o menos así, dependiendo de la forma que tú hayas hecho tu fondo, e imágenes. En mi caso como puedes ver los corredores son muy pequeños, y el publico espectador es muy grande, como solo se trataba de un ejemplo no es muy importante este detalle de perspectiva, pero si piensas vender tus juegos debes de tener en cuenta estos detalles, ya que como verás no lucen bien. Ahora quizás quieras agregar otro competidor para que la carrera sea más interesante. O piensa en que modificaciones les puedes hacer al juego, para hacerlo más entretenido. Repaso: Las variables son nombres que hacen referencia a un valor; este valor cambia y de ahí el nombre de variables. Sólo usaremos variables globales (que conserven su valor en todas las instancias o lugares del juego) y por lo tanto siempre las escribimos por ejemplo como: global.ejemplo. Sigamos ahora con el tutorial, pues espero que con esto quede claro que son y como se usan las variables. 38.5.- Asignaciones: Una asignación almacena un valor en una variable. Una asignación tiene la siguiente estructura: Variable = exp resión; Una expresión puede ser un valor simple pero puede también ser algo más complicada. Además de asignar un valor a una variable, también se le puede agregar un valor, al valor actual de la variable usando + = similar, puedes restarle un valor usando - =, multiplicarla usando * =, dividiéndola usando /=, el uso de otros los operadores también existen por ejemplo, o usando |=, &, ^=. (Esto solo funciona para variables que contengan valores reales (numéricos) y expresiones, no para las variables de cadena o texto (string)). 101
- 102. 38.6.- Expresiones: Las expresiones pueden ser número reales (por ejemplo 3.4), números hexadecimales, comenzando con el signo $ (por ejemplo $00FFAA), cadenas entre comillas simples o dobles (por ejemplo 'hola' o “hola”) o expresiones más complicadas. Para las expresiones, existen los siguientes operadores binarios en orden de prioridad: &&, ││ (Para agregar una línea similar a las anteriores presiona la tecla Alt, y 179 suelta Alt, y listo), donde los símbolos && se utilizan para la función and, y las líneas ││ para la función. <,<=,==, !=,>,>=: Son comparaciones, dando un resultado entre true (1) y false (0). │ & ^ (Para agregar la flecha hacia arriba usa Alt, 94): Operadores a nivel de bit (│= bitwise or, &= bitwise and, ^= bitwise xor). <<, >>: Operadores a nivel de bit (<<= shift left, >>= shift right). +, -: Valores de suma y resta. *, /, div, mod: (Valores de multiplicación, división, división entera, y modulo respectivamente). Nota que el valor X div Y es el valor de x/y, redondeado al numero mas cercano al cero. El operador mod devuelve el resto obtenido dividiendo sus operadores; en otras palabras X mod Y = x-(x div y) * y. Aquí se muestran unos ejemplos y que debería de suceder en cada uno de ellos. Boolean functions (Funciones Boleanas): &, &&, and. Tanto esta declaración como la siguiente declaración deben ser verdaderas p ara poder continuar. Por ejemplo : if statement_a && statement_b then { //hacer este código } El código sólo será ejecutado si tanto la declaración A, como la declaración B son verdaderas. En una tabla esto sería... Declaración A Declaración B Resultado Final True False False False True False False False False True True True |, ||, or Si al menos una declaración es verdadera el código será ejecutado. if statement_a || statement_b then { //hacer este código } Entonces el código será ejecutado a no ser que ambas declaraciones sean falsas. En una tabla: Declaración A Declaración B Resultado Final True False True False True True False False False True True True ^, ^^, xo r Si al menos una declaración es verdadera el código será ejecutado a no s er que ambas declaraciones sean verdaderas. 102
- 103. if statement_a ^^ statement_b then { //hacer este código } Entonces el código será ejecutado, a no ser que ambas declaraciones sean falsas o ambas sean verdaderas. En una tabla: Declaración A Declaración B Resultado Final True False True False True True False False False True True False 38.7.-Comparaci ones: =, == Resultado verdadero (1) o falso (0). Esto quiere decir que, tanto esta declaración como la siguiente declaración debe ser igual para seguir. Por ejemp lo: if nu mber_a != nu mber_b then { //hacer este código } El código sólo será ejecutado si ambos números son iguales. Si nu mber_a es 5 y number_b es 5 esto causará verdadero y el código será ejecutado. Pero si number_b no es igual a nu mber_a no será verdadero y no será ejecutado. != Resultado verdadero (1) o falso (0). Esto quiere decir que esta declaración no debe ser igual a la siguiente declaración Por ejemp lo: if nu mber_a != nu mber_b then { //hacer este código } El código sólo será ejecutado si number_a no es igual a number_b. Si nu mber_a es 5 y number_b es 5 el resultado será falso mientras con cualquier valo r de nu mber_b además de 5 será verdadero. < (menor que) Resultado verdadero (1) o falso (0). Esto quiere decir que el primer número de be ser menor, que el segundo número para que esta función devuelva a verdadero. En los otros casos esto volverá falso. if nu mber_a < nu mber_b then { //hacer este código } Resultado verdadero (1) o falso. Por ejemp lo asumimos que number_a = 5 entonces ten drá: Nu mber_A Nu mber_B Resultado 5 4 False 5 5 False 5 6 True 103
- 104. <= (igual o menor que) Resultado verdadero (1) o falso (0). Esto quiere decir que el primer número debe ser menor o igual al segundo número para que esta función devuelva a verdadero. Además esto volverá a falso. if nu mber_a <= number_b then { //hacer este código } Por ejemp lo asumimos que number_a = 5 entonces tendrá: Nu mber_A Nu mber_B Resultado 5 4 False 5 5 True 5 6 True > (Mayor que) Resultado verdadero (1) o falso (0). Esto quiere decir que el primer nú mero debe ser mayor que el segundo número para que esta función devuelva a verdadero. Además esto volverá a falso. if nu mber_a > nu mber_b then { //hacer este código } Por ejemp lo asumimos que number_a = 5 entonces tendrá: Nu mber_A Nu mber_B Resultado 5 4 True 5 5 False 5 6 False >= (igual o mayor que) Resultado verdadero (1) o falso (0). Esto quiere decir que el primer nú mero debe ser más grande o igual al segundo número para que esta función devuelva a verdadero. Además esto volverá a falso if nu mber_a >= number_b then { //hacer este código } Por ejemp lo asumimos que number_a = 5 entonces tendrá: Nu mber_A Nu mber_B Resultado 5 4 True 5 5 True 5 6 False Otros: + Adición : El símbolo su ma los valores, que se encuentran antes y después devolviendo el resultado. - Substracción: Resta los valores, que se encuentran antes y después devolviendo el resultado. * Multiplicación: Multip lica los valores antes y después del signo, devolviendo el resultado. / Div isión: Div ide los valores dados y devuelve el resultado. div: Div isión de número entero: 104
- 105. (a) div (b) devolverá el valo r a/b dado, redondeando al número entero más cercano. Así por ejemp lo si 9/2 = 4.5 el redondeo dará 4. mod Módulo: (a) mod (b) devolverá el nú mero que permanencias dividiendo un número. Por ejemp lo dividiendo 9 por 2, notarás que 2 entra en nueve 4 veces, con 1 izquierdo. Mod devolverá 1 ya que todavía tienes 1 como valor izquierdo que no se puede dividir. También, los siguientes operadores unitarios están disponibles: !: no lógico, convierte verdadero a falso y falso a verdadero -: niega el siguiente valor, cambiando su signo. ~: niega el s iguiente valor cambiando su signo a nivel de bits. Como valores puedes usar números, variables, o funciones que regresan un valor. Algunas expresiones secundarias pueden ser puestas entre paréntesis. Todos los operadores funcionan con valores reales. Las comparaciones también funcionan para las cadenas y + concatena (une) cadenas. (Por favor nota que, contrariament e a algunos lenguajes, los dos argumentos en una operación booleana siempre son computados, incluso cuando el primer argumento aún no determina el resultado). Ejemplo Aquí hay algunos ejemplos con algunas asignaciones pero no se da ningún resultado: { x = 23; color=$FFAA00; str = 'hello world'; y += 5; x *= y; x = y << 2; x = 23*((2+4) / sin(y)); str = 'hello' + " world"; b = (x < 5) && !(x==2 || x==4); } 38.8.- Más sobre Variables extras: Se crean nuevas variables asignándoles un valor al ser nombradas. Si utilizas simplemente un nombre de variable, la variable será almacenada sólo con la instancia del objeto actual. Así que no esperes encontrarla cuando trates de usarla con otro objeto (u otra instancia del mismo objeto) después. También puedes establecer y leer variables en otros objetos poniendo el nombre del objeto con un punto antes del nombre de la variable. Recuerda que para crear variables globales, que sean visibles en todas las instancias de objetos, precédelas con la palabra global y un punto. Así que por ejemplo puedes escribir: { if (global.hacer) { // hacer cualquier cosa g lobal.hacer = false; } } Algunas veces quieres variables sólo en el actual código o script. De esta forma evitas el uso excesivo de memoria y te aseguras que no haya conflicto de nombres. También es más rápido que usar variables globales. Para lograr esto debes declarar las variables al principio del código usando la palabra var. Esta declaración se ve como sigue. var <no mbre_varable1>,<nombre_variable2>,<no mbre_variable3>, ... Por ejemplo, puedes escribir: { var xx,yy; xx = x+10; yy = y+10; instance_create(xx,yy,pelota); } 105
- 106. Esto creara una pelota en las coordenadas dadas. 38.9.- Direccionando Variables a otras instancias: Como se describió antes, puedes establecer variables en la instancia actual utilizando sentencias como: x = 3; Pero en un número de casos quizás quieras direccionar variables a otra instancia. Por ejemplo, tal vez quieras detener el movimiento de todas las pelotas, o tal vez quieras mover al personaje principal a una posición en particular, o, en caso de una colisión, tal vez quieras establecer la imagen para otra instancia implicada. Esto puede ser logrado precediendo el nombre de la variable con el nombre de un objeto y un punto. Así que por ejemplo, puedes escribir: Pelota.speed = 0; Esto cambiará la velocidad de todas las instancias del objeto pelota. Hay un número de palabras especiales que no puedes utilizar para nombrar tus objetos: self: La instancia del objeto actual para la que estamos ejecutando la acción. other: La otra instancia de objeto implicada en un evento de colisión. all: Todas las instancias del objeto. noone: Ninguna instancia de objeto (probablemente suena extraño pero si viene útil como veremos después). global: No es precisamente una instancia, sino un contenedor que almacena variables globales. Así que, por ejemplo, puedes usar los siguientes tipos de sentencias: other.sprite_index = sprite5; all.speed = 0; global.message = 'Un buen resultado'; global.x = pelota.x; Ahora tal vez te preguntes que es lo que hace, la asignación anterior (o sea Pelota.speed = 0;), cuando hay varias pelotas. Bueno, la primera es tomada y su valor x es asignado al valor global para todas las pelotas. Pero qué si quieres establecer la velocidad para una pelota en particular, en vez de a todas las pelotas. Esto es ligeramente más difícil. Cada instancia tiene una identificación única (id de ahora en adelante). Cuando pones instancias en un cuarto, o nivel de juego mientras estas diseñando el juego, esta id de la instancia es mostrada cuando pones el M ouse sobre ella. Estos son números más grandes o iguales a 1000000 un millón. Puedes usar dicho número como la parte izquierda del punto. Pero se cuidadoso. El punto se interpretará como el número decimal en el número. Para evitar esto, pon paréntesis alrededor del número. Así que por ejemplo, asumiendo que la id de la pelota es 1000032, puedes escribir: (1000032).speed = 0; Cuando creas una instancia en el programa, la llamada regresa el identificador id. Así que un programa válido es: { nnn = instance_create(100,100,ball); nnn.speed = 8; } Esto crea una pelota (en la posición x=100 y en la posición y=100) y establece su velocidad a 8. Nota que asignamos el identificador id (representado por las letras n) de la instancia a una variable y utilizamos esta variable como indicación después del punto (speed). Esto es completamente válido. Vamos a intentar hacer esto más comprensible. Un punto es en realidad un operador. Este toma un valor como operador izquierdo y una variable (dirección) como operador derecho, y regresa la dirección de esa variable en particular en el objeto indicado o en la instancia del objeto. Todos los nombres de objetos, y los objetos especiales indicados abajo simplemente representan valores y estos pueden ser manejados como cualquier valor. Por ejemplo, el siguiente programa es válido: { obj[0] = pelota; obj[1] = bandera; obj[0].alarm[4] = 12; obj[1].id.x = 12; } La última sentencia debería ser leída como sigue. Tomamos el identificador id de la primera bandera. Para la instancia con esa id establecemos la coordenada x=12. Los nombres de objetos, los objetos especiales, y el identificador id de la instancia, también pueden ser utilizados en un número de funciones. Son en realidad tratados como constantes en los programas. 106
- 107. 38.10.- Órdenes (Arrays): Puedes usar órdenes (Arrays) unidimensionales y bidimensionales en el lenguaje del Game M aker. Simplemente pon el índice entre corchetes cuadrados “[ ]” para órdenes (arrays) unidimensionales, y los dos índices con una coma entre ellos para órdenes (arrays) bidimensionales. En el momento en que usas un índice la orden (arrays) es generada. Cada orden (array) corre desde el índice 0. Ten cuidado usando índices grandes de ordenes porque la memoria para una orden grande estará reservada. Nunca uses índices valores negativos. El sistema pone un límite de 32000 en cada índice y 1000000 en el total de tamaño. Como por ejemplo puedes escribir lo siguiente: { a[0] = 1; i = 1; wh ile (i < 10) { a[i] = 2*a[i-1]; i += 1;} b[4,6] = 32; } 38.11.- Sentencia if (si): Una declaración si (if) tiene la forma: if (<expresión>) <sentencia> O también. if (<expresión>) <sentencia> else <sentencia> La declaración puede también ser un bloque. La expresión será evaluada. Si el valor (aproximado) es if <=0 (falso) se ejecuta la declaración sino (else) es ejecutada, de otra forma (cierto) la otra declaración es ejecutada. Es un buen hábito siempre poner llaves alrededor de las declaraciones en el si (if). M ejor usa: if (<expresión>) { <sentencia> } else { <sentencia> } El siguiente ejemplo mueve el objeto hacia en medio de la pantalla. { if (x<200) { x+=4} else { x-=4}; } 38.12.- Sentencia re peat: repeat (<exp resión>) <sentencia> La sentencia es repetida el número de veces indicado, por el valor redondeado de la expresión. Ejemplo: El siguiente programa crea cinco pelotas en posiciones aleatorias: { repeat (5) instance_create(random(400),random(400),pelota); } 38.13.- Sentencia while: Una declaración while tiene la forma: while (<exp resión>) <sentencia> 107
- 108. Funcionará mientras la expresión que pude o no estar en un bloque sea verdadera. Sé cuidadoso con tus secuencias while. Puedes fácilmente hacer que se repita por siempre, en este caso tu juego se bloqueara y no reaccionará a ninguna petición o acción que el usuario haga. Ejemplo: El siguiente programa prueba poner el objeto actual en una posición libre (esto es como la misma acción para mover un objeto a una posición aleatoria). { wh ile (!place_free(x,y)) { x = random(roo m_width); y = random(roo m_height); } } 38.14.- Sentencia do: Una sentencia do tiene la forma: do <sentencia> until (<expresión>) La sentencia (que puede estar en un bloque) es ejecutada mientras que la expresión es verdadera. La sentencia se ejecuta por lo menos una vez. Sé cuidadoso con tus secuencias do. Puedes fácilmente hacer que se repita por siempre, en este caso tu juego se bloqueara y no reaccionará a ninguna petición o acción que el usuario haga. Ejemplo: El siguiente programa prueba poner el objeto actual en una posición libre (esto es como la misma acción para mover un objeto a una posición aleatoria): { do { x = random(roo m_width); y = random(roo m_height); } until (place_free(x,y)) } 38.15.- Sentencia for: Una declaración for tiene la forma: for (<sentancia1> ; <expresión> ; <sentencia2>) <sentencia3> Funciona de la siguiente manera. Primero se ejecuta la sentencia1, entonces se evalúa la expresión, si es verdadera, se ejecuta la sentencia3, luego entonces la sentencia2 y luego se evalúa nuevamente la expresión; esto continua hasta que la expresión sea falsa. Esto puede sonar complicado. Deberías interpretar esto como sigue. La primera declaración inicializa el circuito for. La expresión prueba si el ciclo debiera de terminar. La sentencia2 es la sentencia de paso hacia la evaluación del siguiente ciclo. El uso más común en su mayoría de los casos, es para tener un contador corriendo hasta un cierto valor. Ejemplo El siguiente programa inicia un orden de longitud 10 con los valores del 1 al 10. { for (i=0; i<=9; i+=1) list[i] = i+1; } 38.16.- Sentencia s witch: En un número de situaciones tal vez quieras dejar que tu acción dependa de un valor en particular. Puedes hacer esto usando un número de sentencias if (si), pero es más sencillo utilizar la sentencia switch (interruptor). Una sentencia switch tiene la siguiente estructura: 108
- 109. switch(<expresión>) { case <expresión1>: <sentencia1>; ... ; break; case <expresión2>: <sentencia2>; ... ; break; ... default: <sentencia>; ... } Esto funciona como sigue. La p rimera expresión es ejecutada. La siguiente es comparada con los resultados de las diferentes expresiones después de las sentencias case. La ejecución continúa después de la primera sentencia con el valor correcto, hasta que una sentencia break es encontrada. Si ninguna sentencia case tiene el valor el valor correcto, la ejecución es continuada después de la sentencia default. (No es requerido tener una sentencia default). Nota que múltiples sentencias case pueden ser colocadas para la misma sentencia. También, la sentencia break no es requerida. Si no hay ninguna sentencia break la ejecución simplemente continúa con el código de la siguiente sentencia case. Ejemplo: El siguiente programa toma una acción basada en una tecla que es presionada: switch (keyboard_key) { case vk_left: case vk_numpad4: x -= 4; break; case vk_right: case vk_numpad6: x += 4; b reak; } 38.17.- Sentencia Break: La declaración de la sentencia break tiene la forma: break; Si se utiliza en un ciclo for, while, repeat, en una sentencia switch, o with, finaliza el ciclo o sentencia. Si es empleada fuera de una de estas sentencias finaliza el programa no el juego. 38.18.- Sentencia continue (conti nua): La declaración de continue tiene la siguiente forma: continue; Si está utilizada dentro de un ciclo for, while, repeat o con una sentencia with, continúa con el siguiente valor del ciclo for o de la sentencia with. 38.19.- Sentencia exit (Salir): La declaración de exit tiene la forma siguiente: exit; Termina simplemente la ejecución de del programa o script actual. ¡(No termina la ejecución del juego! Para ello necesitas la función game_end(); ver más abajo.) 39.- Funciones: Una función tiene la siguiente estructura: nombre de la función, seguido por uno o más argumentos entre paréntesis, separados por comas (también puede no incluir ningún argumento). Y se vería de la siguiente forma: <función>(<argumento1>,<argumento2>,…) Hay dos tipos de funciones, en primer lugar tenemos una gran cantidad de funciones internas, para controlar todos los aspectos del juego; en segundo lugar, cualquier script que sea definido en el juego puede ser usado como una función. ¿Qué son y para que son los argumentos dentro de las funciones cuando usas scripts? 109
- 110. Los argumentos de los scripts son los parámetros (opcionales) que le puedes enviar a un script a la hora de ejecución para indicarle que y como hacerlo. Por ejemplo, este sencillo script: { /* Script Cuadrado(Número) //devuelve el cuadrado del número proporcionado if is_real(argument0) return argument0*argument0; else return 0; } OK, para que quede claro este script simplemente devuelve el cuadrado de su argumento 1 (índice 0) así, en cualquier lugar podrías poner esto; Variable = Cuadrado(2) y en efecto, eso te devolvería un 4 p or ejemplo. Se pueden usar hasta 16 argumentos en una función, los cuales se pondrían de la sigu iente manera en la función: function(argument0,….argument16) Una función tiene la forma del nombre de una función, seguido por ninguno o más argumentos entre paréntesis, separados por comas. Nota que en una función sin argumentos debes necesariamente usar los paréntesis. Algunas funciones regresan valores y pueden ser usados en expresiones. Otras simplemente ejecutan comandos. Nota que es imposible usar una función como la parte izquierda de una asignación. Por ejemplo, no puedes escribir instance_nearest(x,y,obj).speed = 0. Porque lo correcto que deberías de escribir es: (instance_nearest(x,y,obj)).speed = 0. 40.- Scripts: Cuando creas un script, querrás tener acceso a los argumentos enviados a él (ya sea cuando uses una acción script, o cuando llames al script como una función desde un programa u otro, o inclusive desde el mismo script). Estos argumentos se almacenan en las variables argument0, argument1, …, argument15. Por lo que puede haber como máximo 16 argumentos. (Nota: Cuando se llama un script desde una acción, sólo se pueden especificar los primeros 5 argumentos). Puedes usar también argument[0], etc. Los scripts también pueden devolver un valor, por lo que pueden ser empleados en expresiones. Para ello debes emplear la declaración return: return (<expresión>) ¡La ejecución del script termina en la sentencia return! Ejemplo: Aquí está la definición de un pequeño script que calcula el cuadrado del argumento: { return (argu ment0*argument0); } Para llamar un script desde una pieza de código, solo hazlo, como cuando se hacen las llamadas a funciones. Esto es, el nombre del script con sus argumentos entre paréntesis. 41.- Construcciones with: Como se indicó antes, es posible leer y cambiar el valor de las variables en otras instancias. Pero en ciertos casos querrás hacer mucho más con esas otras instancias. Por ejemplo, imagina que deseas mover todas las pelotas 8 píxeles hacia abajo. Pudieras pensar que eso se logra con el siguiente código: pelota.y = pelota.y + 8; 110
- 111. Pero no es cierto. El valor a la derecha de la asignación obtiene la coordenada “ y” de la primera pelota y le suma 8. Entonces este nuevo valor se toma como la coordenada “y” para todas las pelotas. Por lo que el resultado es que todas las pelotas tienen la misma coordenada “y”. La sentencia pelota.y += 8; tendrá exactamente el mismo efecto porque es simplemente una abreviatura de la p rimera declaración. Entonces, ¿Cómo logramos esto? Para ello existe la declaración with. Su forma general es: with(<expresión>) <sentencia> <expresión> Indica una o más instancias. Para esto puedes emplear el id de la instancia, o el nombre de un objeto (para indicar todas las instancias de este objeto) o uno de los objetos especiales (all, self, other, noone). La <declaración o sentencia> se ejecuta para cada una de las instancias indicadas, como si la instancia fuera la instancia (self) actual. Así, para mover todas las pelotas 8 píxeles hacia abajo, puedes escribir: with(pelota) y += 8; Si deseas ejecutar múltiples declaraciones, colócalas entre corchetes. Por ejemplo, para mover todas las pelotas a una posición aleatoria, puedes usar: with(pelota) { x = random(roo m_width); y = random(roo m_height); } Nota que, dentro de las declaraciones, la instancia indicada se ha vuelto la instancia self. Entonces, la instancia self original ahora es la instancia other. Así, por ejemplo, para mover todas las pelotas a la posición de la instancia actual, puedes usar: with(pelota) { x = other.x; y = other.y; } El uso de la declaración with es muy poderoso. A continuación se muestran unos cuantos ejemplos más. Para destruir todas las pelotas puedes usar: with(pelota) instance_destroy(); Si una bomba explota y quieres destruir todas las instancias cercanas a ella puedes usar with(all) { if (distance_to_object(other) < 50) instance_destroy(); } 42.- Comentarios: Como ya habrás visto puedes agregar comentarios a tus programas. Todo lo que esta escrito en un renglón después de dos líneas diagonales // no es leído por el programa y no se ejecuta. Puedes hacer también un comentario multilíneas poniendo texto entre /* y /*. (La coloración del código podría no trabajar correctamente aquí, presiona F12 para recolorear el texto si esto ocurre). 43.- Funciones y variables en el lenguaje del Game Maker “GML”: El GM L contiene un gran número de funciones y variables internas o predefinidas. Con ellas puedes controlar cualquier aspecto o parte del juego. Para todas las acciones existe una función correspondiente por lo que de hecho no necesitas emplear ninguna acción si prefieres emplear código. Pero hay muchas más funciones y variables que controlan aspectos del juego que no se pueden acceder sólo empleando acciones. Por lo que si deseas crear juegos más avanzados se te recomienda leer los siguientes capítulos para tener un panorama general de todo lo que es posible lograr. Por favor nota que estas variables y funciones pueden también ser usadas cuando se proveen o envían valores para las acciones. Por lo que aún si no planeas emplear código o escribir algún script, aún obtendrás beneficios de esta información. En los capítulos siguientes se emplean las siguientes convenciones. Los nombres de variables marcados con un * son sólo de lectura, es decir, no se puede cambiar su valor. 111
- 112. Los nombres de variables con [0..n] después de ellos son ordenes (arrays). Y se da el intervalo posible de sus índices. 44.- Haciendo cálculos o Computando cosas: El Game M aker contiene un gran número de funciones para llevar a cabo diversos cálculos. A continuación se verá la lista completa. 44.1.-Constantes: Las siguientes constantes matemáticas están disponibles: true Igual a 1. false Igual a 0. pi Igual a 3.1415… 44.2.- Funci ones basadas en val ores reales (números): Las siguientes funciones disponibles manejan números reales: random (x): Devuelve un número real entre 0 y x. El número siempre es menor al valor de x. choose (val1,val2,val3,…) Devuelve una de los argumentos de forma aleatoria, la función acepta un máximo de 16 argumentos. abs (x): Devuelve el valor absoluto de x. sign (x): Devuelve el signo de x (-1 or 1). round (x): Devuelve x redondeado al entero más cercano. floor (x): Devuelve x redondeado al entero hacia abajo. ceil (x): Devuelve x redondeado al entero hacia arriba. frac (x): Devuelve la parte fraccional de x, es decir, la parte detrás del punto decimal. sqrt (x): Devuelve la raíz cuadrada de x. El valor de no debe ser negativo. sqr (x): Devuelve el valor cuadrado de x. power (x,n): Devuelve x elevado a la potencia n. exp (x): Devuelve e elevado a la potencia x. ln (x): Devuelve el logaritmo natural de x. log2 (x): Devuelve el logaritmo base 2 de x. log10 (x): Devuelve el logaritmo base 10 de x. logn (n,x): Devuelve el logaritmo base n de x. sin (x): Devuelve el seno de x (x en radianes). cos (x): Devuelve el coseno de x (x en radianes). tan (x): Devuelve la tangente de x (x en radianes). arcsin (x): Devuelve el arcoseno de x. arccos (x): Devuelve el arcocoseno de x. arctan (x): Devuelve el arcotangente de x. arctan2 (y, x): Calcula el arcotangente de (Y/X), y devuelve un ángulo en el cuadrante correcto. degtorad (x): Convierte grados a radianes. radtodeg (x): Convierte radianes a grados. min (val1,val2,val3…): Devuelve el menor de los valores, soporta hasta 16 argumentos. Los valores deben ser todos números reales o cadenas de texto. max (val1,val2,val3…): Devuelve el mayor de los valores, soporta hasta 16 argumentos. Los valores deben ser todos números reales o cadenas de texto min3 (x, y, z): Devuelve el mínimo de los valores x, y y z. max3 (x, y, z): Devuelve el máximo de los valores x, y y z. mean (val1, val2, val3…): Devuelve el promedio de los valores, soprta hasta 16 argumentos. Los valores deben de ser números reales. M edian(val1, val2, val3…) Devuelve el valor intermedio de los valores o argumentos introducidos (Cuando el número de argumentos es parejo, el menor de los dos valores intermedios, es el que devuelve la función). Soporta hasta 16 argumentos, los valores deben de ser números reales. point_distance (x1, y1, x2, y2): Devuelve la distancia existente entre el punto (x1,y1) hacia el punto (x2,y2). point_direction (x1, y1, x2, y2): Devuelve la dirección desde el punto (x1,y1) hacia el punto (x2,y2) en grados. lengthdir_x (len,dir) Devuelve el componente horizontal (x) del vector determinado por la longitud y dirección indicadas. lengthdir-y (len,dir) Devuelve el componente vertical de (y) del vector determinado por la longitud y la dirección indicadas. is_real (x): Averigua cuando (x) es un valor real. (Diferenciándolo de una cadena de texto) is_string (x): Averigua cuando (x) es una cadena de texto. (Diferenciándolo de un número real). 112
- 113. 44.3.- Funci ones basadas en el manejo de cadenas o texto (strings): Las siguientes funciones manejan caracteres y cadenas de texto (strings). chr (val): Devuelve una cadena que contiene el carácter con valor de código ASCI val. ord (str): Devuelve el código A SCI del primer carácter de la cadena de texto str. real (str): Convierte una cadena de texto en un número real; str puede contener signos negativos, puntos decimales, e inclusive una parte exponencial. string (val): Convierte un número real en una cadena de texto empleando un formato estándar (no hay parte decimal si es un entero, y un máximo de dos decimales para los demás casos). string_format (val, tot, dec): Convierte val en una cadena empleando tu propio formato: tot indica el número total de caracteres y dec indica el número de decimales. string_length (str): Devuelve el número de caracteres en la cadena. string_pos (substr, str): Devuelve la posición de substr en str (0 no encontrado). string_copy (str, index, count): Devuelve una sub cadena de str, empezando en la posición index, y con longitud count. string_char_at (str, index): Devuelve el carácter situado en la posición index de la cadena str. string_delete (str, index, count): Devuelve una copia de str con una parte removida, que empieza en la posición index y de una longitud definida por count. string_insert (substr, str, index): Devuelve una copia de str con la sub cadena substr insertándola en la posición index. string_replace (str, substr, newstr): Devuelve una copia de str con la primer a ocurrencia de substr reemplazada por newstr. string_replace_all (str, substr, newstr): Devuelve una copia de str con todas las ocurrencias de substr reemplazadas por newstr. string_count (substr, str): Devuelve el número de ocurrencias de substr en str. string_lower (str): Devuelve una copia de str en minúsculas string_upper (str): Devuelve una copia en mayúsculas de str. string_repeat (str, count): Devuelve una cadena con un número de copias de la cadena str definido por count. string_letters (str): Devuelve una cadena que solo contiene las letras en la cadena str. string_digits (str): Devuelve una cadena que solo contiene los dígitos en la cadena str. string_lettersdigits (str): Devuelve una cadena que contiene las letras y dígitos en la cadena str. Las siguientes funciones acceden al portapapeles para almacenar texto. clipboard_has_text (): Devuelve si hay texto en el portapapeles. clipboard_get_text (): Devuelve el texto actual en el portapapeles. clipboard_set_text (str): Coloca la cadena str en el portapapeles. 45.- Manejando el tiempo y fechas: En Game M aker existen un número de funciones para trabajar con fechas y tiempo. Una combinación fecha tiempo se almacena en un número real. La parte entera de un valor fecha tiempo es el número de días que han pasado desde 12/30/1899. La parte fraccionaria del valor fecha tiempo es una fracción de un día de 24 horas que han transcurrido. Las siguientes funciones están disponibles: date_current_datetime(): Regresa el valor fecha hora que corresponde al momento actual. date_current_date(): Regresa el valor fecha actual (ignorando la hora). date_current_time(): Regresa el valor hora actual (ignorando la fecha). date_create_datetime(year,mouth,day,hour,minute,second): Crea un valor fecha hora correspondiente a la fecha y hora indicados, comenzando por el año, mes, día, hora, minuto y segundo. date_create_date(year,mouth,day): Crea un valor fecha hora correspondiente a la fecha indicada. date_create_time(hour,minute,second): Crea un valor fecha hora correspondiente a la hora indicada. date_valid_datetime (año, mes, día, hora, minuto, segundo): M uestra si la hora y fecha indicados son válidos. date_valid_date (año, mes, día): M uestra si la fecha indicada es válida. date_valid_time (hour, minute, second): M uestra si la hora indicada es válida. date_inc_year (fecha, n): Regresa una nueva fecha que es n años después de la fecha indicada. “n” debe ser un número entero. date_inc_month (fecha, n): Regresa una nueva fecha que es n meses después de la fecha indicada. “n” debe ser un número entero. date_inc_week (fecha, n): Regresa una nueva fecha que es n semanas después de la fecha indicada. “n” debe ser un número entero. date_inc_day (fecha, n): Regresa una nueva fecha que es n días después de la fecha indicada. “n” debe ser un número entero. date_inc_hour (fecha, n): Regresa una nueva fecha que es n horas después de la fecha indicada. “n” debe ser un número entero. 113
- 114. date_inc_minute (fecha, n): Regresa una nueva fecha que es n minutos después de la fecha indicada. “n” debe ser un número entero. date_inc_second (fecha, n): Regresa una nueva fecha que es n segundos después de la fecha indicada. “n” debe ser un número entero. date_get_year (fecha): Regresa el año actual. date_get_month (fecha): Regresa el mes actual. date_get_week (fecha): Regresa la semana actual. date_get_day (fecha): Regresa el día del año especificado. date_get_hour (fecha): Regresa la hora del año especificado. date_get_minute (fecha): Regresa el minuto del año especificado. date_get_second (fecha): Regresa el segundo del año especificado. date_get_weekday (fecha): Regresa el día de la semana correspondiente a la fecha. date_get_day_of_year (fecha): Regresa el día del año correspondiente a la fecha. date_get_hour_of_year (fecha): Regresa la hora del año correspondiente a la fecha. date_get_minute_of_year (fecha): Regresa el minuto del año correspondiente a la fecha. date_get_second_of_year (fecha): Regresa el segundo del año correspondiente a la fecha. date_year_span (fecha1, fecha2): Regresa el número de años entre las dos fechas. Reporta años incompletos como una fracción. date_month_span (fecha1, fecha2): Regresa el número de meses entre las dos fechas. Reporta meses incompletos como una fracción. date_week_span (fecha1, fecha2): Regresa el número de semanas entre las dos fechas. Reporta semanas incompletas como una fracción. date_day_span (fecha1, fecha2): Regresa el número de días entre las dos fechas. Reporta días incompletos como una fracción. date_hour_span (fecha1, fecha2): Regresa el número de horas entre las dos fechas. Reporta horas incompletas como una fracción. date_minute_span (fecha1, fecha2): Regresa el número de minutos entre las dos fechas. Reporta minutos incompletos como una fracción. date_second_span (fecha1, fecha2): Regresa el número de segundos entre las dos fechas. Reporta segundos incompletos como una fracción. date_compare_datetime (fecha1, fecha2): Compara los dos valores fecha-tiempo. Regresa -1, 0, ó 1 dependiendo en si la primera es más pequeña, igual, o posterior que el segundo valor. date_compare_date (fecha1, fecha2): Compara los dos valores fecha-tiempo tomando sólo la parte de la fecha en cuenta. Regresa -1, 0, ó 1 dependiendo en si la primera es más pequeña, igual, o posterior que el segundo valor. date_compare_time (fecha1, fecha2): Compara los dos valores fecha-tiempo tomando sólo la parte del tiempo en cuenta. Regresa -1, 0, ó 1 dependiendo en si la primera es más pequeña, igual, o posterior que el segundo valor. date_date_of (fecha): Regresa la parte de la fecha del valor fecha hora indicada, estableciendo la parte de tiempo a 0. date_time_of (fecha): Regresa la parte del tiempo del valor fecha hora indicada, estableciendo la parte de la fecha a 0. date_datetime_string (fecha): Regresa una cadena indicando la fecha y tiempo dados en el formato predeterminado para el sistema. date_date_string (fecha): Regresa una cadena indicando la fecha dada en el formato predeterminado para el sistema. date_time_string (fecha): Regresa una cadena indicando el tiempo dado en el formato predeterminado para el sistema. date_days_in_month (fecha): Regresa el número de días en el mes indicado por el valor fecha-tiempo. date_days_in_year (fecha): Regresa el número de días en el año indicado por el valor fecha-tiempo. date_leap_year (fecha): Regresa si el año indicado por el valor fecha-tiempo es un año bisiesto. date_is_today (fecha): Regresa si el valor fecha-tiempo indicado esta en el día de hoy. 46.- GML; Game play (Jugabilidad): Hay una gran cantidad de variables y funciones que puedes emplear para definir la jugabilidad. Es tas en particular influyen en el movimiento y creación de instancias, el tiempo, y el manejo de los eventos. 46.1.- Movi miento: Obviamente, un aspecto importante de los juegos es el movimiento de las instancias de los objetos. Cada instancia tiene dos variables internas “x” y “y” que indican la posición de la instancia. (Para ser precisos, indican el lugar donde se encuentra el punto de origen del sprite). La posición (0,0) es la esquina superior izquierda del cuarto. Puedes cambiar la posición de la instancia al cambiar los valores de sus variables “x” y “y”. Es lo que debes hacer si deseas movimientos más complicados. Este código normalmente se coloca en el evento paso del objeto. Si el objeto se mueve con velocidad y dirección constante, hay una manera más fácil de lograrlo. Cada instancia tiene una velocidad horizontal (hspeed) y vertical (vspeed). Ambas se indican en píxeles por paso. Una velocidad horizontal positiva indica movimiento a la derecha, una velocidad horizontal negativa indica movim iento a la izquierda. La velocidad vertical positiva es movimiento hacia abajo y la negativa indica movimiento hacia arriba. Por 114
- 115. lo que sólo debes establecer estos valores una vez (por ejemplo en el evento de creación) para dar al objeto un movimiento constante. Hay otra manera muy diferente de especificar el movimiento, usando dirección (en grados 0-359), y velocidad (no debe ser negativa). Puedes configurar y leer estas variables para especificar un movimiento arbitrario. (Internamente se convierte a valores de hspeed y vspeed). También tenemos la fricción y la gravedad, y la dirección de la gravedad. Finalmente, tenemos la función motion_add (dir, speed) para agregar un movimiento al actual. Para concluir, cada instancia tiene las siguientes variables y funciones referentes a su posición y movimiento: x: Su posición x. y: Su posición y. xprevious: Su posición x anterior. yprevious: Su posición y previa. xstart: Su posición x inicial en el cuarto. ystart: Su posición y inicial en el cuarto. hspeed: M ovimiento horizontal de la velocidad. vspeed: M ovimiento vertical de la velocidad. direction: Su dirección actual (0-360, contra las manecillas del reloj, 0 = a la derecha). speed: Su velocidad actual (píxeles por step). friction: Fricción actual (píxeles por step). gravity: Cantidad actual de gravedad (píxeles por paso). gravity_direction: Dirección de la gravedad (270 es hacia abajo). motion_set (dir, speed): Establece el movimiento a la velocidad speed y la dirección dir. motion_add (dir, speed): Agrega el movimiento al movimiento actual (como una suma vectorial). path_index: índice del camino o trayectoria actual que la instancia sigue. –1 indica que no hay camino o trayectoria. path_position: Posición en el camino o trayectoria actual. 0 es el inicio del camino o trayectoria. 1 es el fin del camino o trayectoria. path_orientation: Orientación (contra las manecillas del reloj) en el que se ejecuta el camino o trayectoria. 0 es la orientación normal del camino o trayectoria. path_scale: Escala del camino o trayectoria. Increméntala para hacer al camino o trayectoria más grande. 1 es el valor por defecto. Se tiene una gran cantidad de funciones disponibles que te ayudarán a la definición de movimientos: place_free (x, y): Devuelve si la instancia colocada en la posición (x, y) está libre de colisión. Normalmente se emplea para revisar antes de mover la instancia a la nueva posición. place_empty (x, y): Devuelve si la instancia colocada en la posición (x, y) no se encuentra con nadie. Esta función también toma en cuenta las instancias no sólidas. place_meeting (x, y, obj): Devuelve si la instancia colocada en la posición (x,y) se encuentra con un el objeto obj. obj puede ser un objeto en cuyo caso la función devuelve verdadero si se encuentra con una instancia de ese objeto. También puede ser el id de una instancia, o la palabra especial other. place_snapped (hsnap, vsnap): Devuelve si la instancia está alineada con los valores de precisión hsnap y vsnap de la celda. move_random (hsnap, vsnap): M ueve la instancia a una posición libre, y la alinea con los valores hsnap y vsnap, alineada, al igual que la acción correspondiente. move_snap (hsnap, vsnap): Alinea la instancia, como la acción correspondiente. move_towards_point (x, y, sp): M ueve la instancia con velocidad sp hacia el punto (x, y). move_bounce_solid (adv): Rebotar contra objetos sólidos, como la acción correspondiente, adv indica si se emplea rebote avanzado, que toma en cuenta las paredes inclinadas. Aquí voy move_bounce_all (adv): Rebotar contra todas las instancias, en lugar de solo con las sólidas. move_contact_solid (dir, maxdist): M over la instancia en la dirección dir hasta que haya contacto con un objeto sólido. Si no hay colisión en la posición actual, la instancia es colocada justo antes de donde ocurre una colisión. Si ya hay una collision en la posición actual, la instancia no se mueve. Puedes especificar la distancia máxima a mover la instancia maxdist (emplea un número negativo para indicar distancia arbitraria). move_contact_all (dir, maxdist): Igual que la función anterior pero esta vez se detiene hasta que haya contacto con cualquier objeto, no solo con los sólidos. move_outside_solid (dir, maxdist): M ueve la instancia en la dirección dir hasta que no esté al alcan ce de un objeto sólido. Si no hay collision en la posición actual, no se mueve la instancia. Puedes especificar la distancia máxima a mover (usa un valor negativo para indicar una distancia arbitraria). move_outside_all (dir, maxdist): Igual que el anterior pero se mueve hasta estar fuera de alcance de cualquier objeto, no solo objetos sólidos. distance_to_point (x, y): Devuelve la distancia de la caja límite de la instancia actual hacia el punto (x, y). distance_to_object (obj): Devuelve la distancia de la instancia actual a la instancia más cercana del objeto obj. position_empty (x, y): Indica si no hay nada en la posición (x, y). position_meeting (x, y, obj): Indica si en la posición (x, y) hay una instancia obj. obj puede ser un objeto, una id de una instancia, o las palabras reservadas self, other o all. 115
- 116. 46.2.- Paths (Trayectori as o Cami nos): En Game Maker puedes definir caminos (paths) y ordenar a las instancias que se muevan siguiendo dichos paths. Por supuesto que puedes usar acciones para hacer esto, pero hay funciones y variables que te darán mayor flexibilidad: path_start (path, speed, endaction, absolute): Agrega un camino o trayectoria a la instancia actual y comienza a moverse por él. El parámetro path es el nombre del camino o trayectoria que deseas agregar, speed es la velocidad con que la instancia seguirá al camino o trayectoria. Una velocidad negativa hace que la instancia siga el camino o trayectoria hacia atrás, endaction indica lo que debe ocurrir cuando la instancia termine el camino o trayectoria aquí pueden usarse estos valores: 0: parar el camino o trayectoria. 1: continuar el camino o trayectoria desde el inicio (si el path no está cerrado, la instancia salta al inicio). 2: continuar desde la posición actual. 3: Cambia el signo de la velocidad, es decir, invierte el camino o trayectoria, El argumento absolute debe ser true o false. Si se establece como true, las coordenadas del path son las mismas que las de la habitación, si es false, son relativas a la instancia. Para ser más exactos, cuando es false y la velocidad es positiva, el punto inicial se establece en el mismo punto que el objeto. Cuando es false y la velocidad es negativa, el punto final se establece en el mismo punto que el objeto. path_end (): La instancia dejará de seguir el path actual. path_index*: Índice del camino o trayectoria que se está siguiendo en ese momento. No puedes cambiarlo directamente, para ello debes usar la función path_start(). path_position: Posición en el camino o trayectoria actual. 0 es el comienzo, y 1 el final. Este valor siempre debe estar entre 0 y 1. path_positionprevious: Posición anterior en el camino o trayectoria. Puede usarse por ejemplo, para hacer retroceder un objeto cuando colisiona contra algo. path_speed: Velocidad en píxeles por paso (step) con la que la instancia seguirá el camino o trayectoria. Puedes usar una velocidad negativa para hacer que lo siga hacia atrás. path_orientation: Orientación (en sentido contrario a las agujas del reloj) del camino o trayectoria. 0 es la orientación normal del path. path_scale: Escala del camino o trayectoria. Auméntala para hacerlo mayor. La escala normal es 1. path_endaction: La acción que debe ocurrir al terminar el camino o trayectoria. Debes usar los valores indicados en la parte de arriba. 46.3.- Moti on pl anning (Movi mientos especificados): El movimiento especificado (M otion planning), te ayuda a mover ciertas instancias a un lugar especificado mientras evita colisiones con otras instancias específicas (como paredes). El movimiento especificado (motion planning) es un poco problemático, es imposible dar funciones generales que funcionen en todas las situaciones. También, verificar colisiones es algo que consume tiempo. Por lo tanto debes tener cuidado cuando aplicas estas funciones. Diferentes formas de movimiento especificado (motion planning) están proveídas en el Game M aker. La forma más simple hace que la instancia tome una trayectoria a un sitio en particular, tratando de ir lo más directo posible pero tomando diferentes direcciones si es necesario. Estas funciones deben ser usadas en el evento paso (step) de la instancia. mp_linear_step (x, y, stepsize, checkall): Esta función deja que la instancia tome una trayectoria directa hacia la posición indicada (x, y). El tamaño del paso es indicado por (stepsize). Si la instancia ya está en la posición, no se moverá más. Si la checkall es true la instancia se detendrá cuando colisione con cualquier objeto. Si es false solo se detendrá cuando colisione con una instancia sólido. Esta función devuelve si se ha llegado o no a la posición indicada. mp_linear_step_object (x, y, stepsize, obj): Igual que la anterior solo que esta vez solo instancias de obj son consideradas obstáculos. obj puede ser un objeto o el id de una instancia. mp_potential_step(x, y, stepsize, checkall): Como la función anterior. Pero en este caso trata de esquivar obstáculos. Cuando la instancia deba pasar sobre una instancia sólida (o cualquier instancia si checkall es true) cambiará de dirección y la esquivará. No siempre funcionará bien, pero si el camino es fácil llegará a la meta sin problemas. mp_potential_step_object (x, y, stepsize, obj): Igual que la anterior solo que esta vez solo instancias de obj son consideradas obstáculos. obj puede ser un objeto o el id de una instancia. mp_potential_settings (maxrot, rotstep, ahead, onspot): La función anterior funciona con cierto número de parámetros que pueden ser cambiados usando esta función. Globalmente, esto funciona así. Primero trata de moverse directamente a la meta. Comprueba unos steps adelante como lo indique el parámetro ahead (3 como defecto. Reduciendo este valor significa que empezará a cambiar de dirección más tarde. Incrementándolo significa que empezará a cambiar de dirección antes. Hace esto en el tamaño del step rotstep (10 por defecto). Reduciendo esto le da a la instancia más posibilidades de movimiento, pero es más lento. El parámetro maxrot es un poco más difícil de explicar. La instancia posee su dirección. maxrot (30 por defecto) indica cuantas veces puede cambiar su dirección 116
- 117. por step. Si le das un valor grande a maxrot la instancia puede cambiar muchas veces de dirección en un step. Esto haría más fácil encontrar el camino adecuado y más corto pero puede ocasionar que la instancia no se mueva con buen sentido de la realidad. Haciendo este valor más pequeño lograrás caminos más suaves, pero le será más difícil encontrar el camino adecuado y más corto (e incluso fallar en el intento). Cuando el paso no se pueda dar, el comportamiento dependerá del parámetro onspot. Si onspot es true (el valor por defecto), la instancia rotará en su posición la cantidad de veces que lo indique maxrot. Si es false no se moverá. El segundo tipo de funciones verifican caminos libres de colisión para la instancia. Una vez que este path ha sido verificado puedes asignarlo para que la instancia se mueva por el camino a la meta. La verificación del path tomará algún tiempo, pero luego de ese tiempo la ejecución del mismo será rápida. Por supuesto, si esto no cambia durante la ejecución del mismo. Por ejemplo, si los obstáculos se mueven mientras el path está siendo ejecutado, probablemente necesites verificarlo de nuevo. Ten en cuenta, que estas funciones pueden fallar. Estas funciones están solamente disponibles en la versión registrada del Game M aker. Las primeras dos funciones usan movimiento lineal y potencial a través del campo, son también llamadas funciones de paso (step functions). mp_linear_path (path, xg, yg, stepsize, checkall): Esta función calcula un camino en línea recta para la instancia desde su posición hasta la posición (xh, yg) usando el stepsize indicado. El path indicado debe existir y será sobre escribido por el nuevo camino o trayectoria. (Ver próximos capítulos de como crear y borrar paths). La función checkall devuelve si el camino fue encontrado. La función se detendrá y reportará error si no se ha encontrado un camino libre lineal entre el comienzo y la meta. Nota: si falla, el path será creado de todos modos. mp_linear_path_object (path, xg, yg, stepsize, obj): Igual que la anterior, solo que esta vez solo instancias de obj serán consideradas obstáculos. obj puede ser un objeto o el id de una instancia. mp_potential_path (path, xg, yg, stepsize, factor, checkall): Esta función calcula un path para la instancia desde su posición hasta la posición (xg, yg) usando el stepsize indicado tratando de esquivar colisión con obstáculos. El path indicado debe existir y será sobre escribido por el nuevo path. (Ver próximos capítulos de como crear y borrar paths). Para evitar que la función continúe calculando, por siempre deberás proveer un valor de factor mayor que 1.Nota: si falla, el path será creado de todos modos. mp_potential_path_object (path, xg, yg, stepsize, factor, obj): Igual que la anterior, solo que esta vez solo las instancias de obj serán consideradas obstáculos. obj puede ser un objeto o el id de una instancia. Las otras funciones usan un mecanismo más complejo, que es usando grid-based (a veces llamado A* Algoritmo - Path Finding-). Será más exitoso encontrando paths (sin embargo puede fallar) y encontrará caminos más cortos, pero requiere más trabajo de tu parte. La idea general es la siguiente. Primero que todo ponemos una celda (grid) en el cuarto. Luego puedes elegir si usar un fine grid (que será más lento) o un coarse grid. Luego para todos los objetos relevantes determinamos las celdas del grid en que colisionarán (ya sea usando su bounding box o con colisión precisa) y marcamos estas celdas para que sean evitadas. Finalmente especificamos el comienzo y la meta (que debe estar en una celda libre) y la función verifica el camino más corto entre estos. Entonces este path se podrá asignar a una instancia para que lo siga. El A* Algoritmo es muy poderoso (y es usado en muchos juegos profesionales) pero requiere que tengas mucho cuidado. Debes determinar los parámetros correctos y adecuados para tu juego. También deberás saber si tomar una colisión precisa o no. Todos estos parámetros influencian mucho en la eficiencia del camino. En particular el tamaño de las celdas es crucial. Recuerda que las celdas deben ser suficientemente grandes para que el objeto que se va a mover entre completamente en la celda que se encuentre en su posición. Por otro lado, mientras más pequeño sea el tamaño de la celda es más probable que el path exista. Por esto es que debes saber muy bien que tamaño elegir. Las siguientes funciones existen para esto: mp_grid_create (left, top, hcells, vcells, cellwidth, cellheight): Esta función crea la celda (grid). Devu elve el index que debe ser usado en todas las otras funciones. Puedes crear y mantener múltiples estructuras de grids en el mismo momento, hcells y vcells indican el número de celdas horizontales y verticales. Finalmente cellwidth y cellheight indica el tamaño de las celdas. mp_grid_destroy (id): Destruye la estructura de la celda (grid) indicada y libera memoria. mp_grid_clear_all (id): M arca como libres todas las celdas. mp_grid_clear_cell (id, h, v): M arca como libre, solo la celda indicada. Celda 0,0 es la celda de la esquina superior izquierda. mp_grid_clear_rectangle (id, left, top, right, bottom): M arca como libre todas las celdas que intersecten con el rectángulo indicado (según coordenadas del room). mp_grid_add_cell (id, h, v): M arca como celda ocupada la celda indicada. mp_grid_add_rectangle (id, left, top, right, bottom): M arca todas las celdas que interseptan con el rectángulo como ocupadas. mp_grid_add_instances (id, obj, prec): M arca todas las celdas que intercep ten con una instancia del objeto indicado (el objeto puede ser un id o la palabra clave all) como ocupadas, prec indica si usar colisión precisas (solo funcionará si la imagen (sprite) tiene precise collision checking activado). mp_grid_path (id, path, xstart, ystart, xgoal, ygoal, all owdiag): Verifica un camino o trayectoria a través de la celda (grid), el path indicado debe existir y será reemplazado, xstart e ystart indican el comienzo del path, y xgoal e 117
- 118. ygoal el final del mismo, allowdiag indica si los movimientos diagonales están permitidos, o solamente horizontales y verticales. La función devuelve si encontró el path correctamente. mp_grid_draw (id): Esta función dibuja la celda (grid) con celdas verdes como libres y rojas como ocupadas. Esta función es lenta, y debería ser solamente usada a prueba de errores. 46.4.- Verificando colisiones: Al planear movimientos o decidiendo sobre ciertas acciones, es a menudo importante ver si hay colisiones con otros objetos en ciertos lugares. Las rutinas siguientes se pueden utilizar para esto. Todos estos tienen tres discusiones en un campo común: El obj de la discusión puede ser un objeto, la palabra clave all, o la identificación de un caso. La precisión de la colisión indica si debe ser exacta o basada solamente en la caja de limitación del objeto. La comprobación exacta se hace solamente cuando el sprite, para el evento tiene la colisión exacta a comprobar del sistema. El notme de la discusión se puede fijar para verdad para indicar que el caso que llama no debe ser comprobado. Todas estas funciones vuelven cualquier la identificación de uno de los casos que chocan, o vuelven un valor negativo cuando no hay colisión. collision_point (x, y, obj, prec, notme): Verificas con esta función si en el punto (x, y) hay una colisión con las entidades del obj del objeto. collision_rectangle (x1, y1, x2, y2, obj, prec, notme): Verificas con esta función si hay una colisión entre el rectángulo (llenado) con indicado enfrente de esquinas y las entidades del obj del objeto. Por ejemplo, puedes utiliz ar esto para probar si un área está libre de obstáculos. collision_circle (xc, yc, radius, obj, prec, notme): Verificas con esta función si hay una colisión entre el círculo (llenado) centrado en la posición (xc, yc) con el radio y las entidades dados del obj del objeto. Por ejemplo, puedes utilizar esto para probar si hay un objeto cerca de una localización particular. collision_ellipse (x1, y1, x2, y2, obj, prec, notme): Verificas con esta función si hay una colisión entre la elipse (llenada) con indicado enfrente de esquinas y las entidades del obj del objeto. collision_line (x1, y1, x2, y2, obj, prec, notme): Verificas con esta función del si hay una colisión entre la línea segmento (x1, y1) (x2, y2) y entidades del obj del objeto. Esta es una función de gran alcance. Puedes por ejemplo utilizarla para probar si un caso puede considerar otro caso comprobando si la línea segmento entre ellos interseca una pared. 46.5.- Instancias de objetos: En el juego, las unidades básicas son las instancias de los diferentes objetos. Durante el juego puedes cambiar varios aspectos de estas instancias. También puedes crear nuevas instancias y destruir otras. Además de las variables relacionadas con el movimiento, mostradas arriba y las variables relacionadas con el dibu jo de las instancias que se tratarán más adelante, cada instancia cuenta con las siguientes variables: object_index*: Índice del objeto del cual es instancia. Esta variable no puede ser cambiada. id*: El identificador único para la instancia (>=100000). (Nota: al definir cuartos siempre se muestra el id de la instancia sobre la que se ponga el cursor, en la esquina inferior izquierda de la pantalla de cuartos.). mask_index: Índice del sprite empleado como máscara para las colisiones. Da un valor de –1 para que sea igual a sprite_index. solid: Indica si la instancia es sólida. Puede cambiarse durante el juego. persistent: Indica si la instancia es persistente y reaparecerá al moverse a un Nuevo cuarto. Normalmente desactivas la persistencia en ciertos momentos. (Por ejemplo si vuelves al cuarto anterior). Sólo hay un problema al manejar instancias, no es fácil identificar instancias individuales. No cuentan con un nombre. Cuando sólo hay una instancia de un objeto en particular puedes usar el nombre del objeto pero en otros casos requerirás obtener el id de la instancia. Este es un identificador único para la instancia, puedes emplearlo en las sentencias with y como identificador de un objeto (el uso de la construcción. se describe en la sección 28.6). Afortunadamente hay varias variables y rutinas que te ayudan a obtener los id de las instancias. instance_count*: El número de instancias que existen actualmente en el cuarto. instance_id[0..n-1]*: El id de la instancia en particular, n es el número de la instancia. Permíteme darte un ejemplo. Considera que cada unidad en tu juego tiene un poder en particular y quieres encontrar la más poderosa, pudieras usar el siguiente bloque de código: { maxid = -1; maxpower = 0; for (i=0; i<instance_count; i+=1) { iii = instance_id[i]; if (iii.object_index == unit) 118
- 119. { if (iii.power > maxpower) {maxid = iii; maxpower = iii.power;} } } } Después del repetir el ciclo, maxid contendrá el id de la unidad con mayor poder. (No destruyas instancias durante un ciclo de este tipo porque se quitarán automáticamente de la orden (array) y como resultado empezarás a saltarte instancias). instance_find (obj, n): Devuelve el id de la instancia (n+1) de tipo obj, obj puede ser un objeto o la palabra clave all. Si obj no existe, se devuelve el objeto especial noone. instance_exists (obj): Indica si la instancia de tipo obj existe, obj puede ser un objeto, un id de una instancia, o la palabra clave all. instance_number (obj): Devuelve el número de instancias de tipo obj, obj pude ser un objeto o la palabra clave all. instance_position (x, y, obj): Devuelve el id de la instancia de tipo obj en la posición (x, y), cuando varias instancias están en esa posición se devuelve la primera, obj puede ser un objeto o la palabra clave all. Si no existe, se devuelve el objeto especial noone. instance_nearest (x, y, obj): Devuelve el id de la instancia de tipo obj más cercana al punto (x, y), obj puede ser un objeto o la palabra clave all. instance_furthest(x, y, obj): Devuelve el id de la instancia de tipo obj más alejada del punto (x, y), obj puede ser un objeto o la palabra clave all. instance_place (x, y, obj): Devuelve el id de la instancia de tipo obj encontrado cuando la instancia actual es colocada en la posición (x, y), obj puede ser un objeto o la palabra clave all. Si no existe, se devuelve el objeto especial noone. Las siguientes funciones pueden emplearse para crear y destruir instancias: instance_create (x, y, obj): Crea una instancia de obj en la posición (x, y). La función devuelve el id de la nueva instancia. instance_copy (performevent): Crea una copia de la instancia actual. El argumento indica si el evento de creación se debe ejecutar para la copia. La función devuelve el id de la nueva copia. instance_destroy (): Destruye la instancia actual. instance_change (obj, perf): Cambia la instancia en obj., perf indica si se deben ejecutar los eventos de destrucción y creación. position_destroy (x, y): Destruye todas las instancias cuyo sprite contenga la posición (x, y). position_change (x, y, obj, perf): Cambia todas las instancias en (x, y) en obj., perf indica si se deben ejecutar los eventos de destrucción y creación. 46.6.- Desacti vando Instanci as: Cuando creas cuartos grandes, por ejemplo en un juego de plataforma, con una vista pequeña, varias instancias se quedan fuera de la vista. Tales instancias siguen activas y seguirán ejecutando sus eventos. También cuando hacen un chequeo de colisión estas instancias son tomadas en cuenta. Esto puede costar mucho tiempo, que ciert amente no es necesario. (Por ejemplo, regularmente no es importante cuantas instancias se están moviendo fuera de la vista (view). Para resolver este problema Game M aker contiene algunas funciones para desactivar y activar las instancias. Antes de usarlas tienes que entender como trabaja. Cuando desactivas instancias hay algunas que en algún sentido son retiradas del juego. Estas ya no son visibles y tampoco son ejecutados sus respectivos eventos. Entonces para todas las funciones y acciones estos ya no existen. Esto te ahorra mucho tiempo pero tienes que tener cuidado. Por ejemplo, cuando borras todas las instancias de un tipo en particular, las instancias desactivadas no son eliminadas (porque estas no existen). Así que no pienses que una llave que recoge el jugador puede abrir una puerta desactivada. El error más crucial que puedes hacer es desactivar la instancia que es responsable para la activación. Para evadir esto algunas rutinas que están abajo te permiten insistir en llamar a una instancia que no debe desactivarse por si sola. Aquí están las rutinas disponibles: instance_deactivate_all (notme): Desactiva todas las instancias del cuarto. Si notm es cierto la instancia llamada no es desactivada (Esto es lo que normalmente quieres). instance_deactivate_object (obj): Desactiva todas las instancias del cuarto del objeto dado. También puedes usar todo lo indicado para que todas las instancias tengan que ser desactivadas o la id de una instancia desactive una instancia individual. instance_deactivate_region (left, top, width, height, inside, notme): Desactiva todas las instancias en la región indicada (que es, también aunque quede una pequeña parte del bounding box dentro de esa región). Si inside es falso las instancias completamente fuera de la región son desactivadas. Si notme es cierto la instancia llamada no es desactivada (la cual es normalmente lo que quieres). 119
- 120. instance_activate_all (): Activa todas las instancias en el cuarto. instance_activate_object (obj): Activa todas las instancias en el cuarto de un objeto dado. También puedes usar todo lo indicado para que todas las instancias tengan que activarse o la id de una instancia active una instancia individual. instance_activate_region (left, top, width, height, inside): Activa todas las instancias en la región indicada. Si inside es falso las instancias completamente fuera de la región son activadas. Por ejemplo, para desactivar todas las instancias fuera de la vista y activar las que están dentro, puedes colocar el siguiente código en el evento step del personaje móvil: { instance_activate_all(); instance_deactivate_region(view_ xview[0],v iew_yview[0], view_wv iew[0],view_hview[0],false,true); } En la práctica querrás usar una región levemente más grande que la vista. 47.- Timing (Sincronización de tiempos): Los buenos juegos requirieron de un cuidado especial en el manejo del tiempo, en que las cosas se llevaban a cabo (timing). Afortunadamente el Game M aker se ocupa de la mayor parte del timing por ti. Se asegura de que las cosas ocurran con un ritmo constante. Este ritmo es definido al definir los cuartos. Pero puedes cambiarlo usando la variable global room_speed. Así por ejemplo, puedes incrementar lentamente la velocidad del juego, haciéndolo más difícil, agregando una muy pequeña cantidad (como 0.001) a room_speed en cada step. Si tu máquina es lenta la velocidad del juego pudiera no alcanzarse. Esto puede verificarse usando la variable fps que monitorea constantemente el número actual de cuadros por segundo. Finalmente, para un timing avanzado puedes usar la variable current_time que te da el número de milisegundos desde que la computadora fue iniciada. Aquí está la colección completa de variables disponibles (sólo la primera puede ser cambiada): room_speed: Velocidad del juego en el cuarto actual (en steps por segundo). fps*: Número de cuadros que son dibujados por segundo. current_time*: Número de milisegundos que han pasado desde que el sistema fue iniciado. current_year*: El año actual. current_month*: El mes actual. current_day*: El día actual. current_weekday*: El día actual de la semana (1=domingo, …, 7=sábado). current_hour*: La hora actual. current_minute*: El minuto actual. current_second*: El segundo actual. Algunas veces querrás detener el juego por un corto periodo. Para esto, usa la función sleep. sleep (Num): Pausa el juego por cierta cantidad de tiempo especifico en (Num) milisegundos. Como debes saber, cada instancia tiene 8 alarmas diferentes que puedes configurar. Para cambiar los valores (u obtener los valores) de las diferentes alarmas usa la siguiente variable: alarm[0..7]: Valor de la alarma indicada. (Nota: ¡las alarmas solo se actualizan cuando el evento de alarma para el objeto contiene acciones!) Hemos visto que para los problemas de un timing complejo puedes usar el recurso de las líneas de tiempo (time lines). Cada instancia puede tener un recurso time line asociado con ella. Las siguientes variables están relacionadas con esto: timeline_index: Índice de la time line asociada con la instancia. Puedes establecerlo a una time line en particular para usarla. Ponlo en –1 para dejar de usar la time line para la instancia. timeline_position: Posición actual dentro de la time line. Puedes cambiarla para saltar o repetir ciertas partes. timeline_speed: Normalmente, en cada step la posición en la time line se incrementa en 1. Puedes cambiar esta cantidad configurando esta variable a un valor diferente. Puedes usar números reales, p. Ej. 0.5, si el valor es mayor que uno, varios momentos pueden ocurrir dentro del mismo tiempo del step. Se realizarán en el orden correcto, por lo que no se saltará ninguna acción. 48.- Variables y Funciones para los cuartos (Rooms): Los juegos funcionan en cuartos. Cada cuarto tiene un índice que se indica por el nombre del cuarto. El cuarto actual es almacenado en la variable room. No puedes asumir que los cuartos están numerados en un orden consecutivo. Por 120
- 121. lo que nunca sumes o restes un número de la variable room. En lugar de ello usa las funciones y variables indicadas abajo. Por lo que una típica pieza de código que usarás sería: { if (roo m != roo m_last) { room_goto_next(); } else { game_end(); } } Las siguientes variables y funciones se relacionan con los cuartos (rooms). room: Índice del cuarto actual; puede cambiarse para ir a un cuarto diferente, pero mejor usa las rutinas listadas abajo. room_first*: Índice del primer cuarto en el juego. room_last*: Índice del último cuarto en el juego. room_goto (Num): Ir al cuarto con índice Num. room_goto_pre vious (): Ir al cuarto anterior. room_goto_next (): Ir al siguiente cuarto. room_restart (): Reiniciar el cuarto actual. room_pre vious (Num): Devuelve el índice del cuarto anterior aa Num (-1 = ninguno) pero no va a él. room_next (Num): Devuelve el índice del cuarto posterior a Num (-1 = ninguno). game_end (): Finaliza el juego. game_restart (): Reinicia el juego. Los cuartos tienen varias propiedades adicionales: room_width*: Ancho del cuarto en píxeles. room_height*: Alto del cuarto en píxeles. room_caption: Título de la ventana del cuarto. room_persistent: Indica si el cuarto es persistente. M uchos juegos ofrecen al jugador la posibilidad de guardar el juego y cargar un juego guardado. En el Game M aker esto ocurre automáticamente cuando el jugador presiona (F5) para guardar y (F6) para cargar. También puedes guardar y cargar juegos desde una pieza de código (nota que la carga sólo se lleva a cabo al final del step actual). game_save (string): Guarda el juego al archivo con nombre de tipo cadena. game_load (string): Carga el juego del archivo con nombre de tipo cadena. 49.- Variable y Funciones para el score, la energía, y el número de vidas. El Game M aker mantiene el score en la variable global score y el número de vidas en la variable global lives. Puedes cambiar el score simplemente cambiado el valor de esta variable. Lo mismo aplica para la energía y las vidas. Si la variable lives es mayor que 0 y se vuelve menor o igual a 0 se ejecuta el evento no-more-lives para todas las instancias. Si no quieres mostrar el score y las vidas en el título, pon la variable show_score, etc., a falso. También puedes cambiar el título. Para juegos más complicados mejor muestra el score tú mismo. score: El marcador actual. lives: El número de vidas. health: La energía actual (0-100). show_score: Indica si se muestra el marcador en el título de la ventana. show_lives: Indica si se muestra el número de vidas en el título de la ventana. show_health: Indica si se muestra la energía en el título de la ventana. caption_score: El título empleado para el marcador. caption_lives: El título empleado para el número de vidas. caption_health: El título para la energía. También hay un mecanismo interno para manejar una lista de los mejores marcadores. Puede contener hasta diez nombres. Para más información, ve más adelante. 121
- 122. 50.- Generando eventos: Como sabes, el Game M aker es completamente manejado por eventos. Todas las acciones ocurren como resultado de eventos. Hay una gran cantidad de eventos diferentes. Los eventos de creación y destrucción ocurren cuando una instancia es creada o destruida. En cada step, el sistema maneja primero los eventos de alarma. Después los eventos de teclado y ratón, y luego el siguiente evento step. Después de esto las instancias son colocadas en su nueva posición después de lo cual se maneja el evento de colisión. Finalmente el evento draw se usa para dibujar las instancias (nota que cuando empleas múltiples vistas el evento draw es llamado varias veces en cada step). También puedes aplicar un evento a la instancia actual desde una pieza de código. Se tienen las siguientes funciones: event_perform (type, Num): Realiza el evento Num, del type para la instancia actual. Se pueden emplear los siguientes tipos de eventos: ev_create: Crea un evento. ev_destroy: Destruye un evento ev_step: Evento de paso. ev_alarm: Evento alarma. ev_keyboard: Eventos del teclado. ev_mouse: Eventos del ratón. ev_collision: Eventos de colisión. ev_other: Otros eventos. ev_draw: Evento de dibujo. ev_keypress: Evento presionar una tecla. ev_keyrelease: Evento soltar una tecla. Cuando hay varios eventos del un tipo (type) dado, Num puede usarse para especificar el evento preciso. Para el evento de alarma, Num puede tener un valor de 0 a 7. Para el evento de teclado puedes usar el código de tecla para la tecla. Para los eventos de ratón puedes usar las siguientes constantes: ev_left_button: Evento botón izquierdo. ev_right_button: Evento botón derecho. ev_middle_button: Evento botón central, (también funciona con la rueda de desplazamiento). ev_no_button: Evento ningún botón. ev_left_press: Evento presionar a la izquierda. ev_right_press: Evento presionar a la derecha. ev_middle_press: Evento presionar al centro. ev_left_release: Evento soltar izquierda. ev_right_release: Evento soltar derecha ev_middle_release: Evento soltar central. ev_mouse_enter: Evento entrada del ratón. ev_mouse_leave: Evento salida del ratón. ev_joystick1_left: Evento control izquierdo de la palanca 1. ev_joystick1_right: Evento control derecho de la palanca 1. ev_joystick1_up: Evento control arriba de la palanca 1. ev_joystick1_down: Evento control abajo de la palanca 1. ev_joystick1_button1: Evento botón 1 de la palanca 1. ev_joystick1_button2: Evento botón 2 de la palanca 1. ev_joystick1_button3: Evento botón 3 de la palanca 1. ev_joystick1_button4: Evento botón 4 de la palanca 1. ev_joystick1_button5: Evento botón 5 de la palanca 1. ev_joystick1_button6: Evento botón 6 de la palanca 1. ev_joystick1_button7: Evento botón 7 de la palanca 1. ev_joystick1_button8: Evento botón 8 de la palanca 1. ev_joystick2_left: Evento control izquierdo de la palanca 2. ev_joystick2_right: Evento control derecho de la palanca 2. ev_joystick2_up: Evento control arriba de la palanca 2. ev_joystick2_down: Evento control abajo de la palanca 2. ev_joystick2_button1: Evento botón 1 de la palanca 2. ev_joystick2_button2: Evento botón 2 de la palanca 2. ev_joystick2_button3: Evento botón 3 de la palanca 2. ev_joystick2_button4: Evento botón 4 de la palanca 2. ev_joystick2_button5: Evento botón 5 de la palanca 2. ev_joystick2_button6: Evento botón 6 de la palanca 2. ev_joystick2_button7: Evento botón 7 de la palanca 2. 122
- 123. ev_joystick2_button8: Evento botón 8 de la palanca 2. Para el evento de collision proporcionas el índice del otro objeto. Finalmente, para el evento other puedes usar las siguientes constantes: ev_outside: Evento salir del cuarto. ev_boundary: Evento limite del cuarto. ev_game_start: Evento inicio juego. ev_game_end: Evento fin de juego. ev_room_start: Evento inicio cuarto, o nivel de juego. ev_room_end: Evento fin de cuarto, o nivel de juego. ev_no_more_lives: Evento no más vidas. ev_no_more_health: Evento no más energía. ev_animation_end: Evento fin de la animación. ev_end_of_path: Evento fin de camino o trayectoria. ev_user0: Evento definido por el usuario 0. ev_user1: Evento definido por el usuario 1. ev_user2: Evento definido por el usuario 2. ev_user3: Evento definido por el usuario 3. ev_user4: Evento definido por el usuario 4. ev_user5: Evento definido por el usuario 5. ev_user6: Evento definido por el usuario 6. ev_user7: Evento definido por el usuario 7. Para el evento paso (step) puedes dar el índice usando las siguientes constantes: ev_step_normal: Evento de paso normal. ev_step_begin: Evento inicio de paso. ev_step_end: Evento fin del paso. event_perform_object (obj, type, Num): Esta función trabaja igual que la anterior pero esta vez puedes especificar eventos en otro objeto. Nota que las acciones en estos eventos se aplican a la instancia actual, no a las instancias del objeto dado. event_user (Num): En los eventos other también puedes definir 8 eventos definidos por el usuario. Estos son ejecutados solo si llamas esta función. Num debe tener valores de 0 a 7. event_inherited () Ejecuta el evento heredado. Esto solo funciona si la instancia tiene un objeto padre. Puedes obtener información sobre el evento actualmente ejecutado usando las siguientes variables de solo lectura: event_type*: El tipo del evento que se está ejecutando. event_number*: El número del evento que se está ejecutando. event_object*: El índice del objeto para el cual se está ejecutando el evento actual. event_action*: El índice de la acción que está siendo ejecutada (0 es la primera en el evento, etc.) 51.- Variables misceláneas y funciones: Aquí están algunas variables y funciones que se refieren a los errores: error_occurred: Indica si ha ocurrido un error error_last: Cadena que indica el último mensaje de error show_debug_message (str): M uestra la cadena str en modo debug Las siguientes funciones te permiten ver/revisar cuando ciertas variables existen y algunos incluso permiten modificarles sus valores. En todas estas funciones los nombres de variables son de tipo Texto. variable_global_exists (name): Indica cuando una variable global con el nombre asignado (debe ser texto) existe. variable_local_exists (name): Indica cuando una variable local con el nombre asignado (debe ser texto) existe para la actual instancia. variable_global_get (name): Indica el valor de la variable global con el nombre asignado (debe ser texto). variable_global_array_get (name, ind): Indica el valor del índice ind de la variable vector global unidimensional con el nombre asignado (debe ser texto). variable_global_array2_get (name, ind1, ind2): Indica el valor del índice ind1, ind2 de la variable vector global bidimensional con el nombre asignado (debe ser texto). variable_local_get (name): Indica el valor de la variable local con el nombre asignado (debe ser texto). variable_local_array_get (name, ind): Indica el valor del índice ind de la variable vector local unidimensional con el nombre asignado (debe ser texto). variable_local_array2_get (name, ind1, ind2): Indica el valor del índice ind1, ind2 de la variable vector local bidimensional con el nombre asignado (debe ser texto). 123
- 124. variable_global_set (name, value): M odifica la variable global con el nombre de variable asignado (debe ser texto) al valor en value. variable_global_array_set (name, ind, value): M odifica el índice ind en la variable vector global unidimensional con el nombre asignado (debe ser texto) al valor en value. variable_global_array2_set (name, ind1, ind2, value): M odifica el índice ind1, ind2 en la variable vector global bidimensional con el nombre asignado (debe ser texto) al valor en value. variable_local_set (name, value): M odifica la variable local con el nombre de variable asignado (debe ser texto) al valor en value. variable_local_array_set (name, ind, value): M odifica el índice ind en la variable vector local unidimensional con el nombre asignado (debe ser texto) al valor en value. variable_local_array2_set (name, ind1, ind2, value): M odifica el índice ind1, ind2 en la variable vector local bidimensional con el nombre asignado (debe ser texto) al valor en value. Por ejemplo, puedes escribir: { if variable_global_exists('ammun ition') g lobal.ammun ition += 1 else g lobal.ammun ition = 0 } También puedes usar estas funciones para trasladar variables a un script en una forma referencial, trasladando sus nombres como texto y usando las funciones para cambiarlas. Puede cambiar la prioridad del programa con la siguiente función: set_program_priority(priority): M odifica la prioridad del programa. Puede indicarle un valor entre -3 y +3. Un valor de -3 equivale a una prioridad baja (solo seguirá con su ejecución s i no hay muchos procesos con más prioridad requiriendo poder de computo, un valor de -2 y -1 están por debajo de la ejecución normal, para que otros program as corran más velozmente. 0 es el valor normal. +1 y +2 tienen una prioridad más alta, la ejecución del juego será mejor pero requiere más poder de cómputo para si, dejando con menos espacio a otras aplicaciones. +3 es el modo tiempo real. En tiempo real la gran mayoría del procesador es dedicado al juego haciéndolo más importante que el mismo Windows, causando problemas con este y otras aplicaciones. Eventos como los de teclado pueden verse afectados también. Solo se recomienda usar esta prioridad (tiempo real) si manejarás el juego en modo exclusivo y deseas el poder de cómputo concentrado en el juego. Aún así no se recomienda usarlo así que aconsejamos usarlo prudentemente. 52.- Interacción con el usuario: No hay juego sin interacción con el usuario. La manera estándar de interactuar con el usuario en el Game M aker es colocando acciones en los eventos del ratón o del teclado. P ero en ocasiones se necesita más control. Desde una pieza de código puedes verificar la posición del ratón o si alguno de sus botones es presionado. Normalmente esto se verifica en el evento paso (step) de algún objeto controlador y llevas a cabo las acciones adecuadas. Para la interacción con el M ouse tenemos las siguientes variables y funciones: mouse_x*: coordenada-X del ratón. No puede cambiarse. mouse_y*: coordenada-Y del ratón. No puede cambiarse. mouse_button: Botón del ratón presionado actualmente. Como valores puedes emplear mb_none (ningún botón), mb_any (cualquier botón), mb_left (botón izquierdo), mb_middle (botón central) o mb_right (botón derecho). mouse_lastbutton: Último botón presionado. Para comprobar si un botón particular del M ouse está siendo presionado puedes usar las siguientes funciones. Estas se usan particularmente cuando hay múltiples botones presionados. mouse_check_button (Num): Devuelve si el botón del M ouse está siendo presionado (use como valores mb_none, mb_left, mb_middle, o mb_right). mouse_check_button_pressed (Num): Devuelve si el botón del M ouse fue presionado desde el último paso (step). mouse_check_button_released (Num): Devuelve si el botón del M ouse fue soltado desde el último paso (step). Hay algunas funciones adicionales sobre la interacción con el M ouse. mouse_clear (button): Libera el estado del botón del M ouse. Esto significa que no generará más el evento del M ouse hasta que el jugador lo suelte y lo presione de nuevo. io_clear (): Libera el estado del teclado y el M ouse. 124
- 125. io_handle (): Actualiza el estado del teclado y el M ouse. mouse_wait (): Espera hasta que el usuario presione un botón del M ouse. Para la interacción con el Teclado tenemos las siguientes variables y funciones: keyboard_lastkey: Código de la última tecla presionada. Lee más abajo las constantes de los códigos de las teclas. Puedes cambiarlo, por ejemplo. Ponerlo a 0 si tú lo manipulaste. keyboard_key: Código de tecla de la tecla presionada actualmente (ve a continuación; 0 si no hay tecla presionada). keyboard_lastchar: Último carácter introducido (como string). keyboard_string: Cadena de caracteres que contiene los últimos 80 caracteres introducidos. Esta cadena solo contendrá los caracteres imprimibles en pantalla. También responde a la tecla de retroceso borrando el último carácter. En ocasiones es útil juntar / unir una tecla a otra. Por ejemplo pudieras permitir al jugador emplear tanto las teclas del cursor como las del teclado numérico. En lugar de duplicar las acciones puedes juntar / unir el teclado numérico a las teclas del cursor. También pudieras implementar un mecanismo en el que el jugador pueda seleccionar las teclas a usar. Para este fin, contamos con las siguientes funciones keyboard_set_map (key1, key2): M apea la tecla con el código de tecla key1 a la tecla key2. keyboard_get_map (key): Devuelve el mapeado actual de la tecla key. keyboard_unset_map (): Reestablece todas las teclas a su mapa original. Para comprobar / verificar si una tecla o botón del ratón en particular han sido presionados puedes emplear las siguientes funciones. Esto es útil particularmente cuando se presionan varias teclas simultáneamente. keyboard_check (key): Indica si la tecla con el código key ha sido presionada. keyboard_check_direct (key): Indica si la tecla con el código key es presionada, verificando el hardware directamente. El resultado es independiente de la aplicación enfocada. Esta función permite verificar más. En este caso puedes emplear los códigos vk_lshift, vk_lcontrol, vk_lalt, vk_rshift, vk_rcontrol y vk_ralt para verificar si se presiona la tecla shift, control o alt, ya sea izquierda o derecha. (¡No funciona en Windows 95!). mouse_check_button (Num): Indicas si se presiona el botón del ratón Num (como valores de Num puedes emplear mb_none (ninguno), mb_left (derecho), mb_middle (central), o mb_right (derecho)). Las siguientes rutinas pueden emplease para manipular el estado del teclado: keyboard_get_numlock (): Indica si BloqNum está activada. keyboard_set_numlock (on): Activa (on=true) o desactiva (on=false) BloqNum. (No funciona en Windows 95). keyboard_key_press (key): Simula el presionar de la tecla con el código key. keyboard_key_release (key): Simula la liberación de la tecla con el código key. Tenemos las siguientes constante para los códigos de las teclas: vk_nokey: código que representa que ninguna tecla está presionada vk_anykey: código que representa que alguna tecla ha sido presionada vk_left: código para la tecla de la flecha izquierda vk_right: código para la tecla de la flecha derecha vk_up: código para la tecla de la fecha hacia arriba vk_down: código para la tecla de la flecha hacia abajo vk_enter: tecla enter (o intro) vk_escape: tecla escape vk_space: tecla espacio vk_shift: tecla shift vk_control: tecla control vk_alt: tecla alt vk_backspace: tecla de retroceso vk_tab: tecla tabuladora vk_home: tecla inicio vk_end: tecla fin vk_delete: tecla suprimir o borrar vk_insert: tecla insert vk_pageup: tecla AvPag vk_pagedown: tecla RePag vk_pause: tecla Pausa/Inter vk_printscreen: tecla ImpPnt/PetSis vk_f1 … vk_f12: códigos para las teclas de función desde F1 a F12 vk_numpad0 … vk_numpad9: teclas numéricas en el teclado numérico vk_multiply: tecla de multiplicación en el teclado numérico 125
- 126. vk_di vide: tecla de división en el teclado numérico vk_add: tecla de suma en el teclado numérico vk_subtract: tecla de resta en el teclado numérico vk_decimal: tecla del punto decimal en el teclado numérico Para teclas de letras use la función ord (carácter) que devuelve el keycode del carácter escrito. Por ejemplo, para comprobar si la tecla A está siendo presionada ord('A'). Las siguientes constantes pueden ser solamente usadas en keyboard_check_direct: vk_lcontrol: tecla control izquierda vk_lalt: tecla alt izquierda vk_rshift: tecla shift derecha vk_rcontrol: tecla control derecha vk_ralt: tecla alt derecha ¡No funcionan en versiones anteriores de Windows 98! Por ejemplo, asumiendo que tienes un objeto que el usuario puede controlar con las teclas del cursor puedes colocar el siguiente código en el evento step del objeto: { if (keyboard_check(vk_left)) x -= 4; if (keyboard_check(vk_right)) x += 4; if (keyboard_check(vk_up)) y -= 4; if (keyboard_check(vk_down)) y += 4; } Por supuesto que esto es mucho más fácil si simplemente lo ponemos en los eventos del teclado correspondientes. Hay algunas funciones adicionales relacionadas con la interacción con el teclado y el M ouse: keyboard_clear (key): „Limpia‟ el estado de la tecla key. Esto significa que no generará eventos de teclado hasta que se vuelva a presionar. mouse_clear (button): „Limpia‟ el estado del botón del ratón button. Esto significa que no generará eventos del ratón hasta que el jugador lo suelte y lo vuelva a presionar. io_clear (): „Limpia‟ todos los estados del teclado y del ratón. io_handle (): M aneja la entrada y salida por parte del usuario, actualizando los estados del teclado y del ratón. keyboard_wait (): Espera hasta que el usuario presione una tecla del teclado. 52.1.- Soporte para joystick: Tenemos algunos eventos asociados con los joysticks (mandos de control, controles, palancas de mando, palancas de juego, etc.) Pero para tener control total sobre los joysticks hay un grupo de funciones para tratarlos. El Game M aker soporta hasta dos joystick. Por lo que todas estas funciones reciben el id del joystick como argumento. joystick_exists (id): Indica si el joystick id (1 o 2) existe. joystick_name (id): Devuelve el nombre del joystick. joystick_axes (id): Devuelve el número de ejes del joystick. joystick_buttons (id): Devuelve el número de botones del joystick. joystick_has_pov (id): Indica si el joystick tiene capacidades point-of-view. joystick_direction (id): Devuelve el código (vk_numpad1 a vk_numpad9) correspondiente a la dirección del joystick id (1 o 2). joystick_check_button (id, numb): Indica si el botón del joystick id es presionado (numb está en el intervalo 1-32). joystick_xpos (id): Devuelve la posición (-1 a 1) del eje-x del joystick id. joystick_ypos (id): Devuelve la posición y del joystick id. joystick_zpos (id): Devuelve la posición z del joystick id (si es que cuenta con eje z). joystick_rpos (id): Devuelve la posición del timón del joystick id (del cuarto eje). joystick_upos (id): Devuelve la posición u del joystick id (del quinto eje). joystick_vpos (id): Devuelve la posición v del joystick id (del sexto eje). joystick_pov (id): Devuelve la posición del point-of-view del joystick id. Este es un ángulo entre 0 y 360 grados. 0 es adelante, 90 a la derecha, 180 atrás y 270 a la izquierda. Cuando no se presiona ninguna dirección del punto de vista (point-of-view) se devuelve –1. 53.- Gráficos del juego: Una parte importante de un juego son los gráficos. Game M aker normalmente se encarga de esto y en juegos simples no hay de que preocuparse. Pero algunas veces quieres más control. Para algunos aspectos hay acciones pero con código puedes controlar más aspectos. Este capítulo describe todas las variables para esto y da más información acerca de lo que realmente está sucediendo. 126
- 127. 53.1.- Sprites (Imágenes): Cada objeto en la mayoría de los casos, tiene una imagen asociada a él. Ésta puede ser una imagen simple o consistir de imágenes múltiples. Por cada instancia del objeto, el programa dibuja la imagen correspondiente en la pantalla con su origen (definido en las propiedades del sprite) en la posición (x, y) de la instancia. Cuando hay imágenes múltiples, cicla a través de las imágenes para tener un efecto de animación. Hay un número de variables que afectan la manera en la que se dibuja la imagen. Estas pueden ser usadas para cambiar el efecto. Cada instancia tiene las siguientes variables: visible: Si es verdadera (1) la imagen es dibujada, de lo contrario no se dibuja. Las instancias invisibles están aún activas y generan eventos de colisión; sólo tú no las ves. Poner la visibilidad en falso es útil, por ejemplo, objetos controladores (hazlos no sólidos para evitar eventos de colisión) o interruptores escondidos. sprite_index: Este es el índice de la imagen (sprite) actual de la instancia. Puedes cambiarlo para darle a la instancia un sprite diferente. Como valor puedes usar los nombres que le hayas asignado a los diferentes sprites creados. Cambiar el sprite no cambia el índice de la sub-imagen visible actual. sprite_width*: Indica el ancho del sprite. Este valor no puede ser cambiado pero puede que quieras usarlo. sprite_height*: Indica la altura del sprite. Este valor no puede ser cambiado pero puede que quieras usarlo. sprite_xoffset*: Indica el origen horizontal del sprite como fue definido en las propiedades del sprite. Este valor no puede ser cambiado pero puede que quieras usarlo. sprite_yoffset*: Indica el origen vertical del sprite como fue definido en las propiedades del sprite. Este valor no puede ser cambiado pero puede que quieras usarlo. image_number*: El número de sub-imágenes del sprite actual. (No puede ser cambiado) image_index: Cuando la imagen tiene múltiples sub-imágenes el programa cicla a través de ellos. Esta variable indica la sub-imagen actualmente dibujada (se numeran a partir del 0). Puedes cambiar la imagen actual cambiando esta variable. El programa va a continuar ciclando a partir de este nuevo índice. image_single: Algunas veces quieres que una sub-imagen particular sea vis ible y no quieres que el programa cambie a través del resto. Esto se puede lograr asignando a esta variable el índice el la sub-imagen que quieres que quieres ver (la primera sub-imagen tiene el índice 0). Dale el valor de –1 para ciclar a través de las sub-imágenes. Esto es útil cuando un objeto tiene múltiples apariencias. Por ejemplo, supón que tienes un objeto que puede rotar y creas un sprite que tiene sub-imágenes para varias orientaciones (contra-reloj). Entonces, en el evento step del objeto puedes poner: { image_single = d irection * image_number/360; } image_speed: La velocidad con la que se cicla a través de las sub-imágenes. Un valor de 1 indica que en cada paso (step) se obtiene la siguiente imagen. Valores más pequeños cambian la sub-imagen más lento, mostrando cada imagen múltiples ocasiones. Valores más grandes saltarán imágenes para hacer el movimiento más rápido. depth: Normalmente las imágenes son dibujadas en el orden en el que se crearon las instancias. Puedes cambiar esta indicando la profundidad (depth) de la imagen. El valor original es 0 a menos que especifiques un valor diferente en las propiedades del objeto. M ientras más alto sea el valor, la imagen está más lejos. (También puedes usar valores negativos). Las instancias con una profundidad mayor quedarán dibujadas detrás de las instancias de profundidad menor. Indicar la profundidad garantiza que las imágenes se dibujaran en el orden que quieras. (Por ejemplo, el avión enfrente de la nube). Las instancias que se usen como fondo deben de tener una profundidad positiva muy alta, y las de primer plano (foreground) una profundidad negativa muy baja. image_scale: Un factor de escala que hace grande o pequeña a las imágenes. Un valor de 1 indica el tamaño normal. Cambiarla escala también cambia los valores del ancho y alto de la imagen e influencia las colisiones como puedes esperar. Nota que las imágenes escaladas (en particular cuando las haces más pequeñas) toman más tiempo de dibujar. Cambiar la escala puede ser usado para obtener un efecto de 3-D. image_alpha: El valor de la transparencia (alpha) para usar en la imagen. Un valor de 1 es la condición normal. Un valor de 0 es completamente transparente. Úsalo con cuidado. Dibujar imágenes parcialmente transparentes toma mucho tiempo y puede reducir la velocidad del juego. bbox_left*: Lado izquierdo de la caja perimetral usado para la imagen de la instancia. (Tomando en cuenta la escala) bbox_right*: Lado derecho de la caja perimetral de la imagen de la instancia. bbox_top*: Lado superior de la caja perimetral de la imagen de la instancia. bbox_bottom*: Lado inferior de la caja perimetral de la imagen de la instancia. 53.2.- Backgrounds (Fondos): Cada cuarto puede tener hasta 8 fondos. También tiene un color de fondo. Todos los aspectos de estos fondos pueden ser cambiados usando las siguientes variables. (Algunas variables son arreglos que van del 0 al 7 indicando los diferentes fondos): 127
- 128. background_color: El color de fondo del cuarto background_showcolor: Indica si despejar la ventana en el color del fondo background_visible[0..7]: Indica sI la imagen de fondo es visible. background_foreground[0..7]: Indica si el fondo es una imagen de primer plano. background_index[0..7]: Índice de la imagen del fondo. background_x[0..7]: Posición X de la imagen de fondo. background_y[0…7]: Posición Y de la imagen de fondo. background_width[0…7]*: Ancho de la imagen de fondo. background_height[0…7]*: Altura de la imagen de fondo. background_htiled[0..7]: Indica si el fondo es de mosaico horizontalmente. background_vtiled[0..7]: Indica si el fondo es de mosaico vertical. background_hspeed[0..7]: Velocidad de desplazamiento horizontal del fondo (píxeles p or paso). background_vspeed[0..7]: Velocidad de desplazamiento vertical del fondo (píxeles por paso). background_alpha[0..7]: Valor de transparencia (alpha) al dibujarse el fondo. Un valor de 1 es el valor normal; un valor de 0 es completamente transparente. Úsalo con cuidado. Dibujar un fondo parcialmente transparente toma mucho tiempo y puede hacer lento el juego. background_blend[0..7]: Color de mezclado para dibujar el background. Solo disponible en la versión registrada. 53.3.- Di bujando fondos y sprites: Los objetos normalmente poseen un sprite asociado a el. Sin embargo, puedes usar el evento draw para dibujar otras cosas. Esta sección y la siguiente le darán la información necesaria para lograr esto. draw_sprite (spr, subimg, x, y): Dibuja el sprite spr en la subimagen subimg en la posición (x, y). draw_sprite_stretched (sprite, subimg, x, y, w, h): Dibuja el sprite estirado para que entre en la región dada. draw_sprite_tiled (sprite, subimg, x, y): Dibuja el sprite repetido para que entre en todo el room. draw_sprite_part (s prite, subimg, left, top, width, height, x, y): Dibuja la parte del sprite en la subimagen, con los valores dados. draw_background (back, x, y): Dibuja un background en posición (x, y). draw_background_stretched (back, x, y, w, h): Dibuja un background estirado en la región indicada. draw_background_tiled (back, x, y): Dibuja un background repetido para que entre en todo el room. draw_background_part (back, left, top, width, height, x, y): Dibuja la parte indicada del background. Las siguientes funciones extienden las funciones indicadas anteriormente. Solo disponibles en la versión registrada: draw_sprite_ext (sprite, subimg, x, y, xscale, yscale, rot, color, alpha): Dibuja el sprite escalado con los factores xscale e yscale, rotados anti-horario según rot. Color es el color de mezclado usado (Use c_white para no mezclado) Y alpha indica la transparencia en la que es dibujado. Un valor de 0 lo hace completamente transparente. Un valor de 1 lo dibuja con la transparencia normal. draw_sprite_stretched_ext (sprite, subimg, x, y, w, h, color, alpha): Dibuja un sprite estirado para que entre en la región indicada, color es el color de mezclado y alpha indica la transparencia. draw_sprite_tiled_ext (sprite, subimg, x, y, xscale, yscale, color, alpha): Dibuja un sprite repetido para que entre totalmente en el room, pero ahora con escala, color, y transparencia. draw_sprite_part_ext (sprite, subimg, left, top, width, height, x, y, xscale, yscale, color, alpha): Dibuja la parte indicada del sprite, pero ahora con escala, color y transparencia. draw_sprite_general (sprite, subimg, left, top, width, height, x, y, xscale, yscale, rot, c1, c2, c3, c4, alpha): La función para dibujar sprites más general de todas. Dibuja una parte del sprite, en la subimagen, empezando por left como borde izquierdo, y top como borde superior. Con el ancho width y altura height, en la posición (x, y). Escalado horizontalmente por xscale y verticalmente por yscale. Rotado según rot, con los colores de mezclados c1, c2, c3 y c4. Y con la transparencia alpha. draw_background_ext (back, x, y, xscale, yscale, rot, color, alpha): Dibuja el background escalado y rotado con color de mezclado y transparencia. draw_background_stretched_ext (back, x, y, w, h, color, alpha): Dibuja el background estirado en la región indicada. Color es el color de mezclado y alpha indica la transparencia. draw_background_tiled_ext (back, x, y, xscale, yscale, color, alpha): Dibuja el background repetido para que entre en el room, pero ahora con escala, color y transparencia. draw_background_part_ext (back, left, top, width, height, x, y, xscale, yscale, color, alpha): Dibuja la parte indicada del background, pero ahora con escala, color y transparencia. draw_background_general (back, left, top, width, height, x, y, xscale, yscale, rot, c1, c2, c3, c4, alpha): La función más general para dibujar backgrounds. Dibuja la parte indicada por top -left (Borde izquierdo y borde superior) en la posición (x, y) pero con escala, ángulo de rotación, y un color para cada vértice. También un valor de transparencia (alpha). 128
- 129. 53.4.- Di bujando Formas: Hay una cantidad de funciones disponibles para dibujar diversas formas. También hay funciones para dibujar textos. Solo puedes usar esto en el evento draw de un objeto. Ten en cuenta que las colisiones se generan dependiendo de la imagen mascara (sprite/mask) del objeto, y no por lo que dibujes. Las siguientes funciones existen para dibujar simples formas. draw_clear (col): Llena el room entero con el color dado. (No lo mezcla) draw_clear_alpha (col, alpha): Llena el room entero con el color y luminosidad dada. draw_point (x, y): Dibuja un punto a (x, y). draw_line (x1, y1, x2, y2): Dibuja una línea desde (x1, y1) hasta (x2, y2). draw_rectangle (x1, y1, x2, y2, outline): Dibuja un rectángulo, outline indica si debe dibujar solo el borde (true) o si lo debe dibujar relleno (false). draw_roundrect (x1, y1, x2, y2, outline): Dibuja un rectángulo redondeado, outline indica si debe dibujar solo el borde (true) o si lo debe dibujar relleno (false). draw_triangle (x1, y1, x2, y2, x3, y3, outline): Dibuja un triángulo, outline indica si debe dibujar solo el borde (true) o si lo debe dibujar relleno (false). draw_circle (x, y, r, outline): Dibuja un círculo en posición (x, y ) con radio r, outline indica si debe dibujar solo el borde (true) o si lo debe dibujar relleno (false). draw_ellipse (x1, y1, x2, y2, outline): Dibuja una elipse, outline indica si debe dibujar solo el borde (true) o si lo debe dibujar relleno (false). draw_arrow (x1, y1, x2, y2, size) Dibuja una flecha desde (x1, y1) hasta (x2, y2), size indica el tamaño de la flecha en píxeles. draw_button (x1, y1, x2, y2, up): Dibuja un botón, up indica si está presionado o no. draw_path (path, x, y, absolute): Con esta función puedes dibujar el path indicado empezando con la posición inicial del path. Si absolute es true el path es dibujado en la posición donde es definido, y los valores x, y son ignorados. draw_healthbar (x1, y1, x2, y2, amount, backcol, mincol, maxcol , direction, showback, showborder): Con esta función puedes dibujar una barra de vida (O cualquier otra barra que indique algún valor), x1, y1, x2, y2 indica el área total de la barra, amount indica el porcentaje de la barra que debe ser llenado, backcol es el color del background para la barra, mincol y maxcol indica el color cuando la barra es 0 y 100 respectivamente. Para un valor intermedio los colores son mezclados, direction indica la dirección en que la barra es dibujada. Finalmente showback indica si el background cuando la barra no esté llena debería ser dibujado. La mayoría de las funciones anteriores usan alpha y color que pueden ser modificados con las siguientes funciones: draw_set_color (col): M odifica el color con que será usado para dibujar los colores anteriores. draw_set_alpha (alpha): M odifica la transparencia que es usada para dibujar los colores anteriores. draw_get_color (): Devuelve el color usado para dibujar los colores anteriores. draw_get_alpha (): Devuelve la transparencia usada para dibujar los colores anteriores. Hay colores ya definidos que pueden ser usados: c_aqua c_black c_blue c_dkgray c_fuchsia c_gray c_green c_lime c_ltgray c_maroon c_navy c_olive c_purple c_red c_silver c_teal c_white c_yellow Las siguientes funciones te pueden ayudar a crear el color que desees. make_color_rgb (red, green, blue): Devuelve el color obtenido según lo indiquen sus argumentos, red (rojo), green (verde), y blue (azul). El valor debe estar entre 0 y 255. make_color_hsv (hue, saturation, value): Devuelve el color obtenido según lo indiquen sus argumentos. color_get_red (col): Devuelve el valor rojo de un color. color_get_green (col): Devuelve el valor verde de un color. color_get_blue (col): Devuelve el valor azul de un color. color_get_hue (col): Devuelve el valor hue de un color. color_get_saturation (col): Devuelve el valor saturation de un color. color_get_value (col): Devuelve el value de un color. merge_color (col1, col2, amount): Devuelve el color resultante de mezclar el col1 con col2, determinado por amount. Las siguientes funciones extras existen: 129
- 130. draw_getpíxel (x, y): Devuelve el color que se encuentra en la posición (x,y) en el room. No es muy rápida, úsala con cuidado. screen_save (fname): Guarda la imagen visible de la pantalla con el nombre fname. El formato es BM P. Útil para screenshots. screen_save_part (fname, x, y, w, h): Como la anterior, solo que guarda una parte de la pantalla. 53.5.- Fuentes o Texto: En los juegos generalmente necesitas dibujar textos. Para dibujar un texto debes especificar que fuente deseas usar. Las fuentes pueden ser definidas en el game maker, o por medio de las funciones correspondientes. Hay diversas funciones para dibujar textos en diferentes formas. En cada función debes especificar la posición en la pantalla. Para dibujar textos, existen las siguientes funciones: draw_set_font (font): Especifica la fuente que será usada para dibujar textos. Si no se indica, se usará la fuente por defecto (Arial 12) draw_set_halign (halign): Especifica la alineación horizontal usada para dibujar el texto. Elige una de las siguientes constantes: fa_left: alineado hacia la izquierda. fa_center: alineado hacia en el centro. fa_right: alineado hacia la derecha. draw_set_valign (valign): Especifica la alineación vertical usada para dibujar el texto. Utiliza Una de las siguientes constantes. fa_top: alineado arriba. fa_middle: alineado en medio. fa_bottom: alineado abajo. draw_text (x, y, string): Dibuja una cadena (string) en posición (x, y). El carácter # indica una línea nueva. Utiliza # para dibujar el símbolo #. draw_text_ext (x, y, string, sep, w): Similar a la anterior, pero puedes especificar un par de argumentos más, sep indica la separación entre renglones, w indica el ancho del texto en píxeles. string_width (string): Devuelve el ancho del texto string. string_height (string): Devuelve la altura del texto string. string_width_ext (string, sep, w): Ancho del string en la fuente actual. string_height_ext (string, sep, w): Altura del string en la fuente actual. Las siguientes funciones existen para dibujar textos escalados, rotados, e incluso degradados de colores. Estas funciones están solamente disponibles en la versión registrada. draw_text_transformed (x, y, string, xscale, yscale, angle): Dibuja el string en la posición (x, y), pero con escala horizontal y vertical, y rotación indicadas. draw_text_ext_transformed (x, y, string, sep, w, xscale, yscale, angle): Combinación de la función draw_text_ext y draw_text_transformed. draw_text_color (x, y, string, c1, c2, c3, c4, alpha): Dibuja el string en la posición (x, y). Con los 4 colores indicados, alpha es la transparencia usada para dibujar (0-1). draw_text_ext_color (x, y, string, sep, w, c1, c2, c3, c4, alpha): Similar a draw_text_ext() pero con vértices coloreados. draw_text_transformed_color (x, y, string, xscale, yscale, angle, c1, c2, c3, c4, alpha): Similar a draw_text_transformed() pero con vértices coloreados. draw_text_ext_transformed_color (x, y, string, sep, w, xscale, yscale, angle, c1, c2, c3, c4, alpha): Similar a draw_text_ext_transformed() pero con los vértices coloreados. 53.6.- Funci ones avanzadas de di bujo: Estas funciones están solamente disponibles en la versión registrada del Game M aker. Anteriormente un número de funciones para dibujar han sido descritas. Aquí encontrarás un número adicional de funciones que te darán muchas más posibilidades Las siguientes versiones extendidas de las funciones para dibujar existe: draw_point_color (x, y, col1): Dibuja un punto en (x, y) con el color indicado. 130
- 131. draw_line_color (x1, y1, x2, y2, col1, col2): Dibuja una línea desde (x1, y1) hasta (x2, y2) con los colores col1 y col2 draw_rectangle_color (x1, y1, x2, y2, col1, col2, col3, col4, outline): Dibuja un rectángulo. Los 4 colores indican los colores en que será degradado el rectángulo desde sus 4 vértices, outline indica si se debe dibujar solo el borde (true) o relleno (false). draw_roundrect_color (x1, y1, x2, y2, col1, col2, outline): Dibuja un rectángulo redondeado. col1 y col2 son los colores utilizados, outline indica si solo se debe dibujar el borde (true) o relleno (false). draw_triangle_color (x1, y1, x2, y2, x3, y3, col1, col2, col3, outline): Dibuja un triángulo. Los 3 colores son los colores de los vértices, que serán degradados, outline indica si solo se debe dibujar el borde (true) o relleno (false). draw_circle_color (x, y, r, col1, col2, outline): Dibuja un círculo en posición (x, y) con radio r. col1 es el color del centro, y col2 es el color del borde, outline indica si solo se debe dibujar el borde (true) o relleno (false). draw_ellipse_color (x1, y1, x2, y2, col1, col2, outline) Dibuja una elipse, en la posición (x, y), col1 es el color del centro, y col2 es el color del borde, outline indica si solo se debe dibujar el borde (true) o relleno (false). Puedes también dibujar los colores anteriores. Estos funcionan un poco diferentes a las funciones anteriores. Primero especificas el color primario para que empiece a dibujarse, y le a gregas vértices, hasta indicarle que el color primario no se dibuje más. Cuando se le pida el tipo (kind) de color primario que desee dibujar, las siguientes constantes existen: pr_pointlist: Los vértices son a base de puntos. pr_linelist: Los vértices son a base de líneas formando segmentos. pr_linestrip: Los vértices forman líneas que son conectadas el primer vértice con el segundo, el segundo con el tercero, etc. Nota: El último no es conectado con el primero, en caso de así quererlo, deberás especificar un último vértice. pr_trianglelist: Los vértices son a base de triángulos. El número de vértices debe ser múltiplo de 3. pr_trianglestrip: Los vértices forman triángulos, solo que esta vez funciona un poco diferente. Los 3 primeros forman el primer triángulo. Los últimos 2 vértices, juntos con el siguiente, forman el segundo triángulo, y así sucesivamente. pr_trianglefan: Similar a pr_trianglelist pero esta vez el primer vértice es parte de todos los triángulos. Las siguientes funciones existen para dibujar el color primario . draw_color primario _begin (kind): Comienza el color primario con el kind indicado. draw_vertex (x, y): Agrega el vértice (x, y) al color primario. draw_vertex_color (x, y, col, alpha): Agrega el vértice (x, y) al color primario, con el color y alpha indicados. draw_color primario _end (): Indica que todos los vértices deseados fueron agregados, dibujando el color primario correspondiente. Finalmente, es posible dibujar un color primario usando en las imágenes (sprites) o fondos (backgrounds) como texturas. Para lograr esto las siguientes funciones existen: sprite_get_texture (spr, subimg): Devuelve el id de la textura que posee el sprite. Debe ser usado para indicar la textura luego. background_get_texture (back): Devuelve el id de la textura correspondiente al background indicado. La textura elegida puede no estar en la memoria del video. El sistema lo hará automáticamente cuando lo necesite, pero también lo puedes decidir tú mismo. Para eso existen las siguientes funciones: texture_preload (texid): Hace que la textura indicada sea puesta inmediatamente en la memoria del video. texture_set_priority (texid, prio): Cuando hay poca memoria de video, algunas texturas serán removidas para dar lugar a las otras. Las que posean menos prioridad serán removidas primero. Usa valores positivos. Para agregar texturas a tus colores primarios debes especificar que parte de la textura debe dibujarse en el color primario. Posiciones en la textura son indicadas con valores entre 0 y 1. El tamaño de la textura debe ser potencia de 2. Si deseas usar sprites o backgrounds como texturas, debes asegurarte que posean ese tamaño. Para saber que parte de la textura está siendo usada, puedes usar las siguientes 2 funciones. Estas funciones devuelven un valor entre 0 y 1 que indica el ancho o la altura de la parte actual de la textura siendo usada. texture_get_width (texid): Devuelve el ancho de la textura con el id indicado. El ancho será entre 0 y 1. texture_get_height (texid): Devuelve la altura de la textura con el id indicado. La altura será entre 0 y 1. Para dibujar un color primario con texturas, puedes usar las siguientes funciones: draw_color primario _begin_texture (kind, texid): Empieza a dibujar un color primario, pero con la textura dada. 131
- 132. draw_vertex_texture (x, y, xtex, ytex): Agrega un vértice al color primario, como en la función explicada anteriormente, solo que con la textura en la posición xtex y ytex. draw_vertex_texture_color (x, y, xtex, ytex, col, alpha): Agrega un vértice con color, a la vez con la posición de la textura indicada. draw_color primario _end (): Indica que todos los vértices deseados fueron agregados, dibujando el color primario correspondiente. Hay 3 funciones que influencian en como las texturas son dibujadas: texture_set_interpolation (linear): Indica si usar interpolación linear (true) o tomar el píxel más cercano (false), interpolation linear, da texturas más suaves, pero puede también ser un poco borroso, e incluso tomar tiempo extra. texture_set_blending (blend): Indica si usaras colores de mezclados cuando se dibujan texturas. Siendo esto false puede ser más rápido para un hardware antiguo. texture_set_repeat (repeat): Indica si se debe repetir la textura. Hay 2 funciones más que no son solamente útiles para dibujar texturas. Normalmente los colores primarios son mezclados con el background usando el valor alpha. Puedes indicar como deseas que esto pase. draw_set_blend_mode (mode): Indica que modo de mezclado usar. Los siguientes valores con posibles: bm_normal, bm_add, bm_subtract, y bm_max. No olvides volver al modo normal después de usarlo, ya que esto afecta a los sprites e incluso los backgrounds. draw_set_blend_mode_ext (src, dest): Indica que modo de mezclado usar, para la fuente y el color de destino. La fuente y el destino poseen un valor de rojo, verde, azul y luminosidad.pha component. Puedes elegir una de las siguientes constantes: bm_ zero: (0, 0, 0, 0). bm_one: (1, 1, 1, 1). bm_src_color: (Rs, Gs, Bs, As). bm_inv_src_color: (1– Rs, 1– Gs, 1– Bs, 1–As). bm_src_alpha: (As, As, As, As). bm_inv_src_alpha: (1–As, 1–As, 1–As, 1–As). bm_dest_alpha: (Ad, Ad, Ad, Ad). bm_inv_dest_alpha: (1–Ad, 1–Ad, 1–Ad, 1–Ad). bm_dest_color: (Rd, Gd , Bd, Ad). bm_inv_dest_color: (1– Rd, 1– Gd, 1– Bd, 1–Ad). bm_src_alpha_sat: (f, f, f, 1); f = min(As, 1–Ad). Dibujar color primario con texturas, puede resultar trabajoso. Pero trae buenos resultados. 53.7.- Di bujando superficies (surfaces): Estas funciones están solamente disponibles en la versión registrada de Game M aker. En ciertas situaciones no deseas dibujar directamente en la pantalla, sino que quieres dibujar una superficie (surface) determinada. Esto te da la posibilidad de guardar una serie de imágenes y guardarlas en la superficie (surface). Y luego simplemente dibujar la superficie (surface), en vez de dibujar toda la serie de imágenes. Son simples de usar. Primero creas la textura, luego indicas, que lo que sea dibujado en pantalla debe agregarse a la superficie (surface). Hay algunas cosas con las que tener cuidado cuando se dibujan superficies (surfaces), ver al final de la página. Las siguientes funciones existen, para tratar con superficies (surfaces): surface_create (w, h): Crea una superficie (surface) con el ancho (w) y altura (h) indicados. Devuelve el index de la superficie (surface) que debe ser usado en otras funciones. surface_free (id): Libera la memoria usada por la superficie (surface). surface_exists (id): Devuelve si la superficie (surface) especificada existe. surface_get_width (id): Devuelve el ancho de la superficie (surface). surface_get_height (id): Devuelve la altura de la superficie (surface). surface_get_texture (id): Devuelve la textura correspondiente a la superficie (surface). surface_set_target (id): Indica que todo lo que sea dibujado se agregue a la superficie (surface). surface_reset_target (): Hace que se deje de agregar lo que sea dibujado a la superficie (surface). Debería ser llamado antes de que el evento draw termine. surface_getpíxel (id, x, y): Devuelve el color del píxel correspondiente a la posición (x,y) en la superficie (surface). surface_save (id, fname): Guarda la superficie (surface) en el archivo indicado. El formato es BM P. surface_save_part (id, fname, x, y, w, h): Como la anterior, solo que guarda solo una parte de la superficie (surface). 132
- 133. draw_surface (id, x, y): Dibuja la superficie (surface) en posición (x,y). draw_surface_stretched (id, x, y, w, h): Dibuja la superficie (surface) estirada hasta la región indicada. draw_surface_tiled (id, x, y): Dibuja la superficie (surface) repetida para que entre en todo el room. draw_surface_part (id, left, top, width, height, x, y): Dibuja una parte de la superficie (surface), según los argumentos dados. draw_surface_ext (id, x, y, xscale, yscale, rot, color, alpha): Dibuja la superficie (surface) escalada, rotada, con color y transparencia dados. draw_surface_stretched_ext (id, x, y, w, h, color, alpha): Dibuja la superficie (surface) estirada en la región indicada, color es el color de mezclado, y alpha indica la transparencia. draw_surface_tiled_ext (id, x, y, xscale, yscale, color, alpha): Dibuja la superficie (surface) repetida para que entre en todo el room, pero ahora con escala, color y transparencia. draw_surface_part_ext (id, left, top, width, height, x, y, xscale, yscale, color, alpha): Dibuja la parte indicada de la superficie (surface), con el origen en posición (x, y) pero ahora con escala, color y transparencia. draw_surface_general (id, left, top, width, height, x, y, xscale, yscale, rot, c1, c2, c3, c4, alpha): La función más general para dibujar superficies (surfaces). Dibuja la parte indicada en la posición indicada, con escala, rotación, un color para cada uno de los 4 vértices, y transparencia. surface_copy (destination, x, y, source): Copia la superficie (surface) en posición (x, y) en la superficie (surface) destination (de destino). surface_copy_part (destination, x, y, source, xs, ys, ws, hs): Copia la parte indicada de la superficie (surface) source, en posición (x, y) a la superficie (surface) destination. Tenga en cuenta que no hay funciones para copiar una parte de la pantalla a la superficie (surface). Esto es imposible debido a las posibles diferencias entre los formatos de la pantalla y de la superficie (surface). Si necesitas hacer eso, deber guardar la pantalla en una superficie (surface), y luego copiarla en otra. También ten en cuenta que puedes crear backgrounds y sprites a partir de superficies (surfaces). Algunos cuidados se deben tener en cuenta al usar estas funciones. En particular, ten en cuenta lo siguiente: Nunca debes cambiar la superficie (surface) a la que se está dibujando, sin antes reiniciarlas. Esto causará serios problemas. Las superficies (surfaces) no funcionan correctamente en 3D. Por razones de velocidad, las sup erficies (surfaces) se mantienen en la memoria de video solamente. Por esta razón puedes perder una superficie (surface) si cambia la resolución, o si un protector de pantalla se ejecuta. Las superficies (surfaces) no serán guardadas cuando guardes el juego. 53.8.- Tiles (mosaicos): Como debes saber, puedes agregar tiles a los rooms. Un tile es parte de un background, no reaccionan a eventos, y no generan colisiones. Como resultado, los tiles son mucho más rápidos que los objetos. Puedes tener más control sobre los tiles de lo que crees. Puedes agregar tiles cuando estás diseñando el room, pero también puedes hacerlo mientras el juego está siendo ejecutado. Puedes modificar sus posiciones, escalarlos, o hacerlos parcialmente transparentes. Un tile posee las siguientes propiedades: background: El background de donde el tile es tomado. left, top, width, height: Borde izquierdo, superior, ancho y altura del tile, respectivamente. x, y: La posición del tile en el room. depth: La profundidad del tile. Puedes elegir cualquier profundidad. visible: Si el tile es visible (true) o no (false). xscale, yscale: La escala con la que el tile es dibujado. blend: El color de mezclado usado para dibujar el tile. alpha: Indica la transparencia del tile.1 = sin transparencia, 0 = completamente transparente. Para cambiar las propiedades de un tile en particular, debes conocer su id. El id lo puedes ver en el room, en la barra inferior cuando se posiciona el cursor del M ouse encima a un tile. También hay una función para obtener el id del tile en una posición particular. Las siguientes funciones existen para tratar con tiles: tile_add (background, left, top, width, height, x, y, depth): Agrega un tile en el room indicado por los argumentos pedidos. Devuelve el id del tile creado. tile_delete (id): Elimina el tile del id dado. tile_exists (id): Devuelve si un id de tile existe. tile_get_x (id): Devuelve la posición en x del tile especificado. tile_get_y (id): Devuelve la posición en y del tile especificado. tile_get_left (id): Devuelve el borde izquierdo del tile especificado. tile_get_top (id): Devuelve el borde superior del tile especificado. tile_get_width (id): Devuelve el ancho del tile especificado. 133
- 134. tile_get_height (id): Devuelve la altura del tile especificado. tile_get_depth (id): Devuelve la profundidad del tile especificado. tile_get_visible (id): Devuelve si el tile especificado es visible o no. tile_get_xscale (id): Devuelve el valor de la escala horizontal del tile dado. tile_get_yscale (id): Devuelve el valor de la escala vertical del tile dado. tile_get_background (id): Devuelve el background al que pertenece el tile dado. tile_get_blend (id): Devuelve el color con el que está mezclado el tile dado. tile_get_alpha (id): Devuelve la transparencia del tile dado. tile_set_position (id, x, y): M odifica la posición del tile especificado tile_set_region (id, left, right, width, height): Especifica la región en la que encuentra el tile en el background. tile_set_background (id, background): M odifica el background para el tile con el id dado. tile_set_visible (id, visible): M odifica si el tile con el id dado es visible o no. tile_set_depth (id, depth): M odifica el depth (profundidad) del tile dado. tile_set_scale (id, xscale, yscale): M odifica la escala del tile con el id dado. tile_set_blend (id, color): M odifica el color con el que el tile está mezclado. Solamente disponible en la versión registrada. tile_set_alpha (id, alpha): M odifica la transparencia del tile con el id dado. Las siguientes funciones existen para tratar con las diversas capas de los tiles: tile_layer_hide (depth): Esconde todos los tiles que se encuentren en la profundidad dada. tile_layer_show (depth): M uestra todos los tiles en la profundidad dada. tile_layer_delete (depth): Elimina todos los tiles en la profundidad dada. tile_layer_shift (depth, x, y): M ueve todos los tiles que se encuentren en la profundidad dada, sobre el vector (x,y). tile_layer_find (depth, x, y): Devuelve el id del tile en la posición (x,y) con la profundidad dada. Cuando el tile no existe, devuelve -1. tile_layer_delete_at (depth, x, y): Elimina el tile en la posición dada. Con la profundidad especificada. tile_layer_depth (depth, newdepth): M odifica la profundidad de todos los tiles que posean la misma profundidad especificada a una nueva profundidad. 53.9.-El dis play (Monitor): El display representa toda el área del monitor. Tiene un tamaño (generalmente de 1024x768, o 1280x1024), un color depth, que es el número de bits que son usados para representar un simple píxel( gener almente 16 o 32), y una frecuencia, que es el número de veces por segundo que el display es dibujado, (generalmente entre 60 y 120). Estas configuraciones pueden ser modificadas por las propiedades del display. Para juegos, particularmente corre en full- screen (pantalla completa), es importante poder modificar estas configuraciones. Todas estas configuraciones pueden ser inicializadas por el menú Game Settings. Pero además, existen las siguientes funciones para modificar estas configuraciones dentro del juego. Estas funciones están solamente disponibles en la versión registrada del Game M aker. display_get_width (): Devuelve el ancho del display en píxeles. display_get_height (): Devuelve la altura del display en píxeles display_get_colordepth (): Devuelve el color depth en bits. display_get_frequency (): Devuelve la frecuencia del display. display_set_size (w, h): M odifica el ancho y la altura del display en píxeles Devuelve si el cambio fue exitoso o no (Ten en cuenta que solo algunas combinaciones están permitidas). display_set_colordepth (coldepth): M odifica el color depth. Generalmente los valores permitidos son 16 y 32. Devuelve si el cambio fue exitoso o no. display_set_frequency (frequency): M odifica la frecuencia para el display. Solo algunas frecuencias están permitidas. Devuelve si el cambio fue exitoso o no. display_set_all (w, h, frequency, coldepth): M odifica todo en una sola función. Devuelve si el cambio fue exitoso o no. display_test_all (w, h, frequency, coldepth): Comprueba si la configuración indicada está disponible. Devuelve si el cambio fue exitoso o no. display_reset (): Reinicia la configuración a la cual el programa poseía cuando fue ejecutado. A veces es útil saber información sobre el M ouse en el display, o cambiar su posición. Para esto, existen las siguientes funciones. display_mouse_get_x (): Devuelve la posición x del M ouse en el display. display_mouse_get_y (): Devuelve la posición y del M ouse en el display. display_mouse_set (x, y): M odifica la posición del M ouse. 134
- 135. 53.10.-La Ventana de juego: El juego sucede en una ventana. Esta ventana tiene una cantidad de propiedades, como si posee borde, si es pantalla completa, etc. Normalmente estas propiedades de ponen en Game Settings. Pero las puedes cambiar durante el juego. Las siguientes funciones existen para esto: window_set_visible (visible): Especifica si la ventana es visible o no. window_get_visible (): Devuelve si la ventana es visible o no. window_set_fullscreen (full): Especifica si poner modo full screen o no. window_get_fullscreen (): Devuelve si la ventana está siendo mostrada en pantalla completa. window_set_showborder (show): Especifica si mostrar el borde de la ventana. (En modo pantalla completa el borde nunca se ve) window_get_showborder (): Devuelve si el borde de la ventana se ve. window_set_showicons (show): Especifica si mostrar los íconos del borde (maximizar, minimizar, cerrar) . En modo pantalla completa estos íconos nunca se ven. window_get_showicons (): Devuelve si se están mostrando los íconos del borde de la ventana. window_set_stayontop (stay): Especifica si la ventana siempre debe estar sobre el resto de las ventanas. window_get_stayontop (): Devuelve si la ventana debe quedarse siempre sobre el resto. window_set_sizeable (sizeable): Especifica si se el jugador puede modificar el tamaño de la ventana. window_get_sizeable (): Devuelve si el jugador puede modificar el tamaño de la ventana. window_set_caption (caption): Especifica el caption (nombre de la ventana) del room. window_get_caption (): Devuelve el caption del room. window_set_cursor (curs): Especifica el cursor del M ouse que se mostrará en la ventana. Existen las siguientes constantes. cr_default cr_none cr_arrow cr_cross cr_beam cr_size_nesw cr_size_ns cr_size_nwse cr_size_we cr_uparrow cr_hourglass cr_drag cr_nodrop cr_hsplit cr_vsplit cr_multidrag cr_sqlwait cr_no cr_appstart cr_help cr_handpoint cr_size_all Usa cr_none como valor para que el cursor no se vea. window_get_cursor (): Devuelve el cursor utilizado en la ventana. window_set_region_scale (scale, adaptwindow): Si la ventana es más grande que el room, puedes escalar todo para que entre perfectamente en el room. Poniendo un valor de scale en 0, con un valor de 1 toma el tamaño original. window_get_region_scale (): Devuelve la escala usada, que es modificada con la función anterior. La ventana tiene una posición en la pantalla y un tamaño. Puedes modificar estos aspectos usando las siguientes funciones. Ten en cuenta que esto solo funciona cuando la ventana no está en pantalla completa. window_set_position (x, y): Modifica la posición de la ventana. window_set_size (w, h): M odifica el tamaño de la ventana. window_set_rectangle (x, y, w, h): Una combinación de las 2 funciones anteriores. window_center (): Centra la ventana en la pantalla. window_default (): Vuelve la ventana a su tamaño y posición original. window_get_x (): Devuelve la posición en x de la ventana. window_get_y (): Devuelve la posición en y de la ventana. window_get_width (): Devuelve la altura de la ventana. window_get_height (): Devuelve el ancho de la ventana. Si deseas conocer o modificar la posición del M ouse respecto a la ventana, las siguientes funciones existen: window_mouse_get_x (): Devuelve la posición en x del M ouse en la ventana. window_mouse_get_y (): Devuelve la posición en y del M ouse en la ventana. window_mouse_set (x, y): Modifica la posición del M ouse en la ventana, por la posición dada en (x, y). 53.11.-Vistas (views): Como debes saber, puedes definir hasta 8 views diferentes cuando diseñas los rooms. Una view es definida por el area en el room, y el viewport en la pantalla. Usando views puedes mostrar diferentes partes del room a diferentes lugares en la pantalla. También puedes hacer que la vista siga a un objeto, logrando que este esté siempre visible. 135
- 136. Puedes controlar las views por medio del GM L. Puedes hacer views visibles e invisibles, modificarles el tamaño y el lugar, la posición en el room. Puedes modificar el tamaño del espacio horizontal y vertical alrededor del objeto al que sigue, y puedes indicar a que objeto debe seguir. Las siguientes variables existen para modificar todos los aspectos de las views. view_enabled: Si las views están habilitadas o no. view_current*: La view que está siendo actualmente dibujada. Esto es útil para, por ejemplo, asegurarte de que algo se dibuje solamente en una view. view_visible[0..7]: Si una view en particular es visible en la pantalla. view_xview[0..7]: Posición en x de la view en el room. view_yview[0..7]: Posición en y de la view en el room. view_wview[0..7]: Ancho de la view en el room. view_hview[0..7]: Altura de la view en el room. view_xport[0..7]: Posición en x del viewport. view_yport[0..7]: Posición en y del viewport. view_wport[0..7]: Ancho del viewport. view_hport[0..7]: Altura del viewport. view_angle[0..7]: Ángulo de rotación usado por la view en el room. (Especificado en grados y anti-horario) view_hborder[0..7]: Tamaño horizontal del hborder en píxeles. view_vborder[0..7]: Tamaño vertical del hborder en píxeles. view_hspeed[0..7]: Velocidad horizontal de la view. view_vs peed[0..7]: Velocidad vertical de la view. view_object[0..7]: El objeto que debe permanecer siempre visible en la view, en otras palabras, el objeto al que la view sigue. En el juego puedes necesitar conocer la posición del cursor del M ouse respecto a las views, para lograr esto, existen las siguientes funciones. window_view_mouse_get_x (id): Devuelve la posición en x del cursor del M ouse, respecto a la view dada. window_view_mouse_get_y (id): Devuelve la posición en y del cursor del M ouse, respecto a la view dada. window_view_mouse_set (id, x, y): M odifica la posición del cursor del M ouse respecto a la view dada. window_views_mouse_get_x (): Devuelve la posición del M ouse. Lo mismo que la variable mouse_x. window_views_mouse_get_y (): Devuelve la posición del M ouse. Lo mismo que la variable mouse_y. window_views_mouse_set (x, y): Modifica la posición del M ouse, respecto a la primer view visible. 53.12.- Transiciones: Como debes saber cuando te mueves de un room a otro, puedes seleccionar un tipo de transición. M odificando la variable transition_kind usted puede asignar una transición predefinida con el Game M aker. Un valor de 0 indica sin transición. Para asignar la transición deseada, puede usar los siguientes valores. transition_kind Indica la transición que poseerá el siguiente frame. Use los siguientes valores: 0 = Sin efecto 1 = Crear por izquierda. 2 = Crear por derecha. 3 = Crear por arriba. 4 = Crear por debajo. 5 = Crear por el centro. 6 = M over por la izquierda. 7 = M over por la derecha. 8 = M over por arriba. 9 = M over por debajo. 10 = Entrelazar por izquierda. 11 = Entrelazar por derecha. 12 = Entrelazar por arriba. 13 = Entrelazar por debajo. Tenga en cuenta que es fácil hacer tus propias transiciones usando las diversas funciones de dibujo. Por ejemplo, para hacer un efecto de oscurecer a negro, puedes dibujar un rectángulo incrementando su alpha. 53.13.-Redi bujando o refrescando la pantalla: Normalmente al final de cada step, el room es redibujado. Pero en raras ocasiones, necesitas dibujar el room en otros momentos. Por ejemplo, si quieres mostrar un mensaje, y esperar que el jugador presione una tecla para continuar, deberás redibujar la pantalla para que el texto se pueda leer. screen_redraw (): Redibuja el room llamando a todos los eventos Draw. screen_refresh (): Redibuja la pantalla usando la imagen actual del room. (No llamando a los eventos Draw). Para entender como funciona la segunda función, deberás saber como funciona el dibujado internamente. Internamente hay una imagen en donde se dibuja todo. Esta imagen no es visible en la pantalla. Solo al final de cada step, la imagen de la pantalla es reemplazada por esta imagen interna. (Esto es llamado doble buffering). 136
- 137. Si dibujas algo en otro evento que no sea el Draw, esto se dibujará en la imagen interna, pero no será visible en la pantalla. Por ejemplo, si deseas dibujar un texto en pantalla, y esperar que el jugador presione una tecla para continuar, debes actualizar la pantalla, o el texto no será visible. De esta forma: draw_text (screen_width/2,100,"Presione una tecla para continuar”); screen_refresh (); keyboard_wait (); Tenga en cuenta que cuando dibuja en otro evento que no sea el Draw Evento, lo que usted hace es dibujar en la imagen, no en la view. Por eso las coordenadas serían las mismas como si no hubiera vistas (views). Cuando usted dibuja en el room, puede ser útil hacer que no dibuje automáticamente. Por ejemplo, puedes querer que el room se dibuje cada 5 steps. Puedes usar las siguientes funciones para esto: set_automatic_draw (value): Indica si dibujar automáticamente el room. Finalmente hay una función con la cual puedes poner si sincronizar el dibujado de la pantalla con la frecuencia del monitor. set_synchronization (value): Indica si sincronizar el dibujado de la pantalla con la frecuencia del monitor. También puedes esperar por la siguiente sincronización, usando la siguiente función: screen_wait_vsync (): Espera hasta la siguiente sincronización con el monitor. 54.- Sonido y Música Avanzados: Los sonidos juegan un papel crucial en los juegos de computadora. Los sonidos son agregados a tu juego en forma de recursos. Asegúrate de que los nombres que le asignes sean nombres válidos (las mismas reglas que se aplican a nombres de variables). Como quizás ya has visto hay diferentes tipos de sonidos, como normal sounds, background music, 3D sounds y sonidos que pueden ser tocados por medio del media player (reproductor media). Los normal sounds son usados para efectos. Generalmente se usa archivos wave para esto. Estos sonidos se pueden tocar muchos al mismo tiempo (incluso múltiples instancias con el mismo sonido). Puedes aplicar todo tipos de efectos en ellos. Los background music generalmente consisten de archivos midi, pero a veces archivos wave son usados. La única diferencia con los normal sounds es que se puede tocar solo un background music a la vez. No obstante, si empiezas a tocar uno, lo puedes detener. Los 3D sounds permiten usar efectos 3D, que son descritos más adelante. Estos sonidos son mono sounds (wave o midi). Finalmente, si quieres usar otro tipo de sonido, mp3 en particular, estos no pueden ser usados a través de DirectX. Como resultado el media player (reproductor media) debe ser usado para esto. Pero esto está mucho más limitado, solo un sonido puede tocarse a la ves, no se les puede aplicar ningún efecto (ni siquiera modificarle el volumen). También hay delay tocando estos sonidos. Hasta es posible que algunas computadoras no lo soporten. Información sobre sonidos y música puede ser encontrada en las siguientes páginas: 54.1.- Funci ones básicas de l os soni dos: Hay cinco funciones básicas relacionadas con los sonidos, dos para iniciar un sonido, una para comprobar si un sonido está sonando, y dos para detener sonidos. La mayoría toma el principio del sonido como argumento. El nombre del sonido representa el principio. Pero tú puedes conservar también el principio en una variable, usando lo siguiente: sound_play (index): El sonido indicado se ejecuta una sola vez. Si el sonido es el sonido de fondo, el hasta ahora sonido de fondo es detenido. sound_loop (index): El sonido se ejecuta continuamente. Si el sonido es el sonido de fondo, el hasta ahora sonido de fondo es detenido. sound_stop (index): Se detiene el sonido indicado. Si hay muchos sonidos sonando al mismo tiempo que el principal, se detienen todos. sound_stop_all (): Se detienen todos los sonidos. sound_isplaying (index): Regresa mientras una copia del sonido indicado está sonando. Nota que esta función de regreso es verdadera cuando el sonido actualmente suena a través de los altavoces. Después puedes llamar a la función para iniciar un sonido si este no está muy cerca de ser emitido p or los altavoces, de modo que la función pudiera llegar a ser falsa por un momento. Cuando el sonido se detiene puedes escucharlo por un momento (por el eco, por ejemplo) y la función regresará siendo verdadera. Es posible usar efectos de sonido superiores. En particular, puedes cambiar el volumen y la salida, es decir, si el sonido viene del altavoz izquierdo o del derecho. En todos estos casos, el volumen solo puede reducirse. Estas 137
- 138. funciones no trabajan para los archivos que se ejecutan mediante el programa “Windows M edia Player”, como archivos mp3. sound_volume (index, value): Cambia el volumen del sonido indicado. (0 = bajo 1= alto) sound_global_volume (value): Cambia el volumen global para todos los sonidos (0 = bajo, 1= alto) sound_fade (index, value, time): Cambia el volumen para el sonido indicado en relación al nuevo valor (0= bajo, 1= alto) durante el tiempo indicado (en microsegundos). Esto puede ser usado para apagar o encender la música. sound_pan (index, value): Cambia la salida del sonido p or los altavoces (-1 izquierdo, 0= central, 1= derecha). sound_background_tempo (factor): Cambia el tiempo del sonido de fondo (si este es un archivo M idi. “factor” indica el cambio que se va a generar en el tiempo. Por lo que un valor de 1 corresponde a un tiempo normal. Valores mayores se corresponden con un tiempo prolongado, valores más pequeños con un tiempo más lento. Deben situarse entre 0.01 y 100. Además de M idis y de archivos wave (y mp3) hay actualmente un cuarto tipo de archivo qu e puede ejecutarse: como archivos de música directamente. Tienen la extensión .sgt. Para encontrar estos archivos, el sistema de sonidos debe saber donde están localizados. Para este fin, puedes usar las siguientes funciones para establecer el buscador de archivos de esta clase. Nota que puedes añadir archivos por ti mismo. Game M aker no lo hace automáticamente, pero incluye archivos adicionales. sound_set_search_directory (dir): Pone el directorio en los archivos de música que se pueden encontrar. El directorio no debe ser incluido al final. 54.2.- Efectos de soni do (Effects of sounds): Esta funcionalidad solo esta disponible en la versión registrada de Game M aker. Los efectos de sonidos pueden ser usados para cambiar los sonidos del camino y música de fondo. Comprenda que los efectos de sonido solo son aplicados en archivos wave y midi, no para los archivos mp3. Esta sección describe las funciones que existen para usar y cambiar los efectos de sonidos. Comprenda que para usar estas funciones necesitas entender bien como funcionan sonidos y sintetizadores. Aquí no se da ninguna explicación de los diferentes parámetros. Busque en la Web o en libros para informaciones adicionales. Para aplicar un efecto de sonido a un sonido particular tu puedes indicar este cuando se define el recurso del sonido o usarlo de la siguiente función. sound_effect_set (snd, effect): Cambia o combinación un conjunto de efectos de sonidos para el sonido, effect puede ser cualquiera de estos valores: se_none se_chorus se_echo se_flanger se_gargle se_reverb se_compressor se_equalizer Puedes hacer una combinación de efectos añadiendo los valores. Por ejemplo puedes usar: sound_effect_set(snd,se_echo+se_reverb); Para obtener una combinación de efectos de eco y reverberación. Todos los efectos tienen algunas características por defecto. Puedes cambiarlas cuando haz aplicado un efecto en un sonido. El orden aquí es crucial. Primero aplica el efecto al sonido y luego cambia los parámetros para él. Una vez que vuelves a aplicar efectos al sonido, las características se han ido y tu tienes que establecerlas de nuevo. Nótese que todos los parámetros deben estar en un rango particular, el cual es indicado a continuación. Las siguientes funciones existen para cambiar efectos de parámetros: sound_effect_chorus (snd, wetdry, depth, feedback, frequency, wave, delay, phase): Cambia los parámetros para el efecto de coro del sonido indicado. Los siguientes parámetros pueden ser cambiados: wetdry: Radio de señal mojada (procesada) a señal seca (no procesada), (rango: 0 a 100, por defecto 50) depth Porcentaje por el cual el tiempo de tardanza es modulado por el oscilador de frecuencia baja, en centésimos de un punto de porcentaje, (rango: 0 a 100, por defecto 25). feedback: Porcentaje de señal de salida para retroalimentar en la entrada del efecto, (rango: -99 a 99, por defecto 0). frequency: Frecuencia del LFO, (rango: 0 a 10, por defecto 0). wave: Forma de onda del LFO. (0 = triangulo, 1 = onda, por defecto 1). delay: Número de milisegundos que la salida tarda antes de que suena, (rango: 0 a 20, por defecto 0). phase: Fase diferencial entre izquierda del LFO y su derecha, (rango: 0 a 4, por defecto 2). 138
- 139. sound_effect_echo (snd, wetdry, feedback, leftdelay, rightdelay, pandelay): Cambia los parámetros para el efecto de eco del sonido indicado. Los siguientes parámetros pueden ser cambiados: wetdry: Radio de señal mojada (procesada) a señal seca (no procesada), (rango: 0 a 100, por defecto 50). feedback: Porcentaje retroalimentación en la salida (rango: 0 a 100, por defecto es 0). leftdelay: Tiempo de tardanza para el canal izquierdo, en milisegundos, (rango: 1 a 2000, por defecto es 333). rightdelay: Tiempo de tardanza para el canal derecho, en milisegundos, (rango: 1 a 2000, por defecto es 333). pandelay: Si hay que cambiar la tardanza izquierda y la derecha con cada eco sucesivo. (0 = no cambia, 1 = cambia, por defecto es 0). sound_effect_flanger (snd, wetdry, depth, feedback, frequency, wave, delay, phase): Cambia los parámetros para el efecto de flanger del sonido indicado. Los siguientes parámetros pueden ser cambiados: wetdry: Radio de señal mojada (procesada) a señal seca (no procesada), (rango: 0 a 100, por defecto 50) depth: Porcentaje por el cual el tiempo de tardanza es modulado por el oscilador de frecuencia baja, en centésimos de un punto de porcentaje, (rango: 0 a 100, por defecto 25) feedback: Porcentaje de señal de salida para retroalimentar en la entrada del efecto, (rango: -99 a 99, por defecto 0) frequency Frecuencia del LFO, (rango: 0 a 10, por defecto 0) wave: Forma de onda del LFO, (0 = triangulo, 1 = onda, por defecto 1) delay: Número de milisegundos que la salida tarda antes de que suena, (rango: 0 a 20, por defecto 0) phase: Fase diferencial entre izquierda del LFO y su derecha, (rango: 0 a 4, por defecto 2) sound_effect_gargle (snd, rate, wave): Cambia los parámetros para el efecto de gárgaras del sonido indicado. Los siguientes parámetros pueden ser cambiados: rate: Tarifa de modulación, medida en Hertz, (rango: 1 a 1000, por defecto es 1) wave: Forma de la onda de modulación. (0 = triangulo, 1 = cuadrado, por defecto 0) sound_effect_reverb (snd, gain, mix, time, ratio): Cambia los parámetros para el efecto de reverberación del sonido indicado. Los siguientes parámetros pueden ser cambiados: gain: Beneficio de entrada de señal, en decibeles (dB), (rango: -96 a 0, por defecto es 0) mix: M ezcla de Reverberación, en dB, (rango: -96 a 0, por defecto es 0) time: Tiempo de reverberación, en milisegundos, (rango: 0.001 a 3000, por defecto es 1000) ratio: Radio de frecuencia, (rango: 0.001 a 0.999, por defecto es 0.001) sound_effect_compressor (snd, gain, attack, release, threshold, ratio, delay): Cambia los parámetros para el efecto de compresión del sonido indicado. Los siguientes parámetros pueden ser cambiados: gain: Beneficio de salida de señal después de compresión, (rango: -60 a 60, por defecto es 0) attack: Tiempo antes de que la compresión llegue a su valor completo, (rango: 0.01 a 500, por defecto es 0.01) release: Velocidad a la cual la compresión es detenida después de que la entrada es bajada debajo del umbral, (rango: 50 a 3000, por defecto es 50) threshold: Punto al cual la compresión empieza, se mide en decibeles, (rango: -60 a 0, por defecto es -10) ratio: Radio de compresión, (rango: 1 a 100, por defecto es 10) delay: Tiempo después de que Umbral es alcanzado antes de que la fase de ataque ha comenzado, en milisegundos, (rango: 0 a 4, por defecto es 0) sound_effect_equalizer (snd, center, bandwidth, gain): Cambia los parámetros para el efecto de ecualizador del sonido indicado. Los siguientes parámetros pueden ser cambiados: center: Centrar la frecuencia, en hertz, (rango: 80 a 16000) bandwidth: Amplitud de banda, en semitonos,(rango: 1 a 36) gain: Beneficio, (rango: -15 a 15) 139
- 140. 54.3.- Soni do en 3D: Esta function solo se puede usar con la versión registrada. Los sonidos 3D se refieren a los sonidos que tienen una posición y una velocidad con respecto al que escucha. La idea es que el sonido tenga una posición en el espacio. En todas las funciones el que escucha asume que se encuentra en la posición (0,0,0). El sistema calcula como el que escucha va a escuchar el sonido y como lo va a adaptar acorde con ello. El efecto es especialmente bueno cu ando hay un buen sistema de parlantes, pero también sirve aunque no se tan bueno. Además de la posición, también hay una velocidad para el sonido. Esto nos lleva a un buen efecto doppler. Finalmente el sonido puede tener una orientación, y otra vez, ser adaptado acorde a ello. Game M aker soporta los sonidos 3D con la funciones. Solo funciona con sonidos indicados para ser 3D. (Esta da una desventaja la cual es que los sonidos serán mono y no estereo) sound_3d_set_sound_position (snd, x, y, z): Pone la posición e indica con respecto al que escucha una posición en el espacio. Los valores en „x‟ incrementan de izquierda a derecha, en „y‟ de abajo a arriba, y en „z‟ de cercano a lejano. Los valores son medidos en metros. El volumen con el que el sonido es escuchado depende de las medidas. sound_3d_set_sound_velocity (snd, x, y, z): Pone la velocidad del sonido indicado, en un vector en el espacio. Por favor vean que la velocidad no altera la posición. La velocidad es usada para calcular el efecto doppler. Así que si quieren mover el sonido deben cambiar la posición de este. sound_3d_set_sound_distance (snd, mindist, maxdist): Pone la mínima distancia a la que el sonido ya no va a incrementar y la máxima distancia en la que el sonido va a incrementar. Lo predeterminado es que la mínima sea 1 metro y la máxima 1 billón de metros. sound_3d_set_sound_cone (snd, x, y, z, anglein, angleout, voloutside): Con esto puedes hacer que el sonido cone cambia y hacer un sonido direccional x, y, z especificando la dirección del sonido cone, anglein especifica el ángulo de adentro. Si el que escucha esta dentro de este ángulo, este escucha el sonido a su volumen normal, angleout especifica el ángulo de afuera. Cuando el que escucha esta afuera este volumen es indicado con voloutside. Para ser precisos el voloutside es un número negativo que indica el número de cientos de decibles que deben ser restados del volumen de adentro. Entre el ángulo de adentro y el de afuera el volumen baja gradualmente. 54.4.- CD de Música: Estas funciones solo son para la versión registrada. Hay algunas funciones en el game maker para tocar música de un cd, aquí están: cd_init() Esta debe ponerse antes de cualquier otra function. También se debe poner cuando se cambia de cd o de tiempo en tiempo. cd_present (): Informa si hay un cd presente en el compartimiento cd_number (): Informa el número de canciones presentes. cd_playing (): Informa si el cd se esta reproduciendo. cd_paused (): Informa si el cd esta en pausa o en stop. cd_track (): Informa el número de track que se escucha. cd_length (): Informa cuantos milisegundos tiene el cd. cd_track_length(n): Informa cuantos milisegundos tiene el track. cd_position (): Informa la posición en milisegundos. cd_track_position (): Informa la posición actual del track en milisegundos. cd_play (first, last): Informa que el CD suene todos los tracks. cd_stop (): Para el cd. cd_pause (): Pausa el cd. cd_resume (): Resume el cd. cd_set_position (pos): Pone la posición del cd en milisegundos. cd_set_track_position (pos): Pone la posición del track en milisegundos. cd_open_door (): Abre la puerta para meter el cd. cd_close_door (): Cierra la puerta del cd. 55.- Splash screens, puntuaciones y otros pop – ups (ventanas emergentes o mensajes): En esta sección describiremos un número de funciones que pueden ser usadas para mostrar splash screens con videos, imágenes, etc., también como mostrar mensajes, y como hacerles preguntas al jugador. Por último como mostrar una tabla de puntajes. Información sobre esto puede ser encontrada en las siguientes páginas: 140
- 141. 55.1.- Spl ash Screens: Algunos juegos presentan ventanas emergentes. Estas pantallas muestran un video, una imagen o algún texto. A menudo son usadas al principio del juego, como una introducción, o para el principio de un nivel o para el final del juego (Por ejemplo para los créditos). En Game M aker tanto las ventanas emergentes con texto, imagines o video pueden ser mostradas en cualquier momento del juego. El juego es pausado temporalmente mientras esta ventana es mostrada. Estas son las funciones para usar: show_text (fname, full, backcol, delay): M uestran una ventana con texto, fname es el nombre del archivo de texto (.txt o .rtf). Debes poner este archive dentro del mismo directorio en que está el juego. Además al crear la versión ejecutable (stand-alone) de tu juego, no se debe olvidar añadir este archivo junto con el juego; full indica si se mostrará en pantalla completa o no, backcol es el color de fondo, y delay es un retraso en segundos antes de regresar al juego. El jugador puede dar un clic con el ratón sobre la pantalla para regresar al juego. show_image (fname, full, delay): M uestra una imagen en una ventana emergente, fname es el nombre del archivo de imagen (solo archivos .bmp .jpg y .wmf) hay que agregar ese archivo en la carpeta donde está el juego, full indica si se va a mostrar en pantalla completa o no, delay es el retraso en segundos antes de regresar al juego. show_video (fname, full, loop): Muestra un video en una ventana, fname es el nombre del archivo de video (.avi, o .mpeg) debes poner este archivo en la misma carpeta donde está el juego, full indica si se va a mostrar a pantalla completa, loop si se debe repetir al finalizar su reproducción. show_info (): Muestra la pantalla de información del juego load_info (fname) carga la información del juego desde un archivo indicado en fname. Este debe de ser un archivo .rtf, esto hace posible mostrar diferentes archivos de ayuda en diferentes momentos. Puedes usar el recurso “data file” para poner estos archivos dentro del juego. 55.2.- Pop-up (ventanas de mensajes) y preguntas: También hay varias funciones para mostrar pequeñas ventanas con mensajes, preguntas, un menú con opciones o un diálogo en el cual el jugador puede introducir un número, una cadena de texto, un color o un nombre de algún archivo: show_message (str): M uestra un cuadro de diálogo como un mensaje show_message_ext (str, but1, but2, but3): M uestra un cuadro de diálogo con el valor “str” como un mensaje, además de 3 botones, but 1, but 2 y but 3 contienen el texto de cada botón. Si no escribes nada significará que el botón no se mostrará. En el texto puedes utilizar el símbolo & para indicar que el siguiente carácter debe ser usado como un acceso directo para este botón. Esta función regresa un valor del botón presionado (0 si el usuario presiona la tecla esc) show_question (str): M uestra una pregunta; devuelve “true” cuando el usuario presiona yes o falso si no. get_integer (str, def): Pide al jugador en un cuadro de diálogo por un número, str es el mensaje, def es el número por defecto que se mostrará. message_background (back): Establece una imagen de fondo para el cuadro de diálogo par alas funciones anteriores, back debe ser uno de los bakcgrounds definidos en el juego. message_alpha (alpha): Establece el valor alpha para la caja de diálogo sobre algunas funciones. El alpha debe estar entre 0 (completamente translucido) y 1 (no translucido) (solo para Windows 2000 o superior). message_button (spr): Establece el sprite usado por los botones del cuadro de dialogo, spr debe ser un sprite que contenga tres imágenes, la primera para el botón cuando no está presionado, la segunda cuando el ratón está sobre el botón pero no está presionado y la tercera es para cuando el botón está presionado. message_text_font (name, size, color, style): Establece la fuente usada en los botones del cuadro de diálogo (0=normal, 1=bold, 2=italic, and 3=bold-italic). message_button_font (name, size, color, style): Establece la fuente para los botones del cuadro de diálogo (0=normal, 1=bold, 2=italic, and 3=bold-italic). message_input_font (name, size, color, style): Establece la fuente para el cuadro de texto (si el usuario necesita introducir algún valor) del cuadro de diálogo. message_mouse_color (col): Establece el color de la fuente del cuadro y texto (si el usuario necesita introducir algún valor) del cuadro de diálogo cuando el ratón está sobre este. message_input_color (col): Establece el color de fondo del cuadro y texto (si el usuario necesita introducir algún valor) del cuadro de diálogo. message_caption (show, str): Establece el título del cuadro de diálogo, show indica si el borde debe ser mostrado (1) o no (0) y str indica el título cuando el borde es mostrado. message_position (x, y): Establece la posición del cuadro de diálogo. message_size (w, h): Fija el tamaño del cuadro de diálogo. Si indicas 0 para el width el ancho de la imagen es utilizado. Si escoges 0 para el height el alto es calculado en base al número de líneas del mensaje. show_menu (str, def): M uestra un menú emergente, str indica el texto del menú esto consiste de los diferentes elementos del menú con una barra vertical entre ellos. Por ejemplo: str = “menu0/menu1/meny2”. Cuando la primera opción es seleccionado, el valor de 0 es regresado, etc., cuando el jugador no selecciona ningún elemento, el valor por defecto def es regresado. show_menu_pos (x, y, str, def): M uestra un menú desplegable como en la función anterior pero en la posición x, y de la pantalla. 141
- 142. get_color (defcol): Pide al jugador por un color, defcol es el color por defecto. Si el usuario presiona cancel el valor - 1 es retornado. get_open_filename (filter, fname): Solicita al jugador por un nombre de archivo para abrir con un filtro dado. El filtro tiene la forma “name1/másk1/name2/másk21… una máscara contiene las diferentes opciones con un punto y coma entre ellos, .*significa cualquier cadena de texto. Si el usuario presiona cancel una cadena de texto vacía es retornada. get_save_filename (filter, fname): Pide al usuario un nombre de archive para guardar con el filtro dado. Si el usuario presiona cancel una cadena de texto vacía es retornada. get_directory (dname): Pregunta por un directorio, dname es el nombre por defecto. Si el usuario presiona cancel una cadena de texto vacía es retornada. get_directory_alt (capt, root): Una manera diferente de pedir un directorio, caps es el título a ser mostrado, root es la ruta del directorio a ser mostrado. Usa una cadena vacía y se mostrará el árbol complete. Si el usuario presion a cancelar se regresa una cadena vacía. show_error (str, abort): Despliega un mensaje de error estándar (y/o lo escribe en un archivo log), abort indica si el juego debe ser abortado. 55.3.- Lista de Record o Puntuaciones: Una ventana especial es la de highscore que es mantenida por cada juego. Estas son las Funciones a usar: highscore_show (numb): M uestra la tabla de highscores, numb es el nuevo record. Si la puntuación es buena para ser añadida a la lista, el jugador podrá ingresar su nombre. Usa -1 para desplegar la lista actual highscore_set_background (back): Establece el fondo de imagen a usar, back debe ser el principio de uno de los recursos del fondo. highscore_set_border (show): Establece si el highscore debe tener un borde o no. highscore_set_font (name, size, style): Pone la fuente usada por el texto en la tabla puedes especificar el nombre, el tamaño y el estilo. (0=normal, 1= bold, 2=italic, 3=bold-italic). highscore_set_colors (back, new, other): Establece los colores usados por el fondo, la nueva entrada en la tabla y otras entradas. highscore_set_strings (caption, nobody, escape): Cambia los strings no válidos cuando se está mostrando la tabla de puntuación, caption es la captura de la forma nobody es el string usado cuando no hay nadie en el ranking escape es el string del botón indicado para presionar la tecla de escape. Puedes usar esto cuando tu juego deba usar un diferente lenguaje. highscore_show_ext (numb, back, border, col1, col2, name, size): M uestra la tabla de puntuaciones con un número de opciones, numb es la nueva puntuación. Si la puntuación es lo suficientemente buena, el jugador puede poner su nombre. Para eso debe usar -1., back es el fondo de imagen a usar, pudiendo o no poner borde, coll es el color para la nueva entrada, col2 es el color para otras entradas, name es el nombre de la fuente a usar, y size es el tamaño de la fuente. highscore_clear (): Borra todas las puntuaciones. highscore_add (str, numb): Añade un jugador de nombre str con la puntuación numb a la lista. highscore_add_current (): Añade la puntuación actual a la lista de highscores. Se le preguntará al jugador por un nombre. highscore_value (place): Devuelve la puntuación de la persona en el lugar indicado(1-10)esto puede ser usado para dibujar tu propia lista de puntuaciones más altas. highscore_name (place): La puntuación de la persona en el lugar indicado (1-10) esto puede ser usado para dibujar tu propia lista de puntuaciones más altas. draw_highscore (x1, y1, x2, y2): M uestra la tabla de puntuaciones más altas en la ventan y con la fuente indicada. 56.- Funciones para obtener información de los recursos: En Game M aker puedes definir varios tipos de recursos, como sprites, sonidos, fuentes, objetos, etc. En este capítulo encontrarás una numerosa cantidad de funciones que te dan información sobre los recursos. En el capítulo siguiente encontrarás información de como modificar y crear recursos mientras el juego. Información sobre recursos puede ser encontrada en las siguientes páginas: 56.1.- Sprites (Imágenes): Las funciones siguientes le darán la información sobre un sprite: sprite_exists (ind): Devuelve si existe un sprite con el índice dado. sprite_get_name (ind): Devuelve el nombre del sprite con el índice dado. sprite_get_number (ind): Devuelve el número de los subimages del sprite con el índice dado. sprite_get_width (ind): Devuelve la anchura del sprite con el índice dado. sprite_get_height (ind): Devuelve la altura del sprite con el índice dado. sprite_get_transparent (ind): Devuelve si el sprite con el índice dado es transparente. sprite_get_smooth (ind): Devuelve si el sprite con el índice dado ha tocado los bordes. 142
- 143. sprite_get_preload (ind): Devuelve si el sprite con el índice dado debe ser cargado. sprite_get_xoffset (ind): Devuelve el x-offset del sprite que correspondiente al índice dado. sprite_get_yoffset (ind): Devuelve el y-offset del sprite que correspondiente al índice dado. sprite_get_bbox_left (ind): Devuelve el lado izquierdo de la caja de limitación del sprite con el índice dado. sprite_get_bbox_right (ind): Devuelve el derecho de la caja de limitación del sprite con el índice dado. sprite_get_bbox_top (ind): Devuelve el lado superior de la caja de limitación del sprite con el índice dado. sprite_get_bbox_bottom (ind): Devuelve el lado inferior de la caja de limitación del sprite con el índice dado. sprite_get_bbox_mode (ind): Devuelve el modo de la caja de colisión (0=automática, 1=imagen completa, 2=manual) del sprite correspondiente al índice dado. sprite_get_precise (ind): Devuelve si el sprite con el índice dado utiliza la comprobación exacta de la colisión. 56.2.- Sounds (Soni dos): Las funciones siguientes le darán la información sobre el uso de los sonidos en el Game M aker: sound_exists (ind): Comprueba si existe un sonido con el índice dado sound_get_name (ind) Devuelve el nombre del sonido con el índice dado. sound_get_kind (ind): Vuelve la clase del sonido con el índice dado (0=normal, 1= background, 2=3d, 3=mmplayer). sound_get_preload (ind): Vuelve si el sonido con el índice dado tiene carga fijada. Los sonidos utilizan muchos recursos y la mayoría de los sistemas pueden almacenar y reproducir solamente un número limitado de sonidos. Si usted hace un juego pesado y quieres tener más control sobre cuales sonidos se cargan en memoria audio en que momento. Usted puede utilizar el botón de precarga para los sonidos para asegurarse de que los sonidos están cargados solamente cuando sean utilizados. Esto tiene sin embargo el problema que puede que se relantize en el momento que carga el sonido. Los sonidos no se descargan automáticamente cuando no los necesita más. Para obtener más control sobre esto puede aplicar las opciones siguientes. sound_discard (index): Libera la memoria audio usada para el sonido indicado. sound_restore (index): Restaura el sonido indicado en la memoria de audio para oírlo de inmediato. 56.3.- Backgrounds (Fondos): Las funciones siguientes le darán la información sobre un fondo: background_exists (ind): Comprueba si existe un fondo con el nombre dado. background_get_name (ind): Devuelve el nombre del fondo con el índice dado. background_get_width (ind): Devuelve la anchura del fondo con el índice dado. background_get_height (ind): Devuelve la altura del fondo con el índice dado. background_get_transparent (ind): Devuelve si el fondo con el índice dado es transparente. background_get_smooth (ind): Devuelve si el fondo con el índice dado ha alisado los bordes (smoothed edges). background_get_preload (ind): Devuelve si el fondo con el índice dado debe ser precargado. 56.4.- Fonts (Fuentes o Ti pos de Letras): Las funciones siguientes le darán la información sobre las Fuentes en el Game M aker: font_exists (ind): Comprueba si existe una fuente con el índice dado. font_get_name (ind): Devuelve el nombre de la fuente con el índice dado. font_get_fontname (ind): Devuelve el “fontname” de la fuente con el índice dado. font_get_bold (ind): Comprueba si la fuente con el índice dado esta en negrita. font_get_italic (ind): Comprueba si la fuente con el índice dado esta en cursiva. font_get_first (ind): Vuelve el índice del primer carácter en la fuente con el índice dado. font_get_last (ind): Vuelve el índice del carácter pasado en la fuente con el índice dado. 56.5.- Paths (Cami nos o trayectorias): Las funciones siguientes le darán la información sobre un camino o trayectoria (path): path_exists (ind): Comprueba si existe una trayectoria con el índice dado. path_get_name (ind): Devuelve el nombre de la trayectoria con el índice dado. path_get_length (ind): Devuelve la longitud de la trayectoria con el índice dado. path_get_kind (ind): Devuelve la clase de conexiones de la trayectoria con el índice dado (0=straight(recto), 1= smooth(curvado)). path_get_closed (ind): Devuelve si la trayectoria es cerrada o no. path_get_precision (ind): Devuelve la precisión usada para crear las trayectorias alisadas. path_get_number (ind): Devuelve a definir los puntos para la trayectoria. 143
- 144. path_get_point_x (ind, n): Devuelve la coordenada X del Nº punto que define para el path. El 0 es el primer punto del path. path_get_point_y (ind, n): Devuelve la coordenada Y del Nº punto que define para el path. El 0 es el primer punto del path. path_get_point_speed (ind, n): Devuelve el factor de velocidad al punto Nº del path. El 0 es el primer punto del path. path_get_x (ind, pos): Devuelve la coordenada x en la posición para el path. path_get_y (ind, pos): Devuelve la coordenada y en la posición para el path. path_get_speed (ind, pos): Devuelve el factor de la velocidad en la posición. La posición de la trayectoria debe estar entre 0 y 1. 56.6.- Scripts: Las funciones siguientes le darán la información sobre un script: script_exists (ind): Comprueba si existe una escritura con el índice dado. script_get_name (ind): Devuelve el nombre de la escritura con el índice dado. script_get_text (ind): Devuelve la secuencia de texto de la escritura con el índice dado. 56.7.- Ti me Lines (Líneas de Tiempo): Las funciones siguientes le darán la información sobre un timeline: timeline_exists (ind): Comprueba si existe una línea del tiempo con el índice dado. timeline_get_name (ind). Devuelve el nombre de la línea del tiempo con el índice dado. 56.8.- Objects (Objetos): Las funciones siguientes le darán la información sobre los objetos: object_exists (ind): Comprueba si existe un objeto con el índice dado. object_get_name (ind): Devuelve el nombre del objeto con el índice dado. object_get_sprite (ind): Devuelve el índice del sprite por defecto del objeto con el índice dado. object_get_solid (ind): Comprueba si el objeto con el índice dado es sólido por defecto. object_get_visible (ind): Comprueba si el objeto con el índice dado es visible por defecto. object_get_depth (ind): Cambia la profundidad del objeto con el índice dado. object_get_persistent (ind): Devuelve la profundidad del objeto con el índice dado. object_get_másk (ind): Devuelve el índice de la máscara del objeto con el índice dado (-1 si es que no tiene ninguna máscara especial). object_get_parent (ind): Devuelve el índice del objeto del padre de “ind” del objeto (-1 si no tiene ningún padre). object_is_ancestor (ind1, ind2): Comprueba si el objeto ind2 es un antepasado del objeto ind1. 56.9.- Rooms (Cuartos): Las funciones siguientes le darán la información sobre un cuarto (o room): room_exists (ind): Comprueba si existe un cuarto con el índice dado. room_get_name (ind): Devuelve el nombre del cuarto con el índice dado. Observe que, los rooms cambian durante el transcurso del juego, hay otras formas para recibir información sobre el contenido de la room. 57.- Funciones para modificar los recursos: Estas funciones están solamente disponibles en la versión registrada del Game M aker. Es posible crear nuevos recursos durante el juego. También puedes modificar los recursos ya existentes. Ten cuidado, M odificar recursos puede fácilmente traer serios errores en tu juego. Debes seguir las siguientes reglas para evitar errores, cuando modifiques recursos: No cambies recursos que están siendo usados. Esto traerá errores. Por ejemplo no cambies un sprites que está siendo usado por una instancia. Cuando guardes el juego mientras se está jugando, recursos agregados y modificados NO serán guardados con el juego. Entonces, si cargas el juego guardado, estos recursos no estarán más. Generalmente, cuando modifiques recursos tendrás que usar tu propio método de guardar/cargar el juego. Cuando reinicies el juego mientras se está jugando, los recursos modificados NO volverán a su forma original. Generalmente, cuando modifiques recursos no podrás reiniciar el room/juego con las funciones para eso. 144
- 145. M anipular recursos puede ser lento. Por ejemplo, cambiar sprites o backgrounds es relativamente lento. No lo uses mientras el juego está corriendo. Lo mejor sería usarlo cuando pasas de un room a otro. Crear recursos durante el juego (en particular backgrounds) consumen mucha memoria. Ten mucho cuidado con esto. Por ejemplo, si tienes un sprite animado de 32 subimágenes, con un tamaño de 128x128 y decides crearle 36 copias rotadas, tendrás un 36x32x128x4 = 36 M B de consumo de memoria. Asegúrate de que elimines los recursos que no necesites más. En caso contrario el sistema puede no tener más memoria disponible. Recuerda que no es recomendable cambiar recursos durante el juego, es mejor hacerlo cuando el juego se inicia, o cuando un room se inicia. Si demora mucho, podrías hasta hacer tu propia barra de carga. Información sobre modificar recursos puede ser encontrado en las siguientes páginas: 57.1.- Sprites (Imágenes): Las siguientes funciones existen para modificar las propiedades del sprite. sprite_set_offset (ind, xoff, yoff): Fija el offset del sprite con el index dado. sprite_set_bbox_mode (ind, mode): Fija el modo de bounding box del sprite (0=automatic, 1=full image, 2=manual) sprite_set_bbox (ind, left, top, right, bottom): Fija la bounding box del sprite dado. Solo funciona si la bounding box mode es manual. sprite_set_precise (ind, mode): Especifica si el sprite debe usar comprobación precisa de colisiones. 57.2.- Sounds (Soni dos): Las siguientes funciones pueden ser usadas para crear y remover sonidos. sound_add (fname, kind, preload): Agrega un sonido al juego, fname es el nombre del sonido, kind indica el tipo de sonido (0=normal, 1=background, 2=3d, 3=mmplayer) preload indica si el sonido debe ser cargado en la memoria de audio inmediatamente. Esta función devuelve el index del sonido que podrá ser usado en diferentes funciones de sonido. Devuelve -1 si hubo algún error (como que el archivo no exista) sound_replace (index, fname, kind, loadonuse): Como la anterior, solo que reemplaza el archivo por el sonido especificado. sound_delete (index): Elimina el sonido indicado, liberando toda la memoria asociada a el. 57.3.- Backgrouds (Fondos): Las siguientes funciones pueden ser usadas para crear y remover backgrounds. background_duplicate (ind): Crea un duplicado del background con el index dado. Devuelve el index del nuevo background. Si algún error ha ocurrido devuelve -1. background_assign (ind, back): Asigna el background indicado al background index especificado. Esto en realidad hace una copia del background, pero directamente le especifica el nombre. background_add (fname, transparent, smooth, preload) Agrega una imagen guardada en el archivo fname a un background. Solo bmp y jpg, transparent indica si la imagen debe ser parcialmente transparente, smooth indica si se deben suavizar los ejes, preload indica si debe cargar la imagen en la memoria de texturas inmediatamente. Esta función devuelve el nuevo index del back ground agregado. background_replace (ind, fname, transparent, smooth, preload): Igual que antes solo que el background agregado es reemplazado por el especificado ya existente. background_create_color (w, h, col, preload): Crea un nuevo background con el tamaño y color indicado. Devuelve el index del nuevo background. background_create_gradient (w, h, col1, col2, kind, preload) Crea un background relleno con degradado de colores. col1 y col2 son los 2 colores entre los que se debe degradar, kind es un número entre 0 y 5, indicando el tipo de degradado: 0=horizontal 1=vertical, 2= rectangle, 3=elipse, 4=soble horizontal, 5=doble vertical. Devuelve el index del nuevo background. Si un error ha ocurrido devuelve -1. background_create_from_screen (x, y, w, h, transparent, smooth, preload): Crea un background copiando el area de la pantalla. Esta función te da la posibilidad de crear el background que quieras. background_create_from_surface (id, x, y, w, h, transparent, smooth, preload): Crea un background copiando el area dada desde la superficie (surface) especificada. background_delete (ind): Elimina el background liberando toda memoria usada por este. La siguiente función existe para cambiar la apariencia de un background. background_set_alpha_from_background (ind, back): M odifica el alpha(transparencia) en el background con el index dado usando los valores de hue del background back. Esto no se puede deshacer. 145
- 146. 57.4.- Fonts (Fuentes / Ti pos de letras): Es posible crear, reemplazar y borrar fuentes durante el juego usando las siguientes funciones. (No reemplaces una fuente que está siendo usada). font_add (name, size, bold, italic, first, last): Agrega una nueva fuente y devuelve su index, indicando el nombre, el tamaño, si usar negrita (bold) o cursiva (italic), y el primer carácter y último que debe ser creado. font_add_sprite (spr, first, prop, sep): Agrega una nueva fuente y devuelve su index. Esta fuente es creada desde un sprite. El sprite debe contener una subimagen para cada carácter, first indica e l index del primer carácter en el sprite, prop indica si la fuente es proporcional, esto significa que para cada carácter, su tamaño es proporcional con el tamaño de la bounding box. sep indica la cantidad de espacio en blanco que debe separar los caracteres horizontalmente, un valor común sería entre 2 y 8. font_replace (ind, name, size, bold, italic, first, last): Como la primera, solo que agrega la fuente reemplazando la ya existente. font_replace_sprite (ind, spr, first, prop, sep): Reemplaza la fuente ind con la nueva fuente basada en sprite. font_delete (ind): Elimina la fuente con el index dado, liberando toda memoria usada por esta. 57.5.- Paths (Cami nos o trayectorias): Es posible crear y agregar puntos a los paths. Nunca cambie path que están siendo usados por una instancia, esto puede traer resultados inesperados. Las siguientes funciones existen: path_set_kind (ind, val): Indica el tipo de conexiones que el path debe tener (0=derecho, 1=suave). path_set_closed (ind, closed): Fija si el path debe ser cerrado (true) o abierto (false). path_set_precision (ind, prec): Fija la precisión con la suavidad del path es calculada, (entre 1 y 8). path_add (): Agrega un nuevo path vacío, devuelve el index usado. path_delete (ind): Elimina el path con el index indicado. path_duplicate (ind): Crea un duplicado del path con el index dado, devuelve el index de la copia. path_assign (ind, path): Asigna el path indicado, al index indicado. path_append (ind, path): Agrega el path indicado al final del path. path_add_point (ind, x, y, speed): Agrega un punto al path con el index dado, en posición (x, y) con la velocidad dada. Recuerda que un valor de 100 corresponde a la velocidad actual. path_insert_point (ind, n, x, y, speed): Inserta un punto en el path con el index dado, antes del punto n, en posición (x, y) y con la velocidad dada. path_change_point (ind, n, x, y, speed): Cambia el punto n del path a la posición (x, y) con la velocidad dada. path_delete_point (ind, n): Elimina el punto n en el path con el index dado. path_clear_points (ind): Convierte el path en un path vacío (Eliminando todos sus puntos). path_reverse (ind): Invierte el sentido del path. path_mirror (ind): Invierte el path horizontalmente (respecto a su centro). path_flip (ind): Invierte el path verticalmente (respecto a su centro). path_rotate (ind, angle): Rota el path anti-horario sobre el ángulo indicado, en grados (respecto a su centro). path_scale (ind, xscale, yscale): Escala el path con los valores especificados. path_shift (ind, xshift, yshift): M ueve todo el path sobre la cantidad dada. 57.6.- Scripts: Los scripts no pueden ser cambiados durante la ejecución del juego. Los scripts son parte de la lógica del juego. Cambiar scripts traerá la necesidad de reescribir el código lo que puede fácilmente traer errores. Pero hay otras formas de lograr esto. Si realmente necesitas ejecutar un código que es desconocido en el desarrollo del juego, puedes hacerlo con las siguientes funciones: execute_string (str): Ejecuta el código en la cadena str. execute_file (fname): Ejecuta el código desde el archivo indicado. A veces necesitas guardar el index de un script en una variable, y usarlo para ejecutarlo. Se puede hacer con la siguiente función: script_execute (scr, arg0, arg1,...): Ejecuta el script con el index dado, con los argumentos dados. 57.7.- Ti me lines (Líneas de tiempo): Las siguientes funciones existen para crear y modificar time lines. No cambies time lines que están en uso: timeline_add (): Agrega una nueva time line. Devuelve su index. timeline_delete (ind): Elimina la time line indicada. Asegúrate que no esté siendo usada. timeline_moment_add (ind, step, codestr): Agrega una acción a la time line, codestr debe contener el código para las acciones. Si el step indicado no existe será creado. 146
- 147. timeline_moment_clear (ind, step): Puedes usar esta función para borrar todas las acciones para un momento en particular. 57.8.- Objects (Objetos): También los objetos pueden ser manipulados y creados durante el juego. NUNCA cambies o borres un objeto si hay instancias creadas de este. Esto puede traer errores inesperados. object_set_sprite (ind, spr): Fija el sprite del objeto con el index dado. Use -1 para remover el sprite del objeto. object_set_solid (ind, solid): Fija si las instancias de este objeto deben ser sólidas. object_set_visible (ind, vis): Fija si las instancias de este objeto deben ser visibles. object_set_depth (ind, depth): Fija el depth de las instancias de este objeto. object_set_persistent (ind, pers): Fija si las instancias de este objeto deben ser persistentes. object_set_mask (ind, spr): Fija la mask de las instancias de este objeto. object_set_parent (ind, obj): Fija el parent (padre) de este objeto. Las siguientes funciones son útiles para crear objetos durante el juego. Como con todos los recursos, ten cuidado de no estar creando objetos todo el tiempo (step event por ejemplo). object_add (): A grega un nuevo objeto. Devuelve el index del objeto. Puedes usar este index en las funciones anteriormente mencionadas para modificar las propiedades del objeto. object_delete (ind): Elimina el objeto con el index dado. Asegúrate que no exista ninguna instancia de este objeto. object_event_add (ind, evtype, evnumb, codestr) Para darle un comportamiento a los objetos debemos definirle eventos. Solo puedes agregar códigos a los eventos usando esta función. Necesitas especificar el objeto, el tipo de evento, el número de evento (ver función event_perform() para más información) y el código que será ejecutado. object_event_clear (ind, evtype, evnumb): Puedes usar esta función para borrar todas las acciones de un evento en particular. Crear objetos es en particular útil cuando estás diseñando scripts o librerías. Durante la interfase. 57.9.- Rooms (Cuartos): M anipular rooms es algo peligroso. Debes tener en cuenta que los rooms cambian todo el tiempo debido a lo que está pasando en el juego. Esto es peligroso porque todo gira entorno a los rooms como sprites, objetos, backgrounds. Por eso debes tener mucho cuidado. Otra cosa es que estos errores no serán avisados (no te saldrá el mensaje de error), sino que verás efectos inesperados en el juego. Las siguientes funciones están disponibles: room_set_width (ind, w): Fija el width (ancho) del room con el index indicado. room_set_height (ind, h): Fija el height (altura) del room con el index indicado. room_set_caption (ind, str): Fija el caption (título) del room con el index indicado. room_set_persistent (ind, val): Fjia si el room debe ser persistent. room_set_code (ind, str): Fija el Room Creation Code. room_set_background_color (ind, col, show) Fija las propiedades del background color del room (el color de fondo del room), col indica el color y show indica si se debe mostrar o no. room_set_background (ind, bind, vis, fore, back, x, y, htiled, vtiled, hspeed, vspeed, alpha): Fija el background con el index bind (0-7) para el room con el index ind. vis indica si el background es visible y fore si es un foreground, back es el index de la imagen background, x, y indican la posición de la imagen y htiled, vtiled indican si la imagen se debe repetir, hspeed y vspeed indican la velocidad con la que el background se mueve, y alpha indica la transparencia. room_set_view (ind, vind, vis, xview, yview, wview, hview, xport, yport, wport, hport, hborder, vborder, hspeed, vspeed, obj): Fija la view con index vind (0-7) para el room con el index indicado, vis indica si la view es visible, xview, yview, wview y hview indican la posición de la view en el room, xport, yport, wport y hport indican la posición en la pantalla. Cuando la view debe seguir a un objeto hborder e yborder indican el borde mínimo visible que se debe mantener alrededor del objeto, hspeed y vspeed indican la máxima velocidad con la cual la view se mueve, obj es el index del objeto que debe seguir, o el id de una instancia. room_set_view_enabled (ind, val): Fija si las views deben estar disponibles en el room indicado. room_add (): A grega un nuevo room. Devuelve el index del nuevo room. Tenga en cuenta que el room no será parte del orden de los rooms. Entonces el nuevo room no tiene ni room siguiente ni room anterior. Si deseas moverte a este room agregado deberás proveer su index. room_duplicate (ind): Duplica el room con el index indicado y devuelve el nuevo index. room_assign (ind, room): Asigna el room indicado al room ind. Esto en realidad hace una copia del room. room_instance_add (ind, x, y, obj): Agrega una instancia del objeto obj en el room, posicionándolo en la posición x, y. Devuelve el id de la instancia. room_instance_clear (ind): Remueve todas las instancias del room indicado. room_tile_add (ind, back, left, top, width, height, x, y, depth): Agrega un nuevo tile al room con la posición indicada. Devuelve el id del tile, back es el background desde el cual el tile es tomado, left, top, width y height indican la parte del background que forma el tile, depth es la profundidad del tile. 147
- 148. room_tile_add_ext (ind, back, left, top, width, height, x, y, depth, xscale, yscale, alpha): Igual que la función anterior, pero esta vez puedes también especificar un valor de escala horizontal y vertical. Y también una transparencia (alpha). room_tile_clear (ind): Remueve todos los tiles del room indicado. 58.- Archivos, registro y ejecución de programas: En juegos más avanzados, probablemente desees leer información de un archivo que viene con tu juego. O puedes querer guardar información mientras el juego está siendo ejecutado. Y en algunas situaciones puedes necesitar ejecutar programas externos. Información puede ser encontrada en las siguientes páginas: 58.1.- Archi vos: Es muy útil poder usar archivos externos en los juegos. Por ejemplo, puedes necesitar un archivo que describa a que momento que debe pasar. También puedes querer guardar información para la siguiente ocasión en que e l juego sea ejecutado (como el room actual). Las siguientes funciones existen para leer y escribir datos en archivos de texto: file_text_open_read (fname): Abre un archivo para lectura con el nombre indicado. Devuelve el id que debe ser usado en otras funciones. Puedes abrir múltiples archivos (máximo 32). No olvides cerrarlos una vez que hayas terminado con ellos. file_text_open_write (fname): Como el anterior, solo que lo abre para escribir en el en vez de para leerlo. Si el archivo no existe, lo crea. También devuelve el index que deberá ser usado en otras funciones. file_text_open_append (fname): Como el anterior, solo que lo abre y posiciona el cursor para escribir al final del archivo. file_text_close (fileid): Cierra el archivo con el id dado. file_text_write_string (fileid, str): Escribe el texto string al archivo especificado. file_text_write_real (fileid, x): Escribe el número al archivo especificado. file_text_writeln (fileid): Baja un renglón en el archivo. file_text_read_string (fileid): Devuelve el texto que se encuentra en el renglón en donde está posicionado el cursor en el archivo especificado. file_text_read_real (fileid): Lee un valor real del archivo y lo retorna. file_text_readln (fileid): Baja un renglón el cursor del archivo dado, posicionándose en el principio de este. file_text_eof (fileid): Devuelve si hemos llegado al final del archivo. Para manipular archivos en el sistema puedes usar las siguientes funciones: file_exists (fname): Devuelve si el archivo con el nombre dado existe (true) , o no (false) . file_delete (fname): Elimina el archivo con el nombre dado. file_rename (oldname, newname): M odifica el nombre del archivo oldname al nombre newname. file_copy (fname, newname): Realiza una copia del archivo fname al archivo newname. directory_exists (dname): Devuelve si el directorio indicado existe. directory_create (dname): Crea un directorio con el nombre dado (el nombre incluye el path al directorio). Solo si no existe. file_find_first (mask, attr): Devuelve el nombre del primer archivo que posea el formato especificado en mask. Si no encuentra ninguno, devuelve un string vacío. Los atributos son propiedades adicionales de los archivos, puedes especificar el atributo con las siguientes constantes: fa_readonly: Archivos solo lecturas fa_hidden: Archivos ocultos fa_sysfile: Archivos de sistema fa_directory: Directorios fa_archive. Archivo de archivos. file_find_next (): Como la anterior, solo que devuelve el siguiente archivo al archivo encontrado. file_find_close (): Debe ser llamado cuando se termina de trabajar con los archivos para liberar memoria. file_attributes (fname, attr): Devuelve si el archivo posee los atributos dados. Existen funciones extra para tratar con archivos: filename_name (fname): Devuelve el nombre del archivo, con la extensión, pero sin el path. filename_path (fname): Devuelve el path del archivo, incluyendo la barra final. filename_dir (fname): Igual que el anterior, solo que sin la barra final. filename_drive (fname): Devuelve la información del archivo en el disco. filename_ext (fname): Devuelve la extensión del archivo, incluyendo el punto. filename_change_ext (fname, newext): Devuelve el archivo indicado, con la extensión (incluyendo el punto) cambiado a la nueva extensión. Usando un string vacío como nueva extensión puedes borrársela. 148
- 149. En raras situaciones puedes necesitar leer datos binarios de los archivos. Existen las siguientes funciones para esto: file_bin_open (fname, mod): Abre el archivo con el nombre indicado. El modo indica que se puede hacer con el archivo: 0 = lectura, 1 = escritura, 2 = ambos. La función devuelve el id del archivo que debe ser usado en otras funciones. Puedes abrir múltiples archivos a la vez, (32 máximo). No olvides cerrarlos una vez que hayas terminado de trabajar con ellos. file_bin_rewrite (fileid): Borra el contenido del archivo dado. Nota: No borra el archivo, solo sus datos. file_bin_close (fileid): Cierra el archivo especificado. file_bin_size (fileid): Devuelve el tamaño en bytes del archivo especificado. file_bin_position (fileid): Devuelve la posición actual del archivo dado. (en bytes, 0 es el principio). file_bin_seek (fileid, pos): M ueve la posición en el archivo a la indicada. file_bin_write_byte (fileid, byte): Escribe un byte de dato en el archivo especificado. file_bin_read_byte (fileid): Lee un byte de dato desde el archivo especificado. Si el jugador ha puesto modo seguro (secure mode) en sus preferencias, unas cuantas de estas funciones no estarán disponibles. Las siguientes variables de sólo lectura le pueden resultar útiles. game_id*: Identificador único del juego. working_directory*: El directorio en donde se encuentra el juego. Sin incluir la barra final. temp_directory*: Directorio temporal creado por el juego. Puedes almacenar archivos aquí, que serán eliminados cuando el juego termine. 58.2.- Registro: Si deseas guardar una pequeña cantidad de información, puedes usar un mecanismo más simple que usar un archivo. Puedes usar el registro. El registro es una gran base de datos que Windows mantiene para llevar el rastro de muchas cosas, generalmente referidas a la configuración de los programas. Un registro posee un nombre y un valor. Puedes usar ambos tipos, textos o números. Las siguientes funciones existen: registry_write_string (name, str): Crea una entrada en el registro con el nombre y el texto dado. registry_write_real (name, x): Crea una entrada en el registro con el nombre y el valor real dado. registry_read_string (name): Devuelve el texto que el nombre posee. El nombre debe existir, en caso contrario devuelve un texto vacío. registry_read_real (name): Devuelve el valor real que el nombre posee. El nombre debe existir, en caso contrario 0 es retornado. registry_exists (name): Devuelve si el nombre dado existe. En realidad, los datos en el registro están agrupados dentro de keys. Las funciones anteriores, funcionan en la key que es creada especialmente para tu juego. El programa puede usar estas funciones para obtener cierta información sobre el sistema mientras el juego está siendo ejecutado. Incluso puedes leer datos en otras keys. Incluso puedes escribir datos en otras keys. Pero ten cuidado PUED ES LLEGAR A DAÑ AR TU S IS TEMA. La escritura en el registro no está permitida en modo seguro. registry_write_string_ext (key, name, str): Crea una entrada en la key especificada en el registro, con el nombre y valor de texto. registry_write_real_ext (key, name, x): Crea una entrada en la key especificada en el registro, con el nombre y valor real. registry_read_string_ext (key, name): Devuelve el string que se encuentra con el nombre indicado en la key indicada. registry_read_real_ext (key, name): Devuelve el valor real que se encuentra con el nombre indicado en la key indicada. registry_exists_ext (key, name): Devuelve si el nombre dado en la key dada, existe. registry_set_root (root): M odifica la raíz para las otras rutinas. Para key utilice los siguientes valores: 0 = HKEY_CURRENT_USER 1 = HKEY_LOCAL_MACHINE 2 = HKEY_CLASSES_ROOT 3 = HKEY_USERS 58.3.- Archi vos INI: Para pasar una cierta cantidad de parámetros, a los programas existe el mecanismo estándar, que es el uso de los archivos INI. Los archivos INI contienen secciones, y en cada sección un número de keys y valores. Por ejemplo, este es un típico archivo INI: [Teclas] 149
- 150. Right=39 Up=38 Left=37 Down=40 [Juego] Vidas=2 Energía=50 Nombre=Diego Este archivo INI contiene 2 secciones (Teclas y Juego). En la sección Teclas hay 4 keys (Right, Up, Left y Down). Con su valor correspondiente. En la sección Juego hay 3 keys (Vidas, Energía y Nombre). Los archivos INI son muy fáciles de usar, las siguientes funciones existen: ini_open (name): Abre un archivo INI con el nombre dado. El archivo debe estar en el mismo directorio que el juego. ini_close (): Cierra el archivo INI que se encuentre abierto. ini_read_string (section, key, default): Lee el valor de texto en la sección indicada, con la key indicada. Cuando la key, el archivo, o la sección no existan, devolverá el valor especificado en default. ini_read_real (section, key, default): Igual que la anterior, solo que lee un valor real. ini_write_string (section, key, value): Escribe un valor de texto en la sección y la key especificada. ini_write_real (section, key, value): Escribe un valor real en la sección y la key especificada. ini_key_exists (section, key): Devuelve si la key especificada existe en la sección indicada. ini_section_exists (section): Devuelve si la sección existe. ini_key_delete (section, key). Elimina la key de la sección. ini_section_delete (section): Elimina la sección dada. 58.4.- Ejecutando programas: Game M aker posee la posibilidad de ejecutar programas externos. Hay 2 funciones disponibles para esto: execute_program y execute_shell. La función execute_program ejecuta un programa, posiblemente con algunos argumentos. Puede esp erar a que el programa termine (pausando el juego) o continuar el juego. execute_program (prog, arg, wait): Ejecuta el programa prog con los argumentos arg. wait indica si el juego debe pausarse o no. execute_shell (prog, arg): Ejecuta el programa (o archivo) en el shell. Ambas funciones no funcionarás si el jugador tiene activado modo seguro en preferencias. Puedes comprobar eso con la siguiente variable de solo lectura. secure_mode*: Si el juego está corriendo en modo seguro. 59.- Data Structures (Estructuras de Datos): Esta funcionalidad está solamente disponible en la versión registrada del Game M aker. En los juegos muy a menudo necesitas guardar información. Por ejemplo necesitas guardar la lista de objetos que una persona lleva, o guardar lugares que deben ser visitados. Puedes usar arrays para esto. Pero si quieres hacer operaciones más complicadas como ordenar, remover, buscar, etc. un objeto en particular, necesitarás escribir largos códigos en GM L los cuales pueden realentizar el juego en su ejecución. Para solucionar esto, Game M aker posee cierta cantidad de data structures (Estructuras de datos en español, de ahora en más serán nombradas siempre data structures, acostúmbrense). Actualmente hay seis tipos de data structures disponibles: stacks, queues (filas), lists, maps, priority queues y grids. Cada uno con sus funciones y ventajas. Todas las data structures funcionan globalmente igual. Puedes crear una data structure con una función que devuelve su id. Luego usas este id para ejecutar ciertas operaciones de las data structures. Una vez que no necesites más la data structure la puedes eliminar liberando memoria. Puedes usar la cantidad de data structures que quieras al mismo tiempo, si así lo deseas. Todas las data structures pueden guardar ambos, strings y valores reales. Tenga en cuenta que toda la información que contengan las data structures no serán guardadas cuando el juego sea guardado usando las funciones para eso. Si deseas guardar información de las data structures deberá usar su propio mecanismo de guardar/cargar juego. Cuando se comparen valores, por ejemplo cuando estés buscando en un mapa, u ordenando una lista, Game M aker debe decidir que hacer cuando 2 valores son iguales. Para números enteros o textos, esto es claro, pero cuando son números reales, no lo es debido a los errores de redondeo. Por ejemplo (5/3)*3 no será igual a 5. Para evitar esto, la precisión es usada. Cuando la diferencia entre 2 números es más pequeña que la precisión usada, estos números se consideran iguales. La precisión por defecto es 0.0000001. Puedes cambiar la precisión usada con la siguiente función: ds_set_precition (prec): Fija la precisión usada para comparaciones en Data Structures. 150
- 151. Nota: Esta precisión es SOLAM ENTE usada en data structures. Información sobre data structures puede ser encontrada en las siguientes páginas: 59.1.- Stracks: Un stack data structure es también llamado LIFO (Last-In First-Out) structures. Esto significa que el último dato que entra, es el primero en salir. ds_stack_create (): Crea un nuevo stack. Esta función devuelve el id del stack, que debe ser usado en todas las otras funciones para acceder a este stack en particular. ds_stack_destroy (id): Destruye el stack con el id dado, liberándolo de la memoria. No olvides llamar esta función cuando no necesites más el stack. ds_stack_clear (id): Borra todos los datos del stack dado, pero no lo destruye. ds_stack_size (id): Devuelve el número de valores guardados en el stack. ds_stack_empty (id): Devuelve si el stack está vacío. Es lo mismo que comprobar si el número de valores guardados es 0. ds_stack_push (id, val): Empuja el valor en el stack. ds_stack_pop (id): Devuelve el valor que se encuentre al final del stack, y lo remueve del mismo. ds_stack_top (id): Igual que la anterior, solo que en este caso no remueve el valor. 59.2.- Queues (Filas): Una queue (fila) es parecida al stack, solo que funciona como FIFO (First-In First-Out), esto significa que el primer valor que entra, es el primero en salir. Entiéndalo como una fila en un negocio, a la persona que entra primero es a la que se atiende primero, y la que sale primero. Las queues (filas) son generalmente útiles para guardar cosas que se deben hacer con cierta prioridad, pero tiene muchos usos. Las siguientes funciones están disponibles: ds_queue_create (): Crea una nueva queue (fila). Esta función devuelve el id de la queue (fila), que debe ser usado en todas las otras funciones para acceder a esta queue (fila) en particular. ds_queue_destroy (id): Destruye la queue (fila) con el id dado, liberándolo de la memoria. No olvides llamar esta función cuando no necesites más la queue (fila) ds_queue_clear (id): Borra todos los datos de la queue (fila) dada, pero no la destruye ds_queue_size (id): Devuelve el número de valores guardados en la queue (fila). ds_queue_empty (id): Devuelve si la queue (fila) está vacía. Es lo mismo que comprobar si el número de valores guardados es 0. ds_queue_enqueue (id, val): Agrega el valor val a la queue (fila) especificada. ds_queue_dequeue (id): Devuelve el valor más largo en la queue (fila) y lo remueve de la misma. ds_queue_head (id): Devuelve el valor que se encuentra al principio de la queue (fila), el que más tiempo lleva en la misma. (No lo remueve del mismo). ds_queue_tail (id): Devuelve el valor que se encuentra al final de la queue (fila), el que menos tiempo lleva en la misma. (No lo remueve del mismo). 59.3.- Lists (Listas): Una lista guarda ciertos datos en un orden particular. Puedes agregar datos al final, o insertarlos en cualquier parte de la lista. Puedes ordenar los valores, sea en orden ascendiente o descendiente. Las listas tienen diversas utilidades, por ejemplo, guardar una colección de valores. Están implementadas usando simples arrays, pero como esto ya está compilado el código es mucho más rápido que usar arrays vos mismo. Las siguientes funciones están disponibles: ds_list_create (): Crea una lista nueva. Esta función devuelve el id del stack, que debe ser usado en todas las otras funciones para acceder a esta lista en particular. ds_list_destroy (id): Destruye la lista con el id dado, liberándola de la memoria. No olvides llamar esta función cuando no necesites más la lista. ds_list_clear (id): Borra todos los datos de la lista dada, pero no la destruye ds_list_size (id): Devuelve el número de valores guardados en la lista. ds_list_empty (id): Devuelve si la lista está vacía. Es lo mismo que comprobar si el número de valores guardados es 0. ds_list_add (id, val): Agrega el valor val al final de la lista id. ds_list_insert (id, pos, val): Inserta el valor val en posición pos en la lista id. El primer valor es posición 0. y el último valor es posición tamaño menos 1. ds_list_replace (id, pos, val): Reemplaza el valor val en posición pos, en la lista id. ds_list_delete (id, pos): Elimina el valor que se encuentre en la posición pos en la lista id. ds_list_find_index (id, val): Devuelve la posición en la que se encuentra el valor val, en la lista id. Si no encuentra devuelve -1. ds_list_find_value (id, pos): Devuelve el valor que se encuentra en la posición pos de la lista id. 151
- 152. ds_list_sort (id, ascend): Ordena los datos de la lista id. Si ascend es true, el ordenamiento es ascendiente, en caso contrario es descendiente. 59.4.- Maps (Mapas): Puede necesitar valores en pares, que consistan de una key y un valor. Por ejemplo, un personaje puede poseer distintos objetos, y cada objeto con una cierta cantidad de estos. En este caso el objeto es la key, y el valor es la cantidad. Las siguientes funciones existen: ds_map_create (): Crea un nuevo mapa. Esta función devuelve el id del mapa, que debe ser usado en todas las otras funciones para acceder a este map en particular. ds_map_destroy (id): Destruye el map con el id dado, liberándolo de la memoria. No olvides llamar esta función cuando no necesites más el mapa. ds_map_clear (id): Borra todos los datos del mapa dado, pero no lo destruye ds_map_size (id): Devuelve el número de valores guardados en el mapa. ds_map_empty (id): Devuelve si el mapa está vacío. Es lo mismo qu e comprobar si el número de valores guardados es 0. ds_map_add (id, key, val): Agrega una key y valor al mapa. ds_map_replace (id, key, val): Reemplaza el valor correspondiente a la key en el mapa dado. ds_map_delete (id, key): Elimina la key dada en el mapa correspondiente. ds_map_exists (id, key): Devuelve si una key existe en el mapa. ds_map_find_value (id, key): Devuelve el valor correspondiente a la key. ds_map_find_previous (id, key): Devuelve la key más grande, pero menor que la key indicada. (Tenga en cuenta que la key es retornada, no el valor). ds_map_find_next (id, key): Devuelve la menor key, pero mayor que la key indicada. ds_map_find_first (id): Devuelve la key menor en todo el mapa. ds_map_find_last (id): Devuelve la key más grande en todo el mapa. 59.5.- Priority Queues (Priori dades de las filas): En una priority queue (prioridad de fila) hay una cantidad de valores guardados, cada uno con una prioridad. Puedes rápidamente encontrar un valor indicando su prioridad. Usando este tipo de data structure usted puede especificar una cantidad de cosas con una respectiva prioridad. Las siguientes funciones existen. ds_priority_create (): Crea un nuevo queue. Esta función devuelve el id del queue, que debe ser usado en todas las otras funciones para acceder a este queue en particular. ds_priority_destroy (id): Destruye el queue con el id dado, liberándolo de la memoria. No olvides llamar esta función cuando no necesites más el queue ds_priority_clear (id): Borra todos los datos del queue dado, pero no lo destruye. ds_priority_size (id): Devuelve el número de valores guardados en el queue. ds_priority_empty (id): Devuelve si el queue está vacío. Es lo mismo que comprobar si el número de valores guardados es 0. ds_priority_add (id, val, prio): Agrega el valor dado con la prioridad dada. ds_priority_change_priority (id, val, prio): M odifica la prioridad del valor dado. ds_priority_find_priority (id, val): Devuelve la prioridad del valor dado. ds_priority_delete_value (id, val): Elimina el valor especificado del queue. ds_priority_delete_min (id): Devuelve el valor con la menor prioridad en todo el queue, y lo elimina. ds_priority_find_min (id): Devuelve el valor con la menor prioridad en todo el queue pero no lo elimina. ds_priority_delete_max (id): Devuelve el valor con mayor prioridad en todo el queue y lo elimina del mismo. ds_priority_find_max (id): Devuelve el valor con mayor prioridad, pero no lo elimina. 59.6.- Gri ds (cel das): Una grid (celda) consiste en arrays (órdenes) bidimensionales. La grid (celda) posee un número entero como ancho, y uno como altura. Esta estructura te da la posibilidad de tomar el valor de una celda dependiendo de la posición de la misma (ancho y alto).También puedes poner valores en regiones, agregar valores, conseguir la suma, el máximo, el mínimo e incluso el valor medio de los valores en una región. Por más que esto se pueda lograr con arrays bidimensionales, las operaciones con data structures son mucho más rápidas. Las siguientes funciones existen: ds_grid_create (w, h): Crea un grid (celda) nuevo con el ancho y altura indicado. La función devuelve el id que debe ser usado en todas las otras funciones para acceder a este grid (celda) en particular. ds_grid_destroy (id): Destruye el grid (celda) con el id dado, liberando la memoria usada por este. No olvides llamar esta función cuando no necesites más la estructura. ds_grid_resize (id, w, h): M odifica el tamaño del grid (celda). Celdas existentes conservan su valor original. ds_grid_width (id): Devuelve el ancho del grid (celda) con el id indicado. ds_grid_height (id): Devuelve la altura del grid (celda) con el id indicado. 152
- 153. ds_grid_clear (id, val): Despeja el grid (celda) con el id indicado al valor indicado. (Puede ser un número o un string). ds_grid_set (id, x, y, val): M odifica la celda indicada en el grid (celda) al valor indicado. (Puede ser un número o un string). ds_grid_add (id, x, y, val): Suma el valor en la celda correspondiente según lo indicado. Para textos los combina. ds_grid_multiply (id, x, y, val): M ultiplica el valor en la celda correspondiente según lo indicado. Solamente válido para números. ds_grid_set_region (id, x1, y1, x2, y2, val): Modifica todas las celdas en la región dada, al valor indicado. (Puede ser un número o un string). ds_grid_add_region (id, x1, y1, x2, y2, val): Suma el valor indicado en cada celda que se encuentre en la región dada. ds_grid_multiply_region (id, x1, y1, x2, y2, val): M ultiplica el valor indicado en cada celda que se encuentre en la región dada. Sólo válido para números. ds_grid_set_disk (id, xm, ym, r, val): M odifica todos los valores en las celdas teniendo en cuenta un área circular con posición (xm, ym) y radio r. ds_grid_add_disk (id, xm, ym, r, val): Agrega un valor val a todos los valores en las celdas teniendo en cuenta un área circular con posición (xm, ym) y radio r. ds_grid_multiply_disk (id, xm, ym, r, val): M ultiplica un valor val a todos los valores en las celdas teniendo en cuenta un área circular con posición (xm, ym) y radio r. ds_grid_get (id, x, y): Devuelve el valor que se encuentre en la celda indicada. ds_grid_get_sum (id, x1, y1, x2, y2): Devuelve la suma de los valores en las celdas según la región dada. Solo funciona con las celdas que contienen números. ds_grid_get_max (id, x1, y1, x2, y2): Devuelve el máximo de los valores en las celdas según la región dada. Solo funciona con las celdas que contienen números. ds_grid_get_min (id, x1, y1, x2, y2): Devuelve el mínimo de los valores en las celdas según la región dada. Solo funciona con las celdas que contienen números. ds_grid_get_mean (id, x1, y1, x2, y2): Devuelve el promedio de los valores en las celdas según la región dada. Solo funciona con las celdas que contienen números. ds_grid_get_disk_sum (id, xm, ym, r): Devuelve la suma de los valores que se encuentren en el area circular dada. ds_grid_get_disk_min (id, xm, ym, r): Devuelve el mínimo de los valores que se encuentren en el area circular dada. ds_grid_get_disk_max(id,xm,ym,r) Devuelve el máximo de los valores que se encuentren en el area circular dada. ds_grid_get_disk_mean(id,xm,ym,r) Devuelve el promedio de los valores que se encuentren en el area circular dada. ds_grid_value_exists (id, x1, y1, x2, y2, val): Devuelve si el valor dado existe en alguna parte de la región. ds_grid_value_x (id, x1, y1, x2, y2, val): Devuelve la coordenada x de la celda en la cual se encuentra el valor en la región especificada. ds_grid_value_y (id, x1, y1, x2, y2, val): Devuelve la coordenada y de la celda en la cual se encuentra el valor en la región especificada. ds_grid_value_disk_exists (id, xm, ym, r, val): Devuelve si el valor dado existe en alguna parte del área circular. ds_grid_value_disk_x (id, xm, ym, r, val): Devuelve la coordenada x de la celda en la cual se encuentra el valor en el área circular especificado. ds_grid_value_disk_y (id, xm, ym, r, val): Devuelve la coordenada y de la celda en la cual se encuentra el valor en el área circular especificado. 60.- Creando Partículas: Esta funcionalidad está solamente disponible en la versión registrada del Game Maker. Los sistemas de Partículas (Particle System) están especialmente diseñados para hacer efectos especiales. Las partículas son pequeños elementos representados por un pequeño sprite. Estas partículas se mueven de acuerdo a sus reglas predefinidas, y pueden variar en tamaño, orientación, color, transparencia, etc. M ientras se mueven. Con las partículas se pueden crear increíbles efectos, como por ejemplo: fuegos artificiales, fuego, explosiones, lluvia, nieve, campos estrellados, humo, niebla, etc. El Game M aker contiene un extenso sistema de partículas que puede ser usado para crear grandiosos efectos. Esto no puede ser muy simple, por lo tanto es recomendable leer bien estas secciones antes de probarlo vos mismo Si esto te resulta muy complicado, hay unos simples mecanismos ya prediseñados para crear distintos efectos. Pero obviamente, las partículas te dan mucho más control. Los sistemas de Partículas (Particle System) dependen de muchos parámetros y no siempre es fácil encontrar la forma de crear el efecto que desees. Primero de todo hay particle types. Un particle type es definido por su tipo particular de partícula. Cada particle type tiene muchos parámetros que lo describen, como forma, tamaño, color, movimiento, etc. Particles types deben ser definidos una sola vez, y luego pueden ser usado en cualquier parte del juego. En segundo lugar están los sistemas de Partículas (Particle System)s. Puede haber diferentes sistemas de Partículas (Particle System)s en el juego. Cada sistema de Partículas (Particle System) puede tener partículas de diferentes tipos (particle types). Un sistema de Partículas (Particle System) posee emitters que son los que crean las partículas. También pueden contener attractors que atraen a las partículas. Finalmente, t ambién puede poseer destroyers que destruyen partículas. 153
- 154. Información sobre las partículas puede ser encontrada en las siguientes páginas: 60.1.- Efectos simples: La manera más fácil de crear partículas es usando el mecanismo de efectos. Los efectos son creados usando un sistema de partículas, pero no te tienes que preocupar por todos los detalles. Simplemente especificas el tipo de efecto, la posición donde debe ser creado, el tamaño, y el color. Eso es todo. Estos son los números de diferentes tipos de efectos: ef_explosion ef_ring ef_ellipse ef_firework ef_smoke ef_smokeup ef_star ef_spark ef_flare ef_cloud ef_rain ef_snow Hay algunos que quieres crear solo una vez, como un explosión, y otros que son en cada step, como la nieve o la lluvia. Nota: La lluvia y nieve se crean en lo superior de la pantalla, por eso no importa la posición. Las siguientes 2 funciones son para crear efectos: effect_create_below (kind, x, y, size, color): Crea un efecto del tipo indicado en la posición indicada. La medida seria: pequeño=0 mediano=1 grande=2. El color es de su elección. El depth que se utiliza es: 100000. effect_create_above (kind, x, y, size, color): Similar al anterior, pero esta vez el efecto es creado encima de las instancias, con un depth de: -100000. Si quieres remover todos los efectos usa esta función: effect_clear (): Borra todos los efectos. 60.2.- Particicle Types (Ti pos de Partículas): Un tipo de particular describe la forma, el color, el movimiento, etc. de una particular partícula. Solo tienes que definir un tipo de partícula en el juego. Después de esto, puede ser usada en cualquier sistema de partículas en el juego. Los tipos de partículas tienen más parámetros que pueden usarse para cambiar todos los aspectos de la partícula. Un número de rutinas están habilitadas para crear un nuevo tipo de partícula y destruirlas de nuevo: part_type_create (): Crea una nueva particular. Vuelve al índice del tipo. Este índice debe ser usado en todas las llamadas de abajo para poner las propiedades del tipo de partícula. Esto quiere decir que casi siempre se pone en una variable global. part_type_destroy (ind): Destruye partículas tipo ind. Pon esto si ya no la necesitas más, para guardar espacio. part_type_exists (ind): Dice si la particular indicada existe. part_type_clear (ind): Pone las opciones predeterminadas al tipo de partícula ind. 60.3.- La forma de l a partícul a: Una particular tiene forma. Esta forma es indicada con un sprite. Puedes usar cualquier sprite que quieras para una particular, pero hay ya 15 hechos. Estos son de 64x64 de tamaño y tienen valores alpha, para que se vean bien con los fondos. Son indicados con las siguientes constantes. pt_shape_píxel pt_shape_disk pt_shape_square pt_shape_line pt_shape_star pt_shape_circle 154
- 155. pt_shape_ring pt_shape_sphere pt_shape_flare pt_shape_spark pt_shape_explosion pt_shape_cloud pt_shape_smoke pt_shape_snow Puedes poner la forma con las siguientes funciones: part_type_shape (ind, shape): Esta pone la forma del tipo de particular como cualquiera de las constantes de arriba. La predeterminada es pt_shape_píxel. También puedes usar tu propias sprites para la particular, si el sprite tiene sub imagines, puedes indicar que hacer con ellas. Puedes elegir una al azar. Animar el sprite, empieza en el principio de la animación o en un lugar a azar etc. Puedes usar estas funciones también. part_type_sprite (ind, sprite, animate, stretch, random): Pone tu propio sprite para un tipo de particular. Con animate, tu puedes indicar si el sprite debe si (1) o no debe (0) se animado. Con stretch (1 o 0) puedes indicar si la animación debe ser estrechada en el tiempo de vida de la particular. Y con random (1 o 0) puedes indicar si usas una subimagen random. Una vez elegido el sprite para la partícula, puedes indicar el tamaño de este. El tamaño 1 es el normal del sprite. part_type_size (ind, size_min, size_max, size_incr, size_wiggle): Pone el parámetro del tamaño para el tipo de partículas. Pones el mínimo y máximo tamaño al comenzar, y en cada paso (step), esta ira aumentando hasta llegar al máximo tamaño, (puedes usar un número negativo para en vez de agrandarse hacerse más pequeño). El tamaño predeterminado es 1, esto hace que el tamaño no cambie. part_type_scale (ind, xscale, yscale): Pone la escala horizontal y vertical. Este factor es multiplicado con el tamaño. La partícula también tiene orientación. Otra vez la orientación puede ser la misma para todas las partículas, diferente, o puede ir cambiando. Los ángulos especifican los grados. part_type_orientation (ind, ang_min, ang_max, ang_incr, ang_wiggle, ang_relative): Pone las características del ángulo de la orientación para el tipo de la partícula. Tú especificas el ángulo mínimo, el ángulo máximo, el incremento en cada paso y la cantidad de cambiar en ángulo. (Todos los valores predeterminados son 0.) Tu puedes también indicar si el ángulo dado debe ser pariente (1) a la dirección actual del movimiento o del absoluto (0). Por ejemplo fijando todos los valores a 0 pero ang_relative a 1, la orientación de la partícula seguirá exacto la trayectoria de la partícula. 60.4.- Coloreando y Mezclando: El color predeterminado es blanco. Cuando tú utilizas un sprite con sus propios colores, esto es normalmente lo que deseas y ningún color necesita ser especificado. part_type_color1 (ind, color1): Indica un solo color que se utilizará para la partícula. part_type_color2 (ind, color1, color2): Especifica dos colores entre los cuales se interpole el color. part_type_color3 (ind, color1, color2, color3): Similar pero esta vez el color se interpola entre tres colores que representen el color en el comienzo, intermedio, y en el extremo. part_type_color_mix (ind, color1, color2): Con esta función tú indicas que la partícula debe conseguir un color que sea una mezcla al azar de los dos colores indicados. Este color seguirá siendo fijo sobre el curso de la vida de la partícula. part_type_color_rgb (ind, rmin, rmax, gmin, gmax, bmin, bmax): Puede ser utilizado indicar que cada partícula debe tener un color fijo pero choosen de una gama. Tu especificas una gama en el componente rojo, verde, y azul del color (cada uno entre 0 y 255). part_type_color_hsv (ind, hmin, hmax, smin, smax, vmin, vmax): Puede ser utilizado indicar que cada partícula debe tener un color fijo pero choosen de una gama. Tu especificas una gama en el componente del color (cada uno de la saturación y del valor de la tonalidad entre 0 y 255). Además del color tu puedes también dar un valor de la transparencia de la alfa. Las formas incorporadas de la partícula tienen ya un poco de transparencia de la alfa pero tu puedes utilizar estos ajustes por ejemplo para hacer que la partícula desaparece sobre su tiempo de la vida. part_type_alpha1 (ind, alpha1): Fija un solo parámetro de la transparencia de la alfa (0-1) para el tipo de la partícula. part_type_alpha2 (ind, alpha1, alpha2): Similar pero este vez se da un valor del comienzo y del final y el valor de la alfa se interpola entre ellos. part_type_alpha3 (ind, alpha1, alpha2, alpha3): Se dan los valores de esta vez tres entre los cuales se interpola la transparencia de la alfa. Las partículas se mezclan normalmente con el fondo de la misma manera que sprites. Pero es también posible utilizar mezclar aditivo. Esto da en detalle un gran efecto para la explosión. part_type_blend (ind, additive): Fija si utilizar el añadido que mezcla (1) o el normal que mezcla (0) para el tipo de la partícula. 155
- 156. 60.5.- Li fe and Death Particles (Vi da y Muerte de las partícul as): Las partículas viven para una cantidad limitada de tiempo. Después de esto desaparecen. El curso de la vida se mide en pasos. Puedes indicar el curso de la vida (o una gama de cursos de la vida) para cada tipo de la partícula. Las partículas pueden crear las nuevas partículas de diversos tipos. Hay dos maneras para esto. Pueden crear nuevas partículas en cada paso o pueden crear partículas cuando mueren. Tenga cuidado que el número total de partículas no consigue demasiado alto. part_type_life (ind, life_min, life_max): Fija los límites del curso de la vida para el tipo de la partícula. (El valor predeterminado es 100). part_type_step (ind, step_number, step_type): Fija el número y el tipo de partículas que se deban generar en cada paso para el tipo indicado de la partícula. Si tu utilizas un valor negativo, en cada paso una partícula se genera con una ocasión -1/número. Tan por ejemplo con un valor de -5 una partícula se genera en promedio una vez cada 5 pasos. part_type_death (ind, death_number, death_type): Fija el número y el tipo de partículas que deban ser generadas cuando una partícula del tipo indicado muere. Tú puedes utilizar otra vez números negativos para crear una partícula con una ocasión particular. Observa que estas partículas están creadas solamente cuando la part ícula muere en el final de su vida, no cuando muere debido a un destructor (véase abajo). 60.6.- Sistemas de Partícul as (Particle System): Las partículas viven en sistemas de la partícula. Tan para tener partículas en su juego que tu necesitas crear unos o más sistemas de la partícula. Puede haber diversos sistemas de la partícula (pero preferiblemente mantener su número pequeño). Por ejemplo, si su juego tiene un número de pelotas y cada pelota tiene una cola de partículas, cada pelota tiene muy probablemente su propio sistema de la partícula. La manera más fácil de ocuparse de los sistemas de la partícula es crear uno y después crear partículas de ella, usando los tipos de la partícula que tú especificaste antes. Pero, como veremos abajo, los sistemas de la partícula pueden contener los emisores que producen automáticamente partículas, los attractors que los atraen, y los destructores que los destruyen. Una vez que las partículas se agreguen a un sistema de la partícula se ponen al día automáticamente cada paso y se dibujan. No se requiere ninguna otra acción. Para hacerla posible que las partículas están dibujadas, detrás, delante, o entre de casos del objeto, cada sistema de la partícula tiene una profundidad, similar a los casos y a los azulejos. Los sistemas de la partícula vivirán encendido por siempre después de que se creen. Tan incluso si tu cambias el sitio o recomienzas el juego, los sistemas y las partículas permanezcan. Los puedes destruir cuando ya no los necesites. Las funciones básicas siguientes se ocupan de los sistemas de la partícula: part_system_create (): Crea un nuevo sistema de la partícula. Vuelve el índice del sistema. Este índice se debe utilizar en todas las llamadas abajo para fijar las características del sistema de la partícula. part_system_destroy (ind): Destruye el sistema ind de la partícula. Esto ahorra espacio. part_system_exists (ind): Vuelve si existe el sistema indicado de la partícula. part_system_clear (ind): Despeja el sistema ind de la partícula a sus ajustes de defecto, quitando todas las partículas y emisor y attractors en él. part_system_draw_order (ind, oldtonew): Fija la orden en la cual el sistema de la partícula dibuja las partículas. Cuando el oldtonew es verdad las más viejas partículas se dibujan primero y la más nueva una mentira encima de ellas (defecto). Si no las más nuevas partículas se dibujan primero. Esto puede dar efectos algo diversos. part_system_depth (ind, depth): Fija la profundidad del sistema de la partícula. Esto se puede utilizar dejó las partículas aparecer detrás, delante, o entre de casos. part_system_position (ind, x, y): Fija la posición donde se dibuja el sistema de la partícula. Esto no es normalmente necesario pero si tú deseas tener partículas en una posición concerniente a un objeto móvil, tú puedes fijar la posición por ejemplo a ese objeto. Según lo indicado arriba, el sistema de la partícula se pone se actualiza y se dibuja automáticamente. Pero esto no es a veces lo que deseas. Para facilitar esto, puedes apagar la actualización automática o el dibujo y después decidirse cuándo activar la actualización o dibujar el sistema de la partícula. Para esto tú puedes utilizar las funciones siguientes: part_system_automatic_update (ind, automatic): Indica si el s istema de la partícula se debe actualizar automáticamente (1) o no (0). El defecto es 1. part_system_automatic_draw (ind, automatic): Indica si el sistema de la partícula se debe dibujar automáticamente (1) o no (0). El defecto es 1. part_system_update (ind): Esto activa las actualizaciones en la posición de todas las partículas en el sistema y deja a los emisores crear partículas. Tienes que llamar solamente esto cuando la actualización no es automática. (aunque es a veces también útil llamar esta función un par de veces antes de conseguir el sistema que va.) part_system_drawit (ind): Esto funciona dibuja las partículas en el sistema. Tienes que llamar solamente esto cuando el dibujo no es automático. Debe ser llamado en el acontecimiento del drenaje de un cierto objeto. Las funciones siguientes se ocupan de las partículas en sistemas de una partícula: 156
- 157. part_particles_create (ind, x, y, parttype, number): Esto funciona para crea partículas del número, y del tipo indicado en la posición (x, y) en el sistema. part_particles_create_color (ind, x, y, parttype, color, number): Esto funciona crea partículas del número del tipo indicado en la posición (x, y) en el sistema con el color indicado. Esto es solamente útil cuando el tipo de la partícula define un solo color (o no define un color en todos). part_particles_clear (ind): Esto funciona quita todas las partículas en el sistema. part_particles_count (ind): Esto funciona las vueltas el número de partículas en el sistema. 60.7.- Emi tters (Emisores o Generadores): Los emisores crean partículas. Pueden crear una corriente continua de partículas o pueden estallar fuera de un número de partículas al usar la función apropiada. Un sistema de la partícula puede tener un número arbitrario de emisores. Un emisor tiene las características siguientes: xmin, xmax, ymin, ymax: Indica el extender de la región en la cual se generan las partículas. shape: Indica la forma de la región. Puede tener los valores siguientes: ps_shape_rectangle ps_shape_ellipse ps_shape_diamond ps_shape_line distribution: indica la distribución usada para generar las partículas. Puede tener los valores siguientes: ps_distr_linear Indica una distribución lineal, de que está por todas partes en la región que la ocasión es igual. ps_distr_gaussian Indica una distribución gaussian en la cual más partículas se generen en el centro que en los lados de la región. particle type: Indica el tipo de partículas que son generadas number: Indica el número de las partículas generadas en cada paso. Si más pequeño de 0, en cada paso una partícula se genera con una ocasión -1/number, por ejemplo con un valor de -5 una partícula se genera en promedio una vez cada 5 pasos. Las funciones siguientes están disponibles para fijar los emisores y los dejan crear partículas . Observa que cada uno de ellas consigue el índice del sistema de la partícula a el cual pertenece como primera discusión. part_emitter_create (ps): Crea un emisor nuevo en el sistema dado de la partícula. Devuelve el índice del emisor. Este índice se debe utilizar en todas las llamadas abajo para fijar las características del emisor. part_emitter_destroy (ps, ind): Destruye el ind del emisor en el sistema de la partícula. Llama esta función si tú no lo vas necesitar más, ahorrar espacio en la memoria. part_emitter_destroy_all (ps): Destruye todos los emisores en el sistema de la partícula se han creado que. part_emitter_exists (ps, ind): Devuelve si el emisor indicado existe en el sistema de la partícula. part_emitter_clear (ps, ind): Despeja el ind del emisor a sus ajustes de defecto. part_emitter_region (ps, ind, xmin, xmax, ymin, ymax, shape, distribution) Fija la región y la distribución para el emisor. part_emitter_burst (ps, ind, parttype, number): Estalla una vez que las partículas del número del tipo indicado del emisor. part_emitter_stream (ps, ind, parttype, number): A partir de este momento encendido cree las partículas del número del tipo indicado del emisor en cada paso. Si tú indicas un número más pequeño de 0 en cada paso una partícula se genera con una ocasión de -1/number. Tan por ejemplo con un valor de -5 una partícula se genera en una vez cada 5 pasos. 60.8.- Attractors (Atractores): Además de los emisores un sistema de la partícula puede también contener atractores. Un atractor atrae las partículas (o las empuja lejos). Un sistema de la partícula puede tener atractores múltiples. Le recomiendan sin embargo para utilizar pocos de éstos porque retrasarán el proceso de las partículas. Un atractor tiene las características siguientes: x, y: Indican la posición del atractor force: Indica la fuerza de atracción del atractor. Cómo los actos de la fuerza en las partículas dependen de los parámetros siguientes. dist: Indica la distancia máxima en la cual el atractor tiene efecto. Solamente partículas más cercanas que esta distancia al atractor será atraída. kind: La clase indica la clase de atractor. Los valores siguientes existen ps_force_constant indica la fuerza constante independiente a la distancia. 157
- 158. ps_force_linear indica una fuerza linear cada vez mayor. En la distancia máxima la fuerza es 0 mientras que en la posición del atractor logra el valor dado. ps_force_quadratic indica que la fuerza crece cuadrática. additive: Indica si la fuerza está agregada a la velocidad y a la dirección en cada paso (verdad) o aplicada solamente a la posición de la partícula (falsa). Cuando añadido que la voluntad de la partícula acelera hacia el atractor mientras que con una fuerza non-additive se moverá allí con velocidad constante. Las funciones siguientes existen para definir attractors. Observe que cada uno de ellas consigue el índice del sistema de la partícula a el cual pertenece como primera discusión. part_attractor_create (ps): Crea un atractor nuevo en el sistema dado de la partícula. Devuelve el índice del atractor. Este índice se debe utilizar en todas las llamadas abajo para fijar las características del emisor. part_attractor_destroy (ps, ind): Destruye el ind del atractor en el sistema de la partícula. part_attractor_destroy_all (ps): Destruye todos los attractors en el sistema de la partícula se han creado que. part_attractor_exists (ps, ind): Devuelve si el atractor indicado existe en el sistema de la partícula. part_attractor_clear (ps, ind): Limpia el ind del atractor a sus ajustes de defecto. part_attractor_position (ps, ind, x, y): Fija las posición del atractor ind (x, y) part_attractor_force (ps, ind, force, dist, kind, aditive): Fija los parámetros de fuerza del atractor ind. 60.9.- Destroyers (Destructores): Los destructores destruyen partículas cuando aparecen en su región. Un sistema de la partícula puede tener un número arbitrario de destructores. Un destructor tiene las características siguientes: xmin, xmax, ymin, ymax: Indican el grado de la región en la cual se destruyen las partículas. shape: Indica la forma de la región. Puede tener los valores siguientes: ps_shape_rectangle ps_shape_ellipse ps_shape_diamond Las funciones siguientes están disponibles para fijar las características de los destructores. Observe que cada uno de ellas consigue el índice del sistema de la partícula a el cual pertenece como primera discusión. part_destroyer_create (ps): Crea un destructor nuevo en el sistema dado de la partícula. Devuelve el índice del destructor. Este índice se debe utilizar en todas las llamadas abajo para fijar las características del destructor. part_destroyer_destroy (ps, ind): Destruye el ind del destructor en el sistema de la partícula. part_destroyer_destroy_all (ps): Destruye todos los destructores en el sistema de la partícula que se han creado. part_destroyer_exists (ps, ind): Devuelve si el destructor indicado existe en el sistema de la partícula. part_destroyer_clear (ps, ind): Limpia el ind del destructor a sus ajustes de defecto. part_destroyer_region (ps, ind, xmin, xmax, ymin, ymax, shape): Fija la región para el destructor. 60.10.- Deflectors (Deflectores): Las desviaciones desvían partículas cuando aparecen en su región. Observe que solamente la posición de la partícula considerado no su sprite o clasifíquelo. Un sistema de la partícula puede tener un número arbitrario de desviaciones. Una desviación tiene las características siguientes: xmin, xmax, ymin, ymax: Indican el grado de la región en la cual se desvían las partículas. kind: indica la clase de desviación. Puede tener los valores siguientes: ps_deflect_horizontal: desvía la partícula horizontalmente; utilizado típicamente para las paredes verticales ps_deflect_vertical: desvía la partícula verticalmente; utilizado típicamente para las paredes horizontales friction: la cantidad de fricciones el resultado del impacto con un reflector. A mayor cantidad más partículas bajan velocidad en el impacto. Las funciones siguientes están disponibles para fijar las características d e la desviación. Observar que cada una de ellas consigue el índice de los Sistemas de Partículas (particle system) a la cual pertenece como primera discusión. 158
- 159. part_deflector_create (ps): Crea un Nuevo reflector en un sistema de partículas. Devuelve e l índice de la desviación. Este índice se debe utilizar en todas las llamadas abajo para fijar las características de la desviación. part_deflector_destroy (ps, ind): Destruye el ind del reflector en el sistema de partículas. part_deflector_destroy_all (ps): Destruye todos los reflectors que han sido creados en el sistema de partículas. part_deflector_exists (ps, ind): Devuelve si el reflector existe en el sistema de partículas. part_deflector_clear (ps, ind): Despeja el ind del reflector a sus ajustes de defecto. part_deflector_region (ps, ind, xmin, xmax, ymin, ymax): Fija la región para el deflector. part_deflector_kind (ps, ind, kind): Fija el tipo para el deflector. part_deflector_friction (ps, ind, friction): Fija la fricción para el deflector. 60.11.- Changers (Cambi adores): Los cambiadores cambian ciertas partículas cuando aparecen en su región. Un sistema de la partícula puede tener un número arbitrario de cambiadores. Un cambiador tiene las características siguientes: xmin, xmax, ymin, ymax: Indican el grado de la región en la cual se cambian las partículas. shape: Indica la forma de la región. Puede tener los valores siguientes: ps_shape_rectangle ps_shape_ellipse ps_shape_diamond parttype1: Indica el tipo de la partícula se que cambia. parttype2: Indica el tipo de la partícula al cual se cambia. kind: Indica la clase de cambiador. Puede tener los valores siguientes: ps_change_motion cambia solamente los parámetros del movimiento del color y de la forma o del curso de la vida de los ajustes de la partícula ps_change_shape cambia solamente los parámetros de la forma como tamaño y color y forma ps_change_all cambia todos los parámetros, éste básicamente los medios que la partícula está destruida y un nuevo del nuevo tipo está creado. Las funciones siguientes están disponibles para fijar las características del cambiador. Observe que cada uno de ellas consigue el índice del sistema de la partícula a el cual pertenece como primera discusión. part_changer_create (ps): Crea un cambiador nuevo en el sistema dado de la partícula. Devuelve el índice del cambiador. Este índice se debe utilizar en todas las llamadas abajo para fijar las características del cambiador. part_changer_destroy (ps, ind): Destruye el ind del cambiador en el sistema de la partícula. part_changer_destroy_all (ps): Destruye todos los cambiadores en el sistema de la partícula se han creado que. part_changer_exists (ps, ind): Devuelve si el cambiador indicado existe en el sistema de la partícula. part_changer_clear (ps, ind): Despeja el ind del cambiador a sus ajustes de defecto. part_changer_region (ps, ind, xmin, xmax, ymin, ymax, shape): Fija la región para el cambiador. part_changer_types (ps, ind, parttype1, parttype2): Fija que el tipo de la partícula la necesid ad del cambiador cambió en lo que el otro tipo. part_changer_kind (ps, ind, kind): Fija el tipo de cambiador. 60.12.- Firework Example (Ejempl o de fuegos artificiales): Aquí está un ejemplo de un sistema de la partícula que crea los fuegos artificiales. El fuego artificial utiliza dos tipos de la partícula: uno que forma el cohete y uno que forma los fuegos artificiales reales. El cohete genera las partículas del fuego artificial cuando muere. También generamos un emisor en el sistema de la partícula que fluye regularmente fuera de las partículas del cohete a lo largo del fondo de la pantalla. Para hacerle este trabajo necesite un objeto. En su acontecimiento de la creación ponemos el código siguiente que crea los tipos de la partícula, el sistema de la partícula, y el emisor: // Hace el sistema de partículas ps = part_system_create(); // Las partículas del fuego artificial pt1 = part_type_create(); part_type_shape(pt1,pt_shape_flare); part_type_size(pt1,0.1,0.2,0,0); part_type_speed(pt1,0.5,4,0,0); part_type_direction(pt1,0,360,0,0); 159
- 160. part_type_color1(pt1,c_red); part_type_alpha2(pt1,1,0.4); part_type_life(pt1,20,30); part_type_gravity(pt1,0.2,270); // El cohete pt2 = part_type_create(); part_type_shape(pt2,pt_shape_sphere); part_type_size(pt2,0.2,0.2,0,0); part_type_speed(pt2,10,14,0,0); part_type_direction(pt2,80,100,0,0); part_type_color2(pt2,c_white,c_gray); part_type_life(pt2,30,60); part_type_gravity(pt2,0.2,270); part_type_death(pt2,150,pt1); // crea la muerte del fuego artificial // Crea el emisor em = part_emitter_create(ps); part_emitter_region(ps,em,100,540,480,490,ps_shape_rectangle,ps_distr_linear); part_emitter_stream(ps,em,pt2,-4); // crea uno cada 4 pasos } Recuerda que lo que esta en verde es solo un comentario y no realiza ninguna función. El sistema operativo hará el truco. Tu puedes ser que desee cerciorarse de que el sistema de la partícula (y quizá los tipos de la partícula) estén destruidos al moverse a otro sitio, si no el fuego artificial que continúen por siempre. 61.- Juegos Multijugador: Esta funcionalidad está solamente disponible en la versión registrada del Game Maker. Jugar juegos contra el ordenador es divertido. Pero jugar contra otros jugadores humanos puede resultar mucho más divertido. Esto no necesariamente hace que el juego sea más difícil de crear, ya que te evitas el problema de hacer complicadas IA (Inteligencia Artificial). Puedes hacer juegos multijugador en el mismo monitor y con el mismo teclado. Pero es mucho más interesante cuando cada uno está en su propia computadora. O mejor aún, cuando el otro está a miles de kilómetros. Por favor, ten en cuenta que hacer juegos con buena sincronización y sin delay no es una tarea fácil. Este capítulo te da una descripción con las posibilidades del Game M aker Información sobre juegos multijugador puede ser encontrada en los siguientes capítulos: 61.1.- Configurando la conexi ón: Para que dos computadoras se comuniquen entre ellas, debe haber un protocolo de conexión. Como en la mayoría de los juegos, Game M aker te ofrece cuatro tipos diferentes de conexión: IPX, TCP/IP, Modem, y Serial. La conexión IPX (Para ser más precisos, el protocolo) es prácticamente transparente. Puede ser usado para jugar juegos con otras personas en la Red de Area Local (LAN/Local Area Network). Requiere estar instalado en la PC para usarlo (Si no funciona consulte la ayuda de Windows). TCP/IP es el protocolo de Internet. Puede ser usado para jugar con cualquier persona entre todo el Internet, suponiendo que conoces su dirección de IP. En la red de area local, puedes usar TCP/IP sin indicar un IP, Una conexión por modem, se realiza a través del modem. Debes especificar algunos datos del modem (La cadena de inicialización y el número de teléfono) para usarlo. Finalmente, cuando se usa serial (conexión directa entre las computadoras), debes proveer algunos datos de los puertos. Hay cuatro funciones en GM L que pueden ser usadas para establecer estas conexiones: mplay_init_ipx (): Inicializa conexión IPX. mplay_init_tcpip (addr): Inicializa conexión TCP/IP, add es un string (texto) que contiene la dirección Web o la dirección IP, por ejemplo: "www.geantgames.com" o "123.123.321.12", Posiblemente seguido por el puerto, como por ejemplo: "123.123.321.12:12". Solamente cuando te unís a una sesión (ver debajo) necesitas especificar el IP. En Red de Area Local (LAN/Local Area Network) no es necesario especificar el IP. mplay_init_modem (initstr, phonenr): Inicializa conexión por M ODEM , initstr es la cadena de inicialización del modem (puede ser una cadena vacía), phoenr es una cadena que contiene el número de teléfono, por ejemplo "0201234567". Solo cuando te unís a una sesión debes especificar el número de teléfono. mplay_init_serial (portno, transnum, bits, paridad, flujo): inicializa un conexión serial, portno es el número de puerto (1-4), transnum es el número de transiciones por segundo del modem a ser utilizado (100-256K), bits indica el número de bits utilizados para indicar el fin de un byte (0 = 1 bit, 1 = 1.5 bit, 2 = 2 bits), paridad indica la paridad (0=ninguna, 1=impar, 2=par, 3=paridad marcada(el bit de paridad es siempre 1)). Y flujo indica el tipo de control de flujo (0=ninguno, 1= xon/xoff, 2=rts, 3=dtr, 4=rts y dtr). Regresa si se tuvo éxito. Una llamada típica es mplay_init_serial(1,57600,0,0,4). Proporciona 0 como un primer argumento para abrir un diálogo para que el usuario escoja la configuración. 160
- 161. Tu juego debería llamar una de estas funciones exactamente una sola vez. Todas las funciones retornan si la conexión fue exitosa. Una razón porque no sea exitosa puede ser que el protocolo indicado no está instalado, o la máquina no lo soporta. Para saber en cualquier momento, si todavía hay conexión, puede usar la siguiente función: mplay_connect_status (): Devuelve el estado de la conexión actual. 0 = sin conexión, 1 = IPX, 2 = TCP/IP, 3 = modem , and 4 = serial. Para finalizar una conexión utilice: mplay_end (): Finaliza la conexión actual. Cuando uses TCP/IP necesitarás saber la dirección IP del que creó la sesión. Para esto, existe la siguiente función: mplay_ipaddress (): Devuelve la dirección IP del usuario (por ejemplo "123.123.123.12") como cadena/texto. Esta función no es muy rápida, por lo tanto no la uses constantemente. 61.2.- Creación y uni ón de sesiones: Cuando te conectas a la red, puede haber diferentes juegos siendo ejecutados en la misma red. Esto se llama sesiones. Estas diferentes sesiones pueden corresponder a distintos juegos, o al mismo juego. Cada juego debe poseer una identidad única en toda la red. Por suerte, Game M aker hace esto por vos. Lo único que debes hacer es modificar el game id en las opciones cuando haya algún cambio. Con esto te aseguras de que personas con versiones viejas no jueguen con personas con versiones nuevas. Si deseas crear un juego multijugador necesitarás crear una nueva sesión. Para esto usted puede usar la siguiente función: mplay_session_create (sesname, playnumb, playername): Crea una nueva sesión en la conexión actual, sesname es una cadena que indica el nombre de la sesión, playnumb es un número que indica la máxima cantidad de jugadores permitidos en el juego (use 0 si no desea límite), playname es tu nombre como jugador. La función devuelve si la sesión fue creada correctamente (true) o no(false). Una instancia del juego debe crear la sesión. Otra instancia debería ser para unirse a la sesión. Unirse es más complicado que crearla. Primero debes buscar que sesiones están disponibles, y luego elegir a cual unirse. Hay 3 funciones importantes para esto: mplay_session_find (): Busca todas las sesiones creadas que todavía acepten jugadores, y retorna la cantidad de sesiones encontradas. mplay_session_name (numb): Devuelve el número de la sesión (0 es la primer sesión). mplay_session_join (numb, playername): Hace que se una a la sesión especificada por numb (0 es la primer sesión), playername es tu nombre como jugador. Devuelve si se unió exitosamente. Hay una función más que puede cambiar el modo de la sesión. Debería ser llamada antes de crear una sesión: mplay_session_mode (move): Fija si cambiar el host(IP que creó la partida) a otro host cuando el host original se desconecte. Para comprobar el estado de la sesión actual, puede usar la siguiente función: mplay_session_status (): Devuelve el estado de la sesión actual. 0 = no hay sesión, 1 = sesión creada, 2 = sesión unida. Un jugador puede desconectarse de la sesión usando la siguiente función: mplay_session_end (): Finaliza la sesión para este jugador. 61.3.- Jugadores: Cada instancia del juego que se unió a la sesión es un jugador. Como se indicó anteriormente, jugadores poseen nombres. Estas 3 funciones tratan con jugadores: mplay_player_find (): Busca todos los jugadores en la sesión actual, y devuelve la cantidad de jugadores encontrados. mplay_player_name (numb): Devuelve el nombre del jugador con el número especificado (0 es el primer jugador, que siempre eres tú mismo). Esta función puede ser solamente llamada luego de llamar la función anterior. mplay_player_id (numb): Devuelve el id único del jugador con el número especificado (0 es el primer jugador, que siempre eres tú mismo). El id es útil para enviar y recibir mensajes de solamente un jugador. 161
- 162. 61.4.- Datos Comparti dos: Comunicación por datos compartidos es probablemente la forma más fácil de sincronizar el juego. Toda la comunicación depende de usted. Hay una serie de 1000000 entidades donde puedes guardar datos (Úselos en orden, o sea, no use el número 10 si no usó el 9, para guardar memoria). Cada ent idad puede fijar valores y leer valores. Un valor puede ser un número real o un string/cadena/texto. Hay solamente dos funciones para esto: mplay_data_write (ind, val): Escribe el valor val (string o real) en la entidad ind (ind entre 0 y 1000000). mplay_data_read (ind): Devuelve el valor en la entidad ind (ind entre 0 y 1000000). Para sincronizar los datos en las diferentes máquinas, puedes usar modo asegurado (guaranteed) que te asegura que los cambios lleguen en la otra máquina, (pero es lento) o no-asegurado (non-guaranteed). Para cambiar este modo utilice la siguiente función: mplay_data_mode (guar): Fija si usar modo guaranteed para la transmisión de datos compartidos. 61.5.- Mensajes: El segundo mecanismo de comunicación que Game M aker soport a es enviando y recibiendo los mensajes. Un jugador puede enviar mensajes a un jugador específico (por ejemplo un objeto que le vendió), o puede enviar el mensaje a todos los jugadores (por ejemplo un mensaje de texto, chat). Los jugadores pueden ver si les llegó un mensaje y tomar una decisión. M ensajes pueden ser enviados en modo asegurado que te asegura que el mensaje llega (pero esto puede resultar lento) o en modo no-asegurado, el cual es más rápido. Las siguientes funciones existen: mplay_message_send (player, id, val): Envía un mensaje al jugador especificado, puede ser el id único o su nombre. Use 0 para enviarles el mensaje a todos los jugadores, id es el id del mensaje, el que se usará en otras funciones, val es el valor del mensaje, puede ser un valor real o string. Lo envía en modo no asegurado. Nota: No se pueden enviar strings con más de 30000 letras. mplay_message_send_guaranteed (player, id, val): Envía un mensaje al jugador especificado, puede ser el id único o su nombre. Use 0 para enviarles el mensaje a todos los jugadores, id es el id del mensaje, el que se usará en otras funciones, val es el valor del mensaje, puede ser un valor real o string. Lo envía en modo no asegurado. Nota: No se pueden enviar strings con más de 30000 caracteres incluyendo espacios. mplay_message_receive (player): Recibe el siguiente mensaje de la fila (queue) de mensajes que viene con el jugador indicado (el id o el nombre), usa 0 para recibir el mensaje de cualquier jugador. La función devuelve si había un nuevo mensaje. mplay_message_id (): Devuelve el id del último mensaje recibido. mplay_message_value (): Devuelve el valor del último mensaje recibido. mplay_message_player (): Devuelve el jugador que envió el último mensaje recibido. mplay_message_name (): Devuelve el nombre del jugador que envió el último mensaje recibido. mplay_message_count (player): Devuelve la cantidad de mensajes en la fila de mensajes del jugador especificado (usa 0 para contar todos los mensajes). mplay_message_clear (player): Elimina todos los mensajes en la cola de mensajes del jugador especificado (use 0 para contar todos los mensajes). Algunos puntos hay que tener en cuenta acá. Primero de todo, si quieres enviar un mensaje a jugador en particular, deberás conocer su id único. Como fue indicado anteriormente puedes obtener esto con la función: mplay_player_id (): Este id del jugador puede también ser usado para recibir mensajes de un jugador en particular. Cada mensaje posee un único id porque esto te da más posibilidades en el momento de elegir que mensaje aceptar. 62.- Usando DLL: Estas funciones están solamente disponibles en la versión registrada del Game Maker. En casos donde las funciones de GM L no son suficientes para tu satisfacción, puedes extender las posibilidades usando plug-ins. Un plug-in viene en forma de archivo DLL (Dynamic Link Library) En una DLL puedes definir funciones. Estas funciones pueden ser programadas en cualquier lenguaje que soporte la creación de DLL (como Delphi, C, C++, etc.). Necesitarás tener cierta habilidad de programación para hacer una. Pueden tener entre 0 y 11 argumentos. Pueden ser números reales (double en C) o un string terminado en '0'. Para más de 4 argumentos, solo pueden ser números reales. La función debe devolver un valor real, o un string terminado en '0'. En delphi puedes crear una DLL eligiendo New del menú File menú y luego elegir DLL. Aquí un ejemplo de DLL que puedes usar con Game M aker escrita en Delphi. (Ten en cuenta que es código de Delphi no GM L!) 162
- 163. library MyDLL; uses SysUtils, Classes; function MyM in(x,y:double):double; cdecl; begin if x<y then Result := x else Result := y; end; var res : array[0..1024] of char; function DoubleString(str:PChar):PChar; cdecl; begin StrCopy(res,str); StrCat(res,str); Result := res; end; exports MyM in, DoubleString; begin end. Esta DLL define 2 funciones MyM in que toma 2 argumentos reales y devuelve el mínimo de los 2. Y DoubleString que dobla el string. Tenga en cuenta tener cuidado con como trata la memoria. management . Una vez que construyas la DLL en Delphi obtendrás un archivo llamado M yDLL.DLL. Este archivó debe ponerse en el directorio donde se ejecuta el juego. O en cualquier otro lugar donde Windows pueda encontrarlo. Para usar la DLL en Game M aker primero debes especificar la función externa que desees usar con los argumentos que desees tomar. Para esto existen las siguientes funciones en GM L: external_define (dll, name, calltype, restype, argnumb, arg1type, arg2type, ...): Define una función externa, dll es el nombre de la dll, name es el nombre de la función, calltype es el modo de llamado usado, usa dll_cdecl o dll_stdall restype es el tipo de dato devuelvo, use ty_real o ty_string, argnumb es la cantidad de argumentos que posee la función. Los demás argumentos son los tipos de datos usados para cada argumento en la función, use ty_real o ty_string Esta función retorna el id de la función externa, que debe ser usada para llamarla. Entonces, suponiendo el ejemplo de DLL mencionado anteriormente, podrías usar el siguiente código GM L: { global.mmm = external_define('M YOW N.DLL','MyMin',dll_cdecl, ty_real,2,ty_real,ty_real); global.ddd = external_define('M YOW N.DLL','DoubleString',dll_cdecl, ty_string,1,ty_string); } Ahora, cuando quieras llamar las funciones, usas la siguiente función: external_call (id, arg1, arg2,...): Llama la función externa con el id dado, y con los argumentos dados. Debes pasar la correcta cantidad de argumentos y el correcto tipo de argumento (real o string). La función devuelve lo que devuelve la función de la DLL. Entonces, por ejemplo, podrías escribir: { aaa = external_call(global.mmm,x,y); sss = external_call(global.ddd, "Ho la"); } Si no necesitas usar más la DLL, deberías liberarla de la memoria, la siguiente función te permite esto: external_free (dll): Libera de la memoria la DLL con el nombre dado. A veces puedes querer hacer una DLL que haga algo específico en el juego. Como hacer una DLL que agrega instancias u objetos en tu juego. La manera más fácil sería hacer que la DLL retorne un string que contenga el código de GM L para lograr esto. El string puede ser ejecutado usando la siguiente función: execute_string (str): Ejecuta el código en el string str. 163
- 164. También podrías hacer que la DLL cree un archivo con el script que debe ejecutar: execute_file (fname): Ejecuta el código en el archivo. Ahora puedes llamar una función externa y ejecutar el string resultante, por ejemplo, así: { ccc = external_call(global.ddd,x,y); execute_string(ccc); } En algunos casos neces ites saber el handle de los gráficos de la ventana. Esto se puede obtener usando la siguiente función, y pasarlo de dato a la DLL: window_handle (): Devuelve el handle de la ventana. Ten en cuenta que las DLL no pueden ser usadas en modo seguro. Usar DLLs en un mecanismo muy poderoso. Pero por favor, solo úsalo, si sabes lo que está haciendo. 63.- Grafic 3D (Gráficos 3D): Esta funcionalidad está solamente disponible en la versión registrada del Game Maker. Game M aker es un programa dirigido para hacer juegos en 2 dimensiones y juegos isométricos. Sin embargo hay algunas funciones para crear juegos en 3 dimensiones. Antes de empezar con esto, hay algunas cosas que debes entender al respecto: Las funcionalidades en Game M aker está limitada a la parte gráfica. No hay ninguna otra ayuda para 3D. Cuando empieces el modo 3D puedes tener problemas con las views, el depth, etc. Esto es porque está limitado a la parte gráfica. Cuando uses las funciones en 3D, hay ciertos aspectos que no pueden ser usados más No puedes más usar background ni foregrounds en tus rooms. No puedes usar la posición del mouse. La posición del mouse no será transformada a coordenadas 3D. Seguirás obteniendo su posición en la pantalla, y no en el juego. Pero puedes hacer el cálculo vos mismo, o directamente no usar el mouse. No puedes más usar tiles. Comprobar colisiones está solo disponible para las coordenadas 2D. Por lo tanto deberás hacer tus propias funciones para comprobar las colisiones. Todas las funciones en 3D son a través de código. Por lo tanto debes conocer muy bien el GM L. También debes entender muy bien como el Game M aker funciona o tendrás muchos problemas. Debes tener algunos conocimientos sobre las básicas de los gráficos 3D. En particular como perspectiva, proyección, luz, niebla, etc. No hay ninguna posibilidad de usar modelos hechos con programas externos, y no se planea agregar en futuras versiones. Debes ser muy cuidadoso con la velocidad. También debes tener en cuenta que no está totalmente optimizado. Si esto no te asusta, puedes seguir. Información en gráficos 3D puede ser encontrado en las siguientes páginas: 63.1.- Iniciando en 3D: Si quieres usar el modo 3D, primero necesitas inicializar el modo 3D en Game M aker. Puedes, luego, volver a modo 2D si así lo deseas. Las siguientes funciones existen para esto: d3d_start (): Inicia el modo 3D. d3d_end (): Termina el modo 3D. Nota: Todas las funciones referidas a 3D, empiezan con d3d_. Iniciar el mod 3D hará lo siguiente. Primero de todo, las superficie (surface)s superficiales son ocultadas. Esto significa que por cada píxel en la pantalla, solo dibuja el que posea el menor valor z (valor de profundidad). Si las instancias tienen el mismo depth, no sabes lo que puede pasar, y es posible que pasen cosas no deseadas. Esté seguro de que las instancias que pueden estar superpuestas no tengan el mismo depth (profundidad). 164
- 165. En segundo lugar, la proyección ortogonal es reemplazada por una proyección de perspectiva. Esto significa lo siguiente. Normalmente el tamaño de las instancias en la pantalla, es independiente de su depth(profundidad). Con una proyección en perspectiva las instancias que tengan un mayor depth, se verán más pequeñas. El punto de donde se ve para la cámara es colocada a una distancia sobre el room. Solo instancias frente a la cámara son dibujadas. Entonces, no uses instancias con un depth menor a 0. Por último, la coordenada y vertical es revertida. Normalmente el punto (0,0) es la esquina superior izquierda en 3D, el punto (0,0) es la esquina inferior izquierda. Puedes elegir si ocultar la superficie (surface), con las siguientes funciones. d3d_set_hidden (enable): Habilita las superficie (surface)s escondidas (false) o las deshabilita (true). d3d_set_perspective (enable): Habilita la proyección en perspectiva (true) o la deshabilita (false). 63.2.- Fácil Di bujado: Una vez que el modo 3D ha sido iniciado, puedes usar el Game M aker como estás acostumbrado a hacerlo Solo objetos aparecerán en distintos tamaños, basado en su depth (profundidad). Puedes, incluso, usar vistas. Una función adicional puede ser útil. Si dibujas muchas cosas en un código, puedes querer modificar el valor de depth de lo que dibujas. Para esto, usa lo siguiente: d3d_set_depth (depth): Especifica la profundidad usada para dibujar. Nota: Al momento que una nueva instancia es dibujada, el depth es vuelto a su depth real. 63.3.- Di bujando polígonos en 3D: El problema de dibujar de la manera antigua, es que el sprite o el polígono se basan en el plano x-y todas las esquinas poseen el mismo depth. Para hacer un 3D verdadero debes poder modificar el depth de los vértices. Desde este momento, hablaremos de la coordenada z, en vez del depth. Entonces las coordenadas que usaremos son (x, y, z). Para estas coordenadas hay una serie de funciones para dibujar: d3d_color primario _begin (kind): Comienza un color primario 3D con el tipo indicado: pr_pointlist, pr_linelist, pr_linestrip,pr_trianglelist,pr_trianglestrip o pr_trianglefan. d3d_vertex (x, y, z): Agrega un vértice (x, y, z) al color primario. d3d_vertex_color (x, y, z, col, alpha): Agrega un vértice (x, y, z) al color primario, con el color y alpha especificado. d3d_color primario _end (): Termina el color primario, en otras palabras, lo dibujar. Por ejemplo, para dibujar un tetraedro, podemos usar el siguiente código: { d3d_color primario _begin(pr_trianglelist); d 3d_vertex(100,100,0); d 3d_vertex(100,200,0); d 3d_vertex(150,150,200); d 3d_vertex(100,200,0); d 3d_vertex(200,200,0); d 3d_vertex(150,150,200); d 3d_vertex(200,200,0); d 3d_vertex(100,100,0); d 3d_vertex(150,150,200); d 3d_vertex(100,100,0); d 3d_vertex(100,200,0); d 3d_vertex(200,200,0); d3d_color primario _end(); } Si lo usas, seguro que verás un triángulo en la pantalla, porque la parte superior del tetraedro no será visible porque estará detrás del punto de la vista. Después veremos métodos para cambiar de lugar el punto de proyección. También puedes usar polígonos texturados en 3D. Funciona exactamente igual que como se describió en "Funciones Avanzadas De Dibujo". Pero esta vez, tendrás las variantes 3D. d3d_color primario _begin_texture (kind, texid): Empieza a dibujar un color primario 3D con el tipo y textura indicada. 165
- 166. d3d_vertex_texture (x, y, z, xtex, ytex): Agrega un vértice (x, y, z) al color primario con la posición (xtex, ytex) en la textura. d3d_vertex_texture_color (x, y, z, xtex, ytex, col , alpha): Como antes, solo que con color y alpha (luminosidad/transparencia) especificados. d3d_color primario _end (): Llama esta función cuando termines de agregar los vértices deseados, para dibujar el color primario. Entonces, por ejemplo puedes usar el siguiente código para dibujar un background que desaparece en la distancia. { var ttt; ttt = background_get_texture(back); d3d_color primario _begin_texture(pr_trianglefan,ttt); d 3d_vertex_texture(0,480,0,0,0); d 3d_vertex_texture(640,480,0,1,0); d 3d_vertex_texture(640,480,1000,1,1); d 3d_vertex_texture(0,480,1000,0,1); d3d_color primario _end(); } Un triángulo tiene una parte frontal y una parte detrás. El frente es lo que deberías ver, si la proyección lo permite. En caso que desees ver la parte de atrás, puedes usar la siguiente función. Ten en cuenta que si se ve la parte de atrás, es más rápido, porque cuando lo dibuja, no pierde tiempo escondiéndolo. d3d_set_culling (cull): Indica si ver la parte de atrás (true) o no (false). 63.4.- Di bujando formas básicas: Una serie de funciones existen para dibujar formas básicas en 3D, como cubos, paredes, cilindros, etc. d3d_draw_block (x1, y1, z1, x2, y2, z2, texid, hrepeat, vrepeat): Dibuja un bloque con los vértices indicados, y la textura indicada. Use -1 en la textura si desea que no posea alguna. hrepeat indica que tan seguido la textura se debe repetir a lo largo del eje horizontal, vrepeat lo mismo para el eje vertical. d3d_draw_cylinder (x1, y1, z1, x2, y2, z2, texid, hrepeat, vrepeat, closed, steps): Dibuja un cilindro vertical en la posición indicada, usando la textura indicada. Use -1 si no desea usar textura, hrepeat indica que tan seguido la textura se debe repetir a lo largo del eje horizontal, vrepeat lo mismo para el eje vertical, closed indica si cerrar la parte superior e inferior del cilindro, steps indica cuantos steps deben tomarse en la rotación, un valor normal es 24. d3d_draw_ellipsoid (x1, y1, z1, x2, y2, z2, texid, hrepeat, vrepeat, steps): Dibuja un elipsoide, con la posición y textura indicadas. Si no desea usar textura, ponga el valor -1, hrepeat indica que tan seguido la textura se debe repetir a lo largo del eje horizontal, vrepeat lo mismo para el eje vertical, steps indica cuantos steps de rotación se deben tomar. Un valor común es 24. d3d_draw_wall (x1, y1, z1, x2, y2, z2, texid, hrepeat, vrepeat): Dibuja una pared con la posición especificada, usando la textura indicada.Si no desea usar textura, ponga el valor -1, hrepeat indica que tan seguido la textura se debe repetir a lo largo del eje horizontal, vrepeat lo mismo para el eje vertical. d3d_draw_floor (x1, y1, z1, x2, y2, z2, texid, hrepeat, vrepeat): Dibuja el piso con la posición dada. Si no desea usar textura, ponga el valor -1, hrepeat indica que tan seguido la textura se debe repetir a lo largo del eje horizontal, vrepeat lo mismo para el eje vertical. El siguiente código dibuja 2 bloques: { var ttt; ttt = background_get_texture(back); d3d_draw_block(20,20,20,80,40,200,ttt,1,1); d3d_draw_block(200,300,-10,240,340,100,ttt,1,1); } 63.5.- Proyección: Supongamos que la proyección es lo que una cámara está filmando, la cámara estará en una posición (desde donde filma). Y filmará hacia una posición, y esto que la cámara está "film ando" es lo que el jugador verá en la pantalla. Hay funciones para modificar los aspectos de la proyección: d3d_set_projection (xfrom, yfrom, zfrom, xto, yto, zto, xup, yup, zup): Define como la proyección se debe hacer. 166
- 167. Piensen en esta función como una cámara: xfrom es el x inicial (el x donde se encuentra la cámara) yfrom es el y inicial (el y donde se encuentra la cámara) zfrom es el z inicial (el z donde se encuentra la cámara) xto es el x final (el x hacia donde mira la cámara) yto es el y final (el y hacia donde mira la cámara) zto es el z final (el z hacia donde mira la cámara) xup, yup y zup son valores para rotar la cámara en la linea que forma la cámara desde su posición inicial hasta su posición inicial. Si no lo entiendes muy bien, prueba variando estos valores entre -1 y 1, para ver su efecto. Veamos un ejemplo: { d3d_set_projection(100,100,10,200,100,10,0,0,1); } Con este código, posiciona a la cámara en la posición (100, 100, 10), y la cámara está proyectando ("filmando") a la posición (200, 100, 10). Para hacer esta proyección un poco más complicada (y más útil), supongamos que la misma cámara se puede mover, y la posición de la cámara va a depender de la posición de un objeto. Podríamos usar el siguiente código: { with (obj_camera) d 3d_set_projection(x,y,10, x+cos(direct ion*pi/180),y -sin(direct ion*pi/180),10, 0,0,1); } Esto puede verse complicado, pero en realidad no lo es. Lo que hace es posicionar la cámara en la misma posición del objeto obj_camera, y que la cámara mire hacia donde la dirección del mismo objeto lo indica. Algo importante que remarcar: La cámara lo que hace es DIBUJAR lo que ve, por lo tanto se debe poner en el evento Draw. Hay una función que extiende la anterior: d3d_set_projection_ext (xfrom, yfrom, zfrom, xto, yto, zto, xup, yu p, zup, angle, aspect, znear, zfar): Una función extendida a la anterior, en la que también puedes especificar el ángulo del campo de la vista, el aspecto entre el tamaño horizontal y vertical de la view, y los planos lejanos y cercanos. Si especificas la posición de la cámara, que mire hacia un vector superior, puedes incluso cambiar como la lente de la cámara está posicionada. Esto es llamado el campo de la vista (view field). Un valor razonable es 45 grados, pero puedes ponerlo a tu gusto. Lo siguiente es el aspecto entre el tamaño horizontal y vertical de la view, normalmente querrás ponerlo igual que el tamaño de la view o el room. Por ejemplo, 640/480. Finalmente znear y zfar. Objetos que se encuentren cercanos a znear no serán dibujados por la cámara. Y objetos que se encuentren más lejos que zfar tampoco serán dibujados. Es importante que si usas esta función, pongas valores muy razonables, en caso contrario no será muy real. Si no sabes bien que valores poner, usa la función anterior que te da estos valores por defecto. Nota: znear debe ser mayor que 0! A veces, necesitas temporalmente una proyección ortogonal. Por ejemplo, para dibujar la mira en un juego de primera persona, o para dibujar un texto 2D, una barra de vida, etc. Para esto existe la siguiente función: d3d_set_projection_ortho (x, y, w, h, angle): M odifica la proyección en perspectiva, a la proyección ortogonal, con los datos dados. Un uso común de esto, aparte de los ya mencionados, es dibujar el puntaje. Para esto tenemos que ir a una proyección ortográfica. También debemos cancelar las superficie (surfaces) escondidas para que el texto se vea. El siguiente ejemplo dibuja el puntaje: { draw_set_color(c_black); d3d_set_projection_ortho(0,0,room_ width,roo m_height,0); d3d_set_hidden(false); draw_text(10,10,'Score: ' + string(score)); d3d_set_hidden(true); } 63.6.- Transformaci ones: Las transformaciones te dan la posibilidad de modificar la forma en que todo es dibujado. Por ejemplo, si quieres dibujar un cubo rotado, primero debes transformarlo. Hay 2 tipos de funciones para esto: Funciones para iniciar una transformación, y funciones para agregar transformaciones: 167
- 168. d3d_transform_set_identity (): Fija la transformación a la identidad (ninguna transformación). d3d_transform_set_translation (xt, yt, zt): Fija la transformación a un excedente de la translación en el vector indicado. d3d_transform_set_scaling (xs, ys, zs): Fija la transformación a una escala con las cantidades indicadas. d3d_transform_set_rotation_x (angle): Fija la transformación a una rotación alrededor del eje-x con la cantidad indicada. d3d_transform_set_rotation_y (angle): Fija la transformación a una rotación alrededor del eje-y con la cantidad indicada. d3d_transform_set_rotation_z (angle): Fija la transformación a una rotación alrededor del eje-z con la cantidad indicada. d3d_transform_set_rotation_axis (xa, ya, za, angle): Fija la transformación a una rotación alrededor del eje indicado por el vector indicado, con la cantidad indicada. d3d_transform_add_translation (xt, yt, zt): Agrega un excedente de la translación en el vector indicado. d3d_transform_add_scaling (xs, ys, zs): Agrega escala con la cantidad especificada. d3d_transform_add_rotation_x (angle): Agrega una rotación alrededor del eje x con la cantidad especificada. d3d_transform_add_rotation_y (angle): Agrega una rotación alrededor del eje y con la cantidad especificada. d3d_transform_add_rotation_z (angle): Agrega una rotación alrededor del eje z con la cantidad especificada. d3d_transform_add_rotation_axis (xa, ya, za, angle): Agrega una rotación alrededor del eje indicado por el vector indicado, con la cantidad indicada. Tenga en cuenta que la rotación y la escala es respecto al origen del mundo, no respecto al objeto que es dibujado. Si el objeto no está en el origen será movido a un nuevo lugar cuando le hagas una transformación, que no es lo que queremos. Entonces, por ejemplo, para rotar un objeto sobre su propio eje-x, primero debemos moverlo hasta su origen, luego rotarlo. Finalmente, lo volvemos a su posición original. Para esto son las funciones de agregar transformaciones. El siguiente ejemplo puede explicarlo mejor. Suponemos que tenemos un sprite llamado spr, que queremos que se dibuje en la posición (100, 100, 10). Podemos usar el siguiente código: { d3d_transform_set_translation(100,100,10); draw_sprite(spr,0,0,0); d3d_transform_set_identity(); } Tenga en cuenta que porque usa la translación, ahora debemos dibujar el sp rite en la posición (0,0). (Esto asume que el depth de la instancia es 0, Si no estás seguro, primero modifícale el depth). Si queremos usarlo en un juego de primera persona, no veremos el sprite. Esto es porque está paralelo al plano x-y. Entonces lo tenemos que rotar 90 grados por el eje-x (o eje-y). Entonces necesitamos agregarle rotación. Recuerde el orden, primero se rota el sprite, luego se traslada, y luego se dibuja. M ire el siguiente ejemplo: { d3d_transform_set_identity(); d3d_transform_add_rotation_x(90); d3d_transform_add_translation(100,100,10); draw_sprite(spr,0,0,0); d3d_transform_set_identity(); } A veces quieres temporalmente guardar la información de la transformación. Por ejemplo para cuando agregas una transformación, volverlo a su estado original. Esto se logra con las siguientes funciones: d3d_transform_stack_clear (): Despeja el stack de transformaciones. d3d_transform_stack_empty (): Devuelve si el stack de transformaciones está vacío. d3d_transform_stack_push (): Guarda la transformación actual en el stack. Devuelve si había lugar para guardarlo, push empuja la transformación actual en el apilado. Devuelve si había sitio en el apilado de empujarlo allí. (Si olvidas eliminar transformaciones del stack, puede pasar que el stack quede sin lugar). d3d_transform_stack_pop (): Elimina (expulsa) la transformación del stack. Devuelve si había transformación o no. d3d_transform_stack_top (): Hace que la transformación en la parte superior sea la actual. Pero no la remueve. Devuelve si había transformación en el stack o no. d3d_transform_stack_discard (): Remueve la transformación en la parte superior, pero no la hace actual. Devuelve si había transformación en el stack o no. Usar transformaciones es un mecanismo potente. Pero ten cuidado, y siempre recuerda volver la transformación a la identidad cuando hayas terminado. 168
- 169. 63.7.- Fog (Niebl a): La Fog (Niebla en español), puede ser usada en juegos 3D, para hacer que los objetos que estén a una mayor distancia se vean más borrosos, o incluso no se vean. Esto ayuda a crear una atmósfera más real, y no dibujar objetos que están muy lejos. Para habilitar y deshabilitar la niebla existe la siguiente función: d3d_set_fog (enable, color, start, end): Habilita o deshabilita el uso de la niebla, color indica el color de la niebla, generalmente querrás usar color negro (c_black), start indica a que distancia la niebla debe empezar, end indica la máxima distancia de la niebla, luego de eso, nada es visible. 63.8.- Lighting (Luz): Cuando dibujas usando las funciones ya mencionadas, se va a ver plano en vez de verse bien en 3D. Esto es porque no hay luz. Para crear escenas más realistas puedes habilitar luces y colocar luces en los lugares adecuados. Debes tener buen sentido de la realidad para hacerlo lo más real posible, colocar bien las luces no es algo fácil, pero el efecto logrado es muy bueno. Para habilitar la luz/lighting puedes usar la siguiente función: d3d_set_lighting (enable): Habilita o deshabilita el uso de luz. Cuando la luz es usada, por cada vértice de un polígono el color es determinado. Luego, el color de los píxeles internos es basado en el color de estos vértices. Hay 2 formas en que se puede hacer esto: O el polígono entero consigue el mismo color, o el color es suavemente interpolado por todo el polígono. Como defecto, esta última posibilidad de sombras suaves (smooth shading) es usado. Para cambiar esto, puede usar la siguiente función: d3d_set_shading (smooth): Fija si se usaran sombras suaves (smooth shading) o no. Para usar luces, obviamente debes definirlas. Existen 2 luces diferentes: luces direccionales (como el sol), y luces posicionales (como una vela). Existen las siguientes funciones para definir luces: d3d_light_define_direction (ind, dx, dy, dz, col) Define una luz direccional, ind es el índice de la luz (use un número pequeño positivo), (dx, dy, dz) es la dirección de la luz, col es el color de la luz (generalmente querrás usar c_white). d3d_light_define_point (ind, x, y, z, range, col): Define luz en un punto, ind es el índice de la luz, (use un número pequeño y positivo), (x, y, z) es la posición de la luz, range indica que tan lejos irá la luz. La intensidad de la luz va a depender de este valor, col es el color de la luz. d3d_light_enable (ind, enable): Habilita o deshabilita la luz especificada con el índice con que fue creada. La manera que un objeto refleja la luz depende del ángulo entre la dirección de la luz y la normal de la superficie. Hay 4 funciones adicionales para definir los vértices de los colores primarios: d3d_vertex_normal (x, y, z, nx, ny, nz): Agrega el vértice (x, y, z) al color primario, con un vector normal (nx, ny, nz). d3d_vertex_normal_color (x, y, z, nx, ny, nz, col, alpha): Como el anterior, pero con color y alpha (luminosidad/transparencia) especificados. d3d_vertex_normal_texture (x, y, z, nx, ny, nz, xtex, ytex): Como el primero, solo que agrega un vértice con textura. d3d_vertex_normal_texture_color (x, y, z, nx, ny, nz, xtex, ytex, col, alpha) Como el anterior, pero con color y alpha (luminosidad/transparencia) especificados. 63.9.- Creando modelos: Cuando necesites dibujar un modelo muy grande, ya sea a base de muchos colores primarios y formas. Dibujar todo puede consumir mucha memoria, para esto existen los modelos. Un modelo consiste en distintos vértices, formas. Una vez que el modelo es creado, puedes simplemente dibujar el modelo, en vez de dibujar todas las formas y color primario. El modelo puede ser cargado en un archivo, y también guardarlos en un archivo. Antes de continuar, hay algo importante que remarcar: El manejo de las texturas. Como se describió en otros capítulos, las texturas son extraídas de los sprites y backgrounds. Los índices de las texturas pueden variar según el tiempo. Como resultado, los modelos no contienen ninguna información sobre las texturas. Por lo tanto, solo puedes usar una sola textura por modelo. Si por alguna razón necesitas usar más de una texturas, puedes combinarlas o usar múltiples modelos. La ventaja de esto, es que puedes dibujar el mismo modelo muchas veces, con distintas texturas. Para crear, cargar, guardar y dibujar modelos, existen las siguientes funciones: d3d_model_create (): Crea un nuevo modelo y devuelve si index. Este index es usado en todas las otras funciones que traten con modelos. d3d_model_destroy (ind): Destruye el modelo con el index dado, liberándolo de la memoria. 169
- 170. d3d_model_clear (ind): Despeja el modelo con el index dado. Nota: no lo elimina, simplemente remueve todos los colores primarios. d3d_model_save (ind, fname): Guarda el modelo indicado en el archivo indicado. d3d_model_load (ind, fname): Carga el modelo indicado en el archivo indicado. d3d_model_draw (ind, x, y, z, texid): Dibuja el modelo en posición (x, y, z), texid es la textura que será usada. Use -1 si no desea textura. Si deseas rotar o escalar el modelo, puedes usar las transformaciones mencionadas anteriormente. Para cada función de color primario, hay una equivalente que hace lo mismo, solo que agrega el color primario a los modelos. Son iguales a los colores primarios 3D, solo que se les agrega un argumento, que es el index del modelo. d3d_model_color primario _begin (ind, kind): Agrega un color primario 3D al modelo, con el tipo (kind) indicado: pr_pointlist, pr_linelist, pr_linestrip,pr_trianglelist,pr_trianglestrip o pr_trianglefan. d3d_model_vertex (ind, x, y, z): Agrega el vértice (x, y, z) al modelo. d3d_model_vertex_color (ind, x, y, z, col, alpha): Como el anterior, solo que con color y alpha (luminosidad/transparencia) especificados. d3d_model_vertex_texture (ind, x, y, z, xtex, ytex): Agrega el vértice (x, y, z) con textura al modelo, con la posición (xtex, ytex) en la textura. d3d_model_vertex_texture_color (ind, x, y, z, xtex, ytex, col, alpha): Como el anterior, solo que con color y alpha (luminosidad/transparencia) especificados. d3d_model_vertex_normal (ind, x, y, z, nx, ny, nz): Agrega el vértice (x, y, z) al modelo, con un vector normal (nx, ny, nz). d3d_model_vertex_normal_color (ind, x, y, z, nx, ny, nz, col, alpha): Como el anterior, pero con color y alpha (luminosidad/transparencia) especificados. d3d_model_vertex_normal_texture (ind, x, y, z, nx, ny, nz, xtex, ytex): Como el primero, solo que agrega un vértice texturado. d3d_model_vertex_normal_texture_color (ind, x, y, z, nx, ny, nz, xtex, ytex, col, alpha): Como el anterior, pero con color y alpha (luminosidad/transparencia) especificados. d3d_model_color primario _end (ind): Fin de definición del color primario en el modelo. Además de agregar color primario a los modelos, puedes agregar las formas básicas que fueron mencionadas anteriormente: d3d_model_block (ind, x1, y1, z1, x2, y2, z2, hrepeat, vrepeat): Agrega un bloque al modelo. d3d_model_cylinder (ind, x1, y1, z1, x2, y2, z2, hrepeat, vrepeat, closed, steps): Agrega un cilindro al modelo. d3d_model_cone (ind, x1, y1, z1, x2, y2, z2, hrepeat, vrepeat, closed, steps): Agrega un cono al modelo. d3d_model_ellipsoid (ind, x1, y1, z1, x2, y2, z2, hrepeat, vrepeat, steps): Agrega una elipsoide al modelo. d3d_model_wall (ind, x1, y1, z1, x2, y2, z2, hrepeat, vrepeat): Agrega una pared al modelo. d3d_model_floor (ind, x1, y1, z1, x2, y2, z2, hrepeat, vrepeat): Agrega piso al modelo. Usar modelos incrementa la velocidad de los gráficos 3D muy notablemente. Deberías usarlos siempre que puedas. 64.- Palabras Finales: Las funciones 3D del Game M aker pueden ser usadas para hacer buenos juegos 3D. Sin embargo, están bastante limitadas, y te dejan mucho trabajo a ti. No esperes que puedas crear tu propio Warcraft III con el. Game M aker, recuerda que está diseñado especialmente para hacer juegos de 2 dimensiones (2D). Espero y este manual de sirva en el desarrollo de tus juegos. 65.- Páginas Web útiles en donde encontrar recursos para crear tus juegos : Bien aquí les dejo la dirección de algunas páginas de Internet en donde podrán conseguir imágenes (sprites), sonidos (sounds), mosaicos (tiles), Tiras cómicas (sprits) ejemp los de juegos que pueden ser modificados, y tutoriales; esperando les sean de utilidad, todos ellos desde paginas que los ofrecen de libre uso. www.gamemaker.nl/.com : En donde podrás descargar el programa para crear tus juegos, y algunos recursos y ejemplos para estos, así como también cuenta con una sección de descargas de programas que podrías utilizar para elaborar tus juegos, también cuenta con una sección de enlaces para otras páginas que pueden serte útiles. www.comunidadgm.com : En donde encontraras ejemplos de juegos, que podrás modificar para ir practicando. Juegos que podrás descargar pero modificar. Algo importante de esta página es que esta en español (es de origen español), y cuenta con un foro en el cual, si te inscribes, te podrán ayudar con algunas dudas que tengas sobre el Game M aker, o como programar con él. www.gmsshowcase.dk/index.php : En donde encontraras ejemplos de juegos, que podrás modificar para ir practicando. 170
- 171. www.mindtools.tased.edn.an/gamemaker : En donde encontraras ejemplos de juegos, que podrás modificar para ir practicando, y tutoriales. www.bigbrain.org : En donde encontraras muy pocos ejemplos de juegos que podrás modificar pero muy buenos (del tipo de rompecabezas o para pensar), y tutoriales. www.gamemerkers games.com : En donde encontraras ejemplos de juegos que podrás modificar, juegos que podrás descargar pero no modificar, y tutoriales. www.molotov.nu : Aquí podrás encontrar varias imágenes que podrás usar para tus (sprites), y algunas tiras cómicas (strips). www.nes-snes-sprites.com : Sin duda alguna la más completa que he visitado, aquí encontraras cientos –por no decir que miles- de tiras cómicas (strips), e imágenes (sprites). www.videogamesprites.com : Aquí encontraras algunas imágenes que te pueden ser útilies. www.gsarchives.net : Otra buena página para conseguir imágenes y tiras cómicas, aunque hay que navegar por ella un poco más. www.amaranthia.com/modules/myalbum : Aquí podrás conseguir algunas imágenes de mosaicos o azulejos (Tileset). www.rmxp.net/two/resources/ndex : Aquí podrás encontrar algunas imágenes de mosaicos (Tileset). www.findmidis.com/dowloand.go : Aquí conseguirás varios sonidos M idis. www.vgmusic.com : Aquí conseguirás varios sonidos M idis. www.flashkit.com : Aquí conseguirás varios sonidos .wav, y .mp3, para tus juegos. www.recursos,cnice.mec.es : Aquí encontraras varios sonidos M idis. www.musicfondo.com : Aquí encontraras varios sonidos de efectos. Visita estas páginas créeme tiene una buena cantidad de recursos para tus posibles juegos, y te ahorraras mucho tiempo buscando en Internet. 171
- 172. APENDICE A Glosario Completo: Alpha: Transparencia. Es un parámetro que se utiliza en las funciones de dibujo avanzadas y que indica el nivel de transparencia de lo que se está dibujando: 0 es totalmente transparente y 1 es totalmente opaco. Los valores intermedios se usan para dibujar elementos parcialmente transparentes. Argumento: Los argumentos son los datos que se le pasan a una función para que ésta opere con ellos. Por ejemplo, una función que sume dos números necesitará que le digas que números tiene que sumar. Esos números son los argumentos de la función. Background: Fondo. Es la imagen que se pone de fondo al cuarto o nivel de juego para que sea el escenario. Puedes agregar varias imágenes distintas y hacer que cada una se mueva a diferente velocidad cuando el personaje avance, haciendo que las imágenes más cercanas se muevan más rápido que las más lejanas. Así consigues un efecto de profundidad muy vistoso. Esta técnica se llama scroll parallax. Blending: Ver image blending. Bmp: Es un tipo de archivo de gráficos de alta calidad (mapa de bits). Sólo es aconsejable utilizar bmps para fondos transparentes. Boolean: Booleano. Es un tipo de variable que sólo puede tener dos valores: true o false. Es decir, si una variable booleana no es true entonces es false. Depth: Profundidad. Es una propiedad de las instancias que sirve para decidir cuál debe dibujarse por encima de las demás cuando chocan, cuál se sitúa primero en el cuarto o nivel de juego...Puede ser positiva, negativa ó 0 y cuanto menor sea más al frente se situará la instancia. False: Falso. En Game Maker false=0, es decir, es lo mismo poner false que poner 0. fps: Frames por segundo. No es lo mismo que la room speed. La room s peed es el valor ideal al que queremos que el juego se actualice. Sin embargo, si ponemos muchas acciones en el evento step el juego puede ralentizarse, o si usamos unos sprites de mucha calidad puede que el juego necesite mucha memoria...esto provoca que el juego se ralentice y en lugar de dibujar todos los frames que queremos en cada segundo dibuje menos. Los fps son la medida real de la velocidad del juego en cada segundo. Te interesará que los fps estén siempre lo más cercano posible a la room speed. Frame: Para generar la ilusión de animación, lo que se hace es dibujar la pantalla muchas veces (por ejemplo 60 veces por segundo) haciendo que su contenido cambie poco a poco. Así, al ver esos cambios de manera seguida parece que la imagen se esté moviendo. Cada instante en el que se dibuja la pantalla se denomina frame. Frame rate: Es la velocidad con la que se pasa de un frame a otro. Cuanto mayor sea, más fluidas se verán las animaciones en la pantalla, pero se requerirá más potencia. Gif: Es un tipo de archivo de gráficos comprimido y animado. Ideal para sprites, con movimiento. Height: Altura. Es un argumento muy común en las funciones de gráficos. Highscore: El marcador más alto, el récord de puntuación obtenido en el juego. Puedes mostrar una lista con las puntuaciones más altas (highscore list) con la acción correspondiente. 172
- 173. Image blending: M ezclado de imágenes. Cuando dos imágenes se superponen (por ejemplo, cuando chocan dos sprites) el programa debe decidir qué es lo que va a dibujar. Si la instancia de uno de los sprites tiene menor profundidad que el otro se dibujará éste por encima. Pero si tiene mayor depth se dibujará por debajo. Si uno de los sprites es parcialmente transparente, se verá parte del otro. Si el modo de mezcla está en suma se sumarán los colores de los dos sprites en la zona en la que chocan (por ejemplo para causar un efecto de brillo), pero si está en modo resta se restarán. Como ves, en la parte de los sprites que choca se decide qué hay que hacer según el modo de mezcla que esté activo (esto también afecta a los backgrounds). Con esta técnica se pueden crear efectos visuales muy espectaculares. jpg: Es un tipo de archivo de gráficos de tamaño reducido, pero que no permite transparencias. Ideal para usarlo en fondos no transparentes o para sprite sheets. Left: Izquierda. Es un argumento muy común en las funciones que deben especificar una posición para indicar dónde debe situarse el borde izquierdo. Midi: Es un formato de sonido de muy pequeño tamaño. Los midis tienen menos calidad que los wav o mp3. Sin embargo su tamaño es mucho menor, lo que hace que no consuman casi memoria. Esto hace que los midis sean ideales para las músicas de fondo del juego. Path: Camino o trayectoria. Game Maker te permite dibujar una trayectoria para que luego la siga una instancia. Así puedes hacer que un enemigo se mueva siguiendo este camino, o hacer que en un juego de coches los participantes sigan la carretera. png: Un tipo de archivo de gráficos de tamaño muy reducido creado para ser transmitido por Internet (png significa "portable network graphics" o "gráficos transportables por la red"). pop-u p: Son los mensajes o ventanas que aparecen de repente y sirven para dar o pedir información al jugador. Por ejemplo, una ventana que se abra y le pregunte al jugador cómo se llama. rar: Es un tipo de archivo comprimido. Los archivos tipo rar consiguen una gran compresión aunque este formato no está tan extendido como el zip. Recurso: Es lo que utiliza el juego. En Game Maker los recursos se dividen en las siguientes categorías: sprites, backgrounds, sonidos y música, paths, scripts, time lines, fuentes, objetos y rooms. Room: Habitación o cuarto. En el room es donde se sitúan todos los objetos y donde todo el juego tiene lugar. Un juego puede tener varias rooms y cada una puede ser un nivel distinto, una pantalla de menú, de ayuda... Room speed: Es el frame rate que queremos que tenga un cuarto y se mide en frames por segundo. Por ejemplo, una room s peed igual a 30 significa que en cada segundo se dibujan 30 frames. S core: M arcador. En el juego, puedes hacer que el marcador se incremente cuando el jugador recoja monedas u otros objetos. S creenshot: Es una foto de la pantalla en un momento determinado. Los screenshots son muy útiles para promocionar tu juego o para usarlos en tablas de récords. S cript: Es un trozo de código que puede recibir argumentos y devolver un valor. Los scripts se utilizan para generalizar código repetido y así ahorrar espacio y ganar velocidad. 173
- 174. S croll: Es el movimiento del fondo. Game Maker te permite añadir varios fondos distintos y asignar un movimiento a cada uno, para dar la impresión de que el decorado avanza cuando el personaje se mueve. S prite: Un sprite es la imagen que se asocia a un objeto y que se dibuja en la pantalla. Los sprites suelen tener varias imágenes, de forma que si en cada momento se dibuja una imagen distinta parece que se mueve. El formato más utilizado para los sprites es el de los archivos gif. S prite sheet: Una sprite sheet (o strip) es una imagen no animada de gran tamaño en la que aparecen muchas imágenes de un personaje (o varios) mostrando todos los frames de sus animaciones. El editor de sprites de Game Maker permite crear sprites animados fácilmente a partir de una sprite sheet. S tep: Paso. Los juegos que crees con Game Maker se ejecutan por pasos, de forma que si haces que se pase de un paso a otro rápidamente dará la impresión de que todo se ejecuta continuamente. S trip: Ver sprite sheet. Tile: Para hacer un fondo, a veces es bueno utilizar imágenes pequeñas que, puestas una al lado de otra, forman un dibujo. Esta técnica se denomina tiling. Por ejemplo: divides el room en casillas del mismo tamaño y en cada una pones una imagen más pequeña (en una un árbol, en otra una casa,...) y haces que se repitan para llenar todo el room. Así puedes conseguir fondos muy originales y que consumen muy poca memoria. Tile set: Ver tile sheet. Tile sheet: Es una imagen muy grande de la que se pueden extraer imágenes más pequeñas para crear tiles. Time line: Línea de tiempo. En una time line puedes añadir acciones en momentos concretos, de forma que estas acciones se ejecutarán en el orden que tú decidas y justo cuando quieras. Top: Arriba. Es un argumento muy común en las funciones que deben especificar una posición para indicar dónde debe situarse el borde superior. True: Verdadero. En Game Maker true=1, es decir, es lo mismo poner true que poner 1. Wav: Son archivos de sonido de gran calidad, pero que por lo tanto ocupan mucho tamaño y consumen bastante memoria. Los archivos wav se suelen utilizar para los efectos de sonido (explosiones, gritos, disparos...). Width: Anchura. Es un argumento muy común en las funciones de gráficos. Zip: Es un tipo de archivo comprimido muy corriente. Al comprimir tu juego, conseguirás que ocupe menos espacio y así podrás distribuirlo más fácilmente por la red. 174
- 175. APENDICE B Ahora conozcamos como debemos agregar el código que se obtiene por medio del programa ActionDecoder1, para las acciones básicas de cada una de las pestañas, que se usan para crear los juegos con el Game M aker esto lo agrego ya que pienso puede ser de gran ayuda a los que estén interesados en trabajar con piezas de código o scripts y desconocen como se debe de escribir este código. Iré poniendo la imagen de la acción utilizada si es verificada como relativa o no, si establece la opción Not o no, y el código de programación que se obtiene con ActionDecoder, para esa acción y las instrucciones introducidas en ellas, Todo referent e al objeto self. Comencemos con la pestaña de movimiento (M ove), Lo que esta con color azul oscuro es la acción, lo que esta en rojo son las coordenadas dadas, lo que esta en negro es la velocidad asignada en este caso 3, y lo que aparece de azul claro es la opción relativa verificada, he tratado de poner los colores que se colocaran en ele editor de códigos que trae el Game M aker para facilitar un poco más la comprensión de lo que aquí se a puesto. Imagen de la acción Dirección Relativa Código escrito Botón central No action_move("000010000",3); Botón central Sí action_move("000010000",3+speed); Derecha No action_move("000001000",3); Derecha Si action_move("000001000",3+speed); Arriba a la derecha No action_move("000001001",3); Arriba a la derecha Si action_move("000001001",3+speed); Arriba No action_move("000000010",3); Arriba Si action_move("000000010",3+speed); Arriba a la izquierda No action_move("000000110",3); Arriba a la izquierda Si action_move("000000110",3+speed); Izquierda No action_move("000100000",3); Izquierda Si action_move("000100000",3+speed); Abajo a la izquierda No action_move("100100000",3); Abajo a la izquierda Si action_move("100100000",3+speed); Abajo No action_move("010000000",3); Abajo Si action_move("010000000",3+speed); Abajo a la derecha No action_move("011000000",3); Abajo a la derecha Si action_move("011000000",3+speed); El siguiente botón de acción es el de moverse a cierta dirección con un valor en grados, el primer digito encerado entre los paréntesis representa la dirección, el segundo la velocidad asignada. Cuando se coloca la opción relativa, nos muestra dos palabras en azul claro. Imagen de la acción Dirección en grados Relativa Código escrito 0 grados (derecha) No motion_set(0,3); 0 grados Si motion_set(direction+0,speed+3); 45 grados (der. Arriba) No motion_set(45,3); 45 grados (der. Arriba) Si motion_set(direction+45,speed+3); 175
- 176. 90 grados (arriba) No motion_set(90,3); 90 grados (arriba) Si motion_set(direction+90,speed+3); 135 grados (izq. Arriba) No motion_set(135,3); 135 grados (izq. Arriba) Si motion_set(direction+135,speed+3); 180 grados (izquierda) No motion_set(180,3); 180 grados (izquierda) Si motion_set(direction+180,speed+3); 225 grados (izq. Abajo) No motion_set(225,3); 225 grados (izq. Abajo) Si motion_set(direction+225,speed+3); 270 grados (abajo) No motion_set(270,3); 270 grados (abajo) Si motion_set(direction+270,speed+3); 315 grados (der. Abajo) No motion_set(315,3); 315 grados (der. Abajo) Si motion_set(direction+315,speed+3); Establecer una velocidad y dirección horizontal. Imagen de la acción Velocidad asignada Relativa Código escrito. 3 No hspeed=3 3 Si hspeed=3+ hspeed Establecer una velocidad y dirección vertical. 3 No vspeed=3 3 Si vspeed=3+vspeed La siguiente acción es la de moverse hacia un punto indicado, aquí debes de indicar las coordenadas “X” y “Y”, a donde tendrá que moverse el objeto y la velocidad, el primer digito es la coordenada X, el segundo la coordenada Y, y el tercer digito es la velocidad. Imagen de la acción Coordenadas y velocidad Relativa Código escrito X=20, Y=10 Velocidad=3 No move_towards_point(20,10,3) X=20, Y=10 Velocidad=3 Si move_towards_point(x+20,y+10,speed+3) Establecer la gravedad a un objeto. Imagen de la acción Coordenada y gravedad Relativa Código escrito 270 grados, 2 de gravedad No gravity_direction=270 gravity=2 270 grados, 2 de gravedad Si gravity_direction=270+ gravity_direction gravity=2+ gravity Establecer la fricción a un objeto Imagen de la acción Cantidad de fricción Relativa Código escrito 2 No friction=2 2 Si friction=2+ friction Saltar a cierta posición Imagen de la acción Coordenadas Relativa Código escrito x=20, y=30 No x=20 y=30 x=20, y=30 Si x= x+20 176
- 177. y=y+30 Saltar a la posición de inicio Imagen de la acción Coordenadas Código escrito x= xstart, y=ystart x= xstart; y=ystart; Saltar a una posición al azar Imagen de la acción Posición de la cuadricula Código escrito Cuadricula Horizontal, vertical move_random(3,4); Precisión de la medida en la cuadricula, o grilla Imagen de la acción M edidas de la cuadricula Código escrito Horizontal, vertical 16 move_snap(16,16); Invertir o cambiar la dirección horizontal Imagen de la acción Código escrito hspeed*=-1 Invertir o cambiar la dirección vertical Imagen de la acción Código escrito vspeed*=-1 M over a una posición de contacto Imagen de la acción Dirección en grados Código escrito 270 grados, -1 máximo move_contact_solid(270,-1); Puedes establecerlo también para todas las instancias poniendo la palabra all, en lugar de solid. Rebotar contra los objetos Imagen de la acción Contra objetos Choque preciso Código escrito Sólidos No move_bounce_solid(false); Todos Si move_bounce_all(true); Nota que si el choque no es preciso tienes que poner entre paréntesis false, y si es preciso true. Vamos ahora con las acciones de la pestaña principal 1. Crear objeto Imagen de la acción Nombre del objeto Coordenadas Código escrito obj_Ejemplo x=300, y=200 instance_create(300,200,obj_ejemplo); Observa como cuando reconoce, a un objeto se colorea el nombre del objeto en color morado. Cambiar la instancia de un objeto Imagen de la acción Nombre del objeto Código escrito obj_ejemplo instance_change(obj_ejemplo,false); La instrucción de perfomance events, sirve para animar el cambio de la imagen false, es sin efecto, y true es con efecto. 177
- 178. Destruir una instancia Imagen de la acción Nombre del objeto a destruir Código escrito obj_ejemplo instance_destroy(obj_ejemplo) Destruir las instancias de objeto en determinada área. Imagen acción Coordenadas x, y Código escrito x=10, y=20 position_destroy(10,20); x=10, y=20 relativa position_destroy(x+10,y+20); Cambiar la imagen Imagen de la acción Nombre del sprite Código escrito spr_ejemplo sprite_index=spr_ejemplo Factor de escala 1 image_scale=1 Reproducir un sonido Imagen de la acción Nombre del sonido Repetir Código escrito snd_sonido No sound_play(snd_sonido) snd_sonido Si sound_loop(snd_sonido) Detener un sonido Imagen de la acción Nombre del sonido Código escrito snd_sonido sound_stop(snd_sonido) Si el sonido se esta escuchando Imagen de la acción Nombre del sonido Código escrito snd_sonido if (sound_isplaying(snd_sonido) snd_sonido con Not verificado if not (sound_isplaying(snd_sonido) Ir al cuarto anterior Imagen de la acción Efecto de transición Código escrito Create from left room_goto_previous() transition_kind=1 Nota: cada efecto de transición es llamado transition_kind y tiene un numero para identificarlo, el numero 0 representa la transición sin efectos, el numero 1 representa el de efecto de transición hacia la izquierda, el numero 2 hacia la derecha y así sucesivamente con los demás efectos hasta llegar al numero 17, y cada uno te da un efecto distinto. Ir al cuarto siguiente Imagen de la acción Efecto de transición Código escrito Sin efectos room_goto_next() Redibujar el cuarto Imagen de la acción Efecto de transición Código escrito Sin efectos room_restart() 178
- 179. Ir al cuarto indicado Imagen de la acción Efecto de transición Código escrito Sin efectos room_goto(rm_ejemplo20) Si el anterior existe Imagen de la acción Efecto de transición Código escrito Sin efectos if (room_previous(room)>-1) room_goto_previous() Con esta instrucción se mueve al cuarto anterior del juego escríbela tal y como esta. Ir al cuarto siguiente Imagen de la acción Efecto de transición Código escrito Sin efectos if (room_next(room)>-1) room_goto_next() Vamos ahora con la pestaña principal 2. Alarma Imagen de la acción Alarma 0, tiempo asignado Código escrito 0, tiempo 20 alarm[0]=20 Relativa alarm[0]=alarm[0]+20 Dormir o Pausar Imagen de la acción Tiempo asignado en milisegundos Código escrito 1000 = 1 segundo falso sleep(1000); En modo Verdadero screen_redraw(); sleep(1000); Asignar línea de tiempo a un objeto Imagen de la acción Nombre del objeto, posición Código escrito tml_ejemplo, posición 0 timeline_index=tml_ejemplo timeline_position=0 Asignar la posición a la línea de tiempo Imagen de la acción Tiempo de posición Código escrito 0 timeline_position=0 M ostrar mensaje Imagen de la acción M ensaje a mostrar Código escrito Hola show_message("Hola"); M ostrar información del juego Imagen de la acción Código escrito show_info(); 179
- 180. Reiniciar el juego Imagen de la acción Código escrito game_restart(); Finalizar el juego Imagen de la acción Código escrito game_end(); Guardar juego Imagen de la acción Nombre del archivo Código escrito Nombre del archivo game_save("Nombre del archivo") Cargar archivo Imagen de la acción Nombre del archivo Código escrito Cargar archivo game_load("Cargar archivo") Vamos ahora con la pestaña de control. Si la posición esta libre Imagen de la acción Coordenadas, relativa, Not Código escrito Con objetos sólidos x=20, y=20 if place_free(20,20) Con relativa if place_free(x+20,y+20) Con Not if not place_free(20,20) Con relativa y Not if not place_free(x+20,y+20) M ismas coordenadas, Para todos los objetos Código escrito x=20, y=20 if place_empty(20,20) Con relativa if place_empty(x+20,y+20) Con Not if not place_empty(20,20) Con relativa y Not if not place_empty(x+20,y+20) Si hay un choque en esta posición Imagen de la acción Coordenadas, relativa,Not Código escrito Con objetos sólidos x=20, y=30 if not place_free(20,30) Con relativa if not place_free(x+20,y+30) Con Not if place_free(20,30) Con relativa y Not if place_free(x+20,y+30) M ismos datos, para Código escrito Todos los objetos x=20, y=30 if not place_empty(20,30) Con relativa if not place_empty(x+20,y+30) Con Not if place_empty(20,30) Con relativa y Not if place_empty(x+20,y+30) Si hay un objeto en la posición Imagen de la acción Coordenadas, y nombre objeto Código escrito Obj_ejemplo x=30, y=30 if position_meeting(30,30,obj_ejemplo) Con relativa if position_meeting(x+30,y+30,obj_ejemplo) Con Not if not position_meeting(30,30,obj_ejemplo) 180
- 181. Con relativa y Not if not position_meeting(x+30,y+30,obj_ejemplo) Si el numero de objetos es igual a Imagen de la acción Nombre del Objeto y cantidad Igual, menor, o mayor Código Escrito Obj_ejemplo, cantidad 5 Igual if (instance_number(obj_ejemplo)=5) M enor if (instance_number(obj_ejemplo)<5) M ayor if (instance_number(obj_ejemplo)>5) Con Not Igual if not (instance_number(obj_ejemplo)=5) M enor if not (instance_number(obj_ejemplo)<5) M ayor if not (instance_number(obj_ejemplo)>5) Si existe la probabilidad Imagen de la acción Número de lados Código escrito 2 if (ceil(random(2))=true) Con Not if (ceil(random(2))=false) Si se contesta si a la pregunta Imagen de la acción Pregunta Código escrito ¿Esta difícil? if show_question("¿Esta difícil?")=true Con Not if show_question("¿Esta difícil?")=false Si la expresión es verdadera Imagen de la acción Expresión Código escrito Todo bien if (Todo bien)=true Con Not if (Todo bien)=false Si el botón es presionado Imagen de la acción Código escrito if mouse_check_button(mb_left)=true Con Not if mouse_check_button(mb_right)=false Aclaro que en el código escrito en las acciones anteriores, se han usado 2 botones el derecho, e izquierdo, y que también se pudo haber usado el central (mb_middle), o ninguno poniendo (mb_no). Si esta alineado a la cuadricula o grilla Imagen de la acción M edidas de la cuadricula Código escrito 16x16 if place_snapped(16,16)=true Con Not if place_snapped(16,16)=false Else Imagen de la acción Código escrito else Iniciar y cerrar bloques de acciones Imágenes de las acciones Código escrito { Para iniciar el bloque pon este simbolo } Para cerrar el bloque pon este simbolo Repetir acción o bloque de acciones Imagen de la acción Número de repeticiones Código escrito 5 repeat(5) 181
- 182. Salir del evento Imagen de la acción Código escrito exit; Veamos ahora la pestaña de dibujo. Dibujar Imagen Nombre de la imagen y coordenadas Código escrito Imagen de la acción spr_ejemplo x=20, y=20 draw_sprite(spr_ejemplo,-1,20,20) Con relativo draw_sprite(spr_ejemplo,-1,x+20,y+20) Dibujar fondo Imagen de la acción Nombre del fondo y coordenadas Código escrito bkn_ejemplo x=0 ,y=0 con false draw_background(bkn_ejemplo,0,0) Con true draw_background_tiled(bkn_ejemplo,0,0) Con false, y relativo draw_background(bkn_ejemplo,x+0,y+0) Con true , y relativo draw_background_tiled(bkn_ejemplo,x+0,y+0) Dibujar un rectángulo o cuadrado Coordenadas Código escrito Imagen de la acción x1=0, y1=0, x2=10, y2=10 draw_rectangle(0,0,10,10) Con relativo draw_rectangle(x+0,y+0,x+10,y+10) Dibujar un circulo o elipse Coordenadas Código escrito Imagen de la acción x1=0, y1=0, x2=10, y2=10 draw_ellipse(0,0,10,10) Con relativo draw_ellipse(x+0,y+0,x+10,y+10) Dibujar una línea Coordenadas Código escrito Imagen de la acción x1=0, y1=0, x2=10, y2=10 draw_line(0,0,10,10) Con relativo draw_line(x+0,y+0,x+10,y+10) Dibujar texto Coordenadas y texto Código escrito Imagen de la acción x=20, y=30 Hola draw_text(20,30,"Hola") Con relativo draw_text(x+20,y+30,"Hola") Establecer los colores de dibujo Código de la acción Imagen de la acción Primer color blanco Segundo color negro brush_color=16777215 pen_color=0 Para conocer el número que representa a los colores, usa esta acción con cada color. Dibujar el tipo de texto a un tamaño, y con un color Imagen de la acción Código de la acción Color rojo font_color=255 Tamaño 10 píxeles font_size=10 Estilo de la Fuente normal font_style=fs_normal Nombre del a fuente Arial font_name="Arial" Observa que el color se indica con el valor numerico del color, no con su nombre. 182
- 183. Cambiar el tamaño de la pantalla Imagen de la acción Tres opciones Código escrito Switch full_screen=!full_screen Window full_screen=false Fullscreen full_screen=true Vamos ahora con la pestaña de puntuaciones, vida y energía Establecer puntuación Imagen de la acción Puntuación Código escrito 10 score=10 Con relativo para sumar score=score+10 Con relativo para restar score=score-10 Si la puntuación vale Imagen de la acción Con valores a Código escrito Igual if (score=10) Igual con Not if not (score=10) M enor if (score<10) M enor con Not if not (score<10) M ayor if (score>10) M ayor con Not if not (score>10) Dibujar la puntuación en un área de la pantalla Imagen de la acción Coordenadas Código escrito x=10, y=10 Puntuación: draw_text(10,10,"Puntuación:"+string(score)) Con relativo draw_text(x+10,y+10,"Puntuación:"+string(score)) Crear la tabla de puntuaciones. Imagen da la acción En modo sencillo Código escrito highscore_show(score); Limpiar la tabla de puntuaciones Imagen de la acción Código escrito highscore_clear(); Fijar las vidas Imagen de la acción Código escrito lives=3 Con relativo lives=lives+3 Si vidas vale Tipo de valores Código escrito Igual a if (lives=3) No es igual a if not (lives=3) Es menor a if (lives<3) No es menor a if not (lives<3) Es mayor a if (lives>3) No es mayor a if not (lives>3) 183
- 184. Dibujar posición y número de vidas Imagen de la acción Coordenadas Código escrito x=20, y=30 draw_text(20,30,"Vidas:"+string(lives)) Con relativo draw_text(x+20,y+30,"Vidas:"+string(lives)) Dibujar el número de vidas con una imagen Imagen de la acción Coordenadas x=20, y=30 Código Escrito { var xx, temp; xx=lives; temp=sprite_index sprite_index=spr_mini_imagen; repeat (lives) {draw_sprite(spr_mini_imagen,-1,20+(xx-1)*sprite_width,30);xx-1} sprite_index=temp; } Ahora con relativo { var xx, temp; xx=lives; temp=sprite_index sprite_index=spr_mini_imagen; repeat(lives) {draw_sprite(spr_mini_imagen,-1,x+20+(xx-1)*sprite_width,y+30); xx-=1} sprite_index=temp; } Establecer nivel de energía o vitalidad Imagen de la acción Código escrito health=100 Con relativo health=health+100 Si la energía vale Imagen de la acción Tipo de valor Código escrito Es igual a if (health=100) No es igual if not (health=100) Es menor a if (health<100) No es menor a if not (health<100) Es mayor a if (health>100) No es mayor a if not (health>100) Dibujar la barra de energía en la pantalla Imagen de la acción Coordenadas Código escrito X1=10, y1=10, x2=20, y2=20 action_draw_health(10,10,20,20,1,"green to red"); Con relativo action_draw_health(10+x,10+y,20+x,20+y,1,"green to red"); Establecer la información en la ventana del juego Imagen de la acción Código escrito action_set_caption(true,"score:",false,"lives:",false,"health:"); Vamos ahora con la pestaña de Códigos. Ejecutar un script Imagen de la acción Código escrito 184
- 185. scr_ejemplo(argumento_ejemplo,argumento_ejemplo1); Establecer una variable Imagen de la acción Código escrito lives=5; Con relativo lives=lives+5 Si la variable vale Imagen de la acción Tipo de valor Código escrito Es igual a if (lives=2) No es igual a if not (lives=2) Es menor a if (lives<2) No es menor a if not (lives<2) Es mayor a if (lives>2) No es mayor a if not (lives>2) Dibujar el valor de la variable en Imagen de la acción Coordenadas Código escrito x=10, y=20 draw_text(10,20,lives) Con relativo draw_text(x+10,y+20,lives) Llamar al evento padre de un objeto Imagen de la acción Código escrito event_inherited(); Colocar un comentario en un código Imagen de la acción Código escrito // Hola esto es un comentario Realmente como ya se menciono arriba lo único, que necesitas para poner un comentario es anteponer a cualquier texto, que escribas en un código las dos líneas diagonales. 185
- 186. APENDICE C Aquí se muestran todas las varibles, funciones, y constantes que vienen incluidas en el Game M aker. Las cuales ya fueron explicadas dentro del manual, en su mayoría al ser escritas en una piezade código, las veras colorearse de los siguientes colores, si las escribes bien pero en algunos casos, solo se marcaran como negritas por ejemplo de las constantes la palabra all se vera así all y no tendrá el color correspondiente a las constantes o sea no se vera así all. Comencemos con las Variables Globales. argument argument0 argument1 argument2 argument3 argument4 argument5 argument6 argument7 argument8 argument9 argument10 argument11 argument12 argument13 argument14 argument15 argument_relative background_alpha background_blend background_color background_foreground background_height background_hspeed background_htiled background_index background_showcolor background_visible background_vspeed background_vtiled background_width background_x background_xscale background_y background_yscale caption_health caption_lives caption_score current_day current_hour current_minute current_month current_second current_time current_weekday current_year cursor_sprite error_last error_occurred event_action event_number event_object event_type fps game_id health instance_count instance_id keyboard_key keyboard_lastchar keyboard_lastkey keyboard_string lives mouse_button mouse_lastbutton mouse_x mouse_y room room_caption room_first room_height room_last room_persistent room_speed room_width score secure_mode show_health show_lives show_score temp_directory transition_kind transition_steps transition_time view_angle view_current view_enabled view_hborder view_hport view_hspeed view_hview view_object view_vborder view_visible view_vs peed view_wport view_wview view_xport view_xview view_yport view_yview working_directory Continuemos con las Variables Locales. alarm bbox_bottom bbox_left bbox_right bbox_top depth direction friction gravity gravity_direction hspeed iId image_alpha image_angle image_blend image_index image_number image_single image_speed image_xscale image_yscale mask_index object_index path_endaction path_index path_orientation path_position path_positionprevious path_scale path_speed persistent solid speed sprite_height sprite_index sprite_width sprite_xoffset sprite_yoffset timeline_index timeline_position timeline_speed visible vspeed x xprevious xstart y yprevious ystart Continuemos con las Funciones MCI_command abs action_another_room action_bounce action_cd_pause action_cd_play action_cd_playing action_cd_present action_cd_resume 186
- 187. action_cd_stop action_change_object action_color action_create_object action_create_object_motion action_create_object_random action_current_room action_draw_arrow action_draw_background action_draw_ellipse action_draw_ellipse_gradient action_draw_gradient_hor action_draw_gradient_vert action_draw_health action_draw_life action_draw_life_images action_draw_line action_draw_rectangle action_draw_score action_draw_sprite action_draw_text action_draw_text_transformed action_draw_variable action_effect action_end_game action_end_sound action_execute_script action_font action_fullscreen action_highscore_clear action_highscore_show action_if action_if_aligned action_if_collision action_if_dice action_if_empty action_if_health action_if_life action_if_mouse action_if_next_room action_if_number action_if_object action_if_previous_room action_if_question action_if_score action_if_sound action_if_variable action_inherited action_kill_object action_kill_position action_linear_step action_load_game action_message action_move action_move_contact action_move_point action_move_random action_move_start action_move_to action_next_room action_partemit_burst action_partemit_create action_partemit_destroy action_partemit_stream action_partsyst_clear action_partsyst_clear action_partsyst_destroy action_parttype_color action_parttype_create action_parttype_gravity action_parttype_life action_parttype_secondary action_parttype_speed action_path action_path_end action_path_position action_path_speed action_potential_step action_previous_room action_replace_background action_replace_sound action_replace_sprite action_restart_game action_reverse_xdir action_reverse_ydir action_save_game action_set_alarm action_set_caption action_set_cursor action_set_friction action_set_gravity action_set_health action_set_hspeed action_set_life action_set_motion action_set_score action_set_timeline action_set_timeline_position action_set_vspeed action_show_info action_show_video action_sleep action_snap action_snap action_sound action_sprite_color action_sprite_set action_sprite_transform action_webpage action_wrap arccos arcsin arctan arctan2 background_add background_assign background_create_color background_create_from_screen background_create_from_surface background_create_gradient background_delete background_duplicate background_exists background_get_height background_get_name background_get_preload background_get_smooth background_get_texture background_get_transparent background_get_width background_name background_replace background_set_alpha_from_background cd_close_door cd_init cd_length cd_number cd_open_door cd_pause cd_paused cd_play cd_playing cd_position cd_present cd_resume cd_set_position cd_set_track_position cd_stop cd_track cd_track_length cd_track_position ceil choose chr clipboard_get_text clipboard_has_text clipboard_set_text collision_circle collision_ellipse collision_line collision_point collision_rectangle color_get_blue color_get_green color_get_hue color_get_red color_get_saturation color_get_value cos d3d_draw_block d3d_draw_cone d3d_draw_cylinder d3d_draw_ellipsoid d3d_draw_floor d3d_draw_wall d3d_end d3d_light_define_direction d3d_light_define_point d3d_light_enable d3d_model_block d3d_model_clear d3d_model_cone d3d_model_create d3d_model_cylinder d3d_model_destroy d3d_model_draw d3d_model_ellipsoid d3d_model_floor d3d_model_load d3d_model_primitive_begin d3d_model_primitive_end d3d_model_save 187
- 188. d3d_model_vertex d3d_model_vertex_color d3d_model_vertex_normal d3d_model_vertex_normal_color d3d_model_vertex_normal_texture d3d_model_vertex_normal_texture_color d3d_model_vertex_texture d3d_model_vertex_texture_color d3d_model_wall d3d_primitive_begin d3d_primitive_begin_texture d3d_primitive_end d3d_set_culling d3d_set_depth d3d_set_fog d3d_set_hidden d3d_set_lighting d3d_set_perspective d3d_set_projection d3d_set_projection_ext d3d_set_projection_ortho d3d_set_projection_perspective d3d_set_shading d3d_start d3d_transform_add_rotation_axis d3d_transform_add_rotation_x d3d_transform_add_rotation_y d3d_transform_add_rotation_z d3d_transform_add_scaling d3d_transform_add_translation d3d_transform_set_identity d3d_transform_set_rotation_axis d3d_transform_set_rotation_x d3d_transform_set_rotation_y d3d_transform_set_rotation_z d3d_transform_set_scaling d3d_transform_set_translation d3d_transform_stack_clear d3d_transform_stack_discard d3d_transform_stack_empty d3d_transform_stack_pop d3d_transform_stack_push d3d_transform_stack_top d3d_vertex d3d_vertex_color d3d_vertex_normal d3d_vertex_normal_color d3d_vertex_normal_texture d3d_vertex_normal_texture_color d3d_vertex_texture d3d_vertex_texture_color date_compare_date date_compare_datetime date_compare_time date_create_date date_create_datetime date_create_time date_current_date date_current_datetime date_current_time date_date_of date_date_string date_datetime_string date_day_span date_days_in_month date_days_in_year date_get_day date_get_day_of_year date_get_hour date_get_hour_of_year date_get_minute date_get_minute_of_year date_get_month date_get_second date_get_second_of_year date_get_week date_get_weekday date_get_year date_hour_span date_inc_day date_inc_hour date_inc_minute date_inc_month date_inc_second date_inc_week date_inc_year date_is_today date_leap_year date_minute_span date_month_span date_second_span date_time_of date_time_string date_valid_date date_valid_datetime date_valid_time date_week_span date_year_span degtorad directory_create directory_exists display_get_colordepth display_get_frequency display_get_height display_get_width display_mouse_get_x display_mouse_get_y display_mouse_set display_reset display_set_all display_set_colordepth display_set_frequency display_set_size display_test_all distance_to_object distance_to_point draw_arrow draw_background draw_background_ext draw_background_general draw_background_part draw_background_part_ext draw_background_stretched draw_background_stretched_ext draw_background_tiled draw_background_tiled_ext draw_button draw_circle draw_circle_color draw_clear draw_clear_alpha draw_ellipse draw_ellipse_color draw_get_alpha draw_get_color draw_getpixel draw_healthbar draw_highscore draw_line draw_line_color draw_path draw_point draw_point_color draw_primitive_begin draw_primitive_begin_texture draw_primitive_end draw_rectangle draw_rectangle_color draw_roundrect draw_roundrect_color draw_set_alpha draw_set_blend_mode draw_set_blend_mode_ext draw_set_circle_precision draw_set_color draw_set_font draw_set_halign draw_set_valign draw_sprite draw_sprite_ext draw_sprite_general draw_sprite_part draw_sprite_part_ext draw_sprite_stretched draw_sprite_stretched_ext draw_sprite_tiled draw_sprite_tiled_ext draw_surface draw_surface_ext draw_surface_general draw_surface_part draw_surface_part_ext draw_surface_stretched draw_surface_stretched_ext draw_surface_tiled draw_surface_tiled_ext draw_text draw_text_color draw_text_ext draw_text_ext_color draw_text_ext_transformed draw_text_ext_transformed_color draw_text_transformed draw_text_transformed_color draw_triangle draw_triangle_color draw_vertex draw_vertex_color draw_vertex_texture draw_vertex_texture_color ds_grid_add ds_grid_add_disk 188
- 189. ds_grid_add_region ds_grid_clear ds_grid_create ds_grid_destroy ds_grid_get ds_grid_get_disk_max ds_grid_get_disk_mean ds_grid_get_disk_min ds_grid_get_disk_sum ds_grid_get_max ds_grid_get_mean ds_grid_get_min ds_grid_get_sum ds_grid_height ds_grid_multiply ds_grid_multiply_disk ds_grid_multiply_region ds_grid_resize ds_grid_set ds_grid_set_disk ds_grid_set_region ds_grid_value_disk_exists ds_grid_value_disk_x ds_grid_value_disk_y ds_grid_value_exists ds_grid_value_x ds_grid_value_y ds_grid_width ds_list_add ds_list_clear ds_list_create ds_list_delete ds_list_destroy ds_list_empty ds_list_find_index ds_list_find_value ds_list_insert ds_list_replace ds_list_size ds_list_sort ds_map_add ds_map_clear ds_map_create ds_map_delete ds_map_destroy ds_map_empty ds_map_exists ds_map_find_first ds_map_find_last ds_map_find_next ds_map_find_previous ds_map_find_value ds_map_replace ds_map_size ds_priority_add ds_priority_change_priority ds_priority_clear ds_priority_create ds_priority_delete_max ds_priority_delete_min ds_priority_delete_value ds_priority_destroy ds_priority_empty ds_priority_find_max ds_priority_find_min ds_priority_find_priority ds_priority_size ds_queue_clear ds_queue_create ds_queue_dequeue ds_queue_destroy ds_queue_empty ds_queue_enqueue ds_queue_head ds_queue_size ds_queue_tail ds_set_precision ds_stack_clear ds_stack_create ds_stack_destroy ds_stack_empty ds_stack_pop ds_stack_push ds_stack_size ds_stack_top effect_clear effect_create_above effect_create_below environment_get_variable event_inherited event_perform event_perform_object event_user execute_file execute_program execute_shell execute_string exp external_call external_call0 external_call1 external_call2 external_call3 external_call4 external_call5 external_call6 external_call7 external_call8 external_define external_define1 external_define2 external_define3 external_define4 external_define5 external_define6 external_define7 external_define8 external_free file_attributes file_bin_close file_bin_open file_bin_position file_bin_read_byte file_bin_rewrite file_bin_seek file_bin_size file_bin_write_byte file_close file_copy file_delete file_eof file_exists file_find_close file_find_first file_find_next file_open_append file_open_read file_open_write file_read_real file_read_string file_readln file_rename file_text_close file_text_eof file_text_open_append file_text_open_read file_text_open_write file_text_read_real file_text_read_string file_text_readln file_text_write_real file_text_write_string file_text_writeln file_write_real file_write_string file_writeln filename_change_ext filename_dir filename_drive filename_ext filename_name filename_path floor font_add font_add_sprite font_delete font_exists font_get_bold font_get_first font_get_fontname font_get_italic font_get_last font_get_name font_get_size font_name font_replace font_replace_sprite frac game_end game_load game_restart game_save get_color get_directory get_directory_alt get_integer get_open_filename get_save_filename get_string highscore_add highscore_add_current highscore_clear 189
- 190. highscore_name highscore_set_background highscore_set_border highscore_set_colors highscore_set_font highscore_set_strings highscore_show highscore_show_ext highscore_value ini_close ini_key_delete ini_key_exists ini_open ini_read_real ini_read_string ini_section_delete ini_section_exists ini_write_real ini_write_string instance_activate_all instance_activate_object instance_activate_region instance_change instance_copy instance_create instance_deactivate_all instance_deactivate_object instance_deactivate_region instance_destroy instance_exists instance_find instance_furthest instance_nearest instance_number instance_place instance_position instance_sprite io_clear io_handle is_real is_string joystick_axes joystick_buttons joystick_check_button joystick_direction joystick_exists joystick_has_pov joystick_name joystick_pov joystick_rpos joystick_upos joystick_vpos joystick_xpos joystick_ypos joystick_zpos keyboard_check keyboard_check_direct keyboard_check_pressed keyboard_check_released keyboard_clear keyboard_get_map keyboard_get_numlock keyboard_key_press keyboard_key_release keyboard_set_map keyboard_set_numlock keyboard_unset_map keyboard_wait lengthdir_x lengthdir_y ln load_info log10 log2 logn make_color make_color_hsv make_color_rgb max max3 mean median merge_color message_alpha message_background message_button message_button_font message_caption message_input_color message_input_font message_mouse_color message_position message_size message_text_font min min3 motion_add motion_set mouse_check_button mouse_check_button_pressed mouse_check_button_released mouse_clear mouse_wait move_bounce move_bounce_all move_bounce_solid move_contact move_contact_all move_contact_solid move_outside_all move_outside_solid move_random move_snap move_towards_point move_wrap mp_grid_add_cell mp_grid_add_instances mp_grid_add_rectangle mp_grid_clear_all mp_grid_clear_cell mp_grid_clear_rectangle mp_grid_create mp_grid_destroy mp_grid_draw mp_grid_path mp_linear_path mp_linear_path_object mp_linear_step mp_linear_step_object mp_potential_path mp_potential_path_object mp_potential_settings mp_potential_step mp_potential_step_object mplay_connect_status mplay_data_mode mplay_data_read mplay_data_write mplay_end mplay_init_ipx mplay_init_modem mplay_init_serial mplay_init_tcpip mplay_ipaddress mplay_message_clear mplay_message_count mplay_message_id mplay_message_name mplay_message_player mplay_message_receive mplay_message_send mplay_message_send_guaranteed mplay_message_value mplay_player_find mplay_player_id mplay_player_name mplay_session_create mplay_session_end mplay_session_find mplay_session_join mplay_session_mode mplay_session_name mplay_session_status object_add object_delete object_event_add object_event_clear object_exists object_get_depth object_get_mask object_get_name object_get_parent object_get_persistent object_get_solid object_get_sprite object_get_visible object_is_ancestor object_name object_set_depth object_set_mask object_set_parent object_set_persistent object_set_solid object_set_sprite object_set_visible ord parameter_count parameter_string part_attractor_clear part_attractor_create part_attractor_destroy part_attractor_destroy_all 190
- 191. part_attractor_exists part_attractor_force part_attractor_position part_changer_clear part_changer_create part_changer_destroy part_changer_destroy_all part_changer_exists part_changer_kind part_changer_region part_changer_types part_deflector_clear part_deflector_create part_deflector_destroy part_deflector_destroy_all part_deflector_exists part_deflector_friction part_deflector_kind part_deflector_region part_destroyer_clear part_destroyer_create part_destroyer_destroy part_destroyer_destroy_all part_destroyer_exists part_destroyer_region part_emitter_burst part_emitter_clear part_emitter_create part_emitter_destroy part_emitter_destroy_all part_emitter_exists part_emitter_region part_emitter_stream part_particles_clear part_particles_count part_particles_create part_particles_create_color part_system_automatic_draw part_system_automatic_update part_system_clear part_system_create part_system_depth part_system_destroy part_system_draw_order part_system_drawit part_system_exists part_system_position part_system_update part_type_alpha part_type_alpha1 part_type_alpha2 part_type_alpha3 part_type_blend part_type_clear part_type_color part_type_color1 part_type_color2 part_type_color3 part_type_color_hsv part_type_color_mix part_type_color_rgb part_type_create part_type_death part_type_destroy part_type_direction part_type_exists part_type_gravity part_type_life part_type_orientation part_type_scale part_type_shape part_type_size part_type_speed part_type_sprite part_type_step path_add path_add_point path_append path_assign path_change_point path_clear_points path_delete path_delete_point path_duplicate path_end path_exists path_flip path_get_closed path_get_kind path_get_length path_get_name path_get_number path_get_point_speed path_get_point_x path_get_point_y path_get_precision path_get_speed path_get_x path_get_y path_insert_point path_mirror path_name path_reverse path_rotate path_scale path_set_closed path_set_kind path_set_precision path_shift path_start place_empty place_free place_meeting place_snapped point_direction point_distance position_change position_destroy position_empty position_meeting power radtodeg random real registry_exists registry_exists_ext registry_read_real registry_read_real_ext registry_read_string registry_read_string_ext registry_set_root registry_write_real registry_write_real_ext registry_write_string registry_write_string_ext room_add room_assign room_duplicate room_exists room_get_name room_goto room_goto_next room_goto_pre vious room_instance_add room_instance_clear room_name room_next room_pre vious room_restart room_set_background room_set_background_color room_set_caption room_set_code room_set_height room_set_persistent room_set_view room_set_view_enabled room_set_width room_tile_add room_tile_add_ext room_tile_clear round screen_redraw screen_refresh screen_save screen_save_part screen_wait_vsync script_execute script_exists script_get_name script_get_text script_name set_automatic_draw set_program_priority set_synchronization show_debug_message show_error show_image show_info show_menu show_menu_pos show_message show_message_ext show_question show_text show_video sign sin sleep sound_3d_set_sound_cone sound_3d_set_sound_distance sound_3d_set_sound_position 191
- 192. sound_3d_set_sound_velocity sound_add sound_background_tempo sound_delete sound_discard sound_effect_chorus sound_effect_compressor sound_effect_echo sound_effect_equalizer sound_effect_flanger sound_effect_gargle sound_effect_reverb sound_effect_set sound_exists sound_fade sound_get_kind sound_get_name sound_get_preload sound_global_volume sound_isplaying sound_loop sound_name sound_pan sound_play sound_replace sound_restore sound_set_search_directory sound_stop sound_stop_all sound_volume sprite_add sprite_add_from_screen sprite_add_from_surface sprite_assign sprite_create_from_screen sprite_create_from_surface sprite_delete sprite_duplicate sprite_exists sprite_get_bbox_bottom sprite_get_bbox_left sprite_get_bbox_mode sprite_get_bbox_right sprite_get_bbox_top sprite_get_height sprite_get_name sprite_get_number sprite_get_precise sprite_get_preload sprite_get_smooth sprite_get_texture sprite_get_transparent sprite_get_width sprite_get_xoffset sprite_get_yoffset sprite_merge sprite_name sprite_replace sprite_set_alpha_from_sprite sprite_set_bbox sprite_set_bbox_mode sprite_set_offset sprite_set_precise sqr sqrt string string_char_at string_copy string_count string_delete string_digits string_format string_height string_height_ext string_insert string_length string_letters string_lettersdigits string_lower string_pos string_repeat string_replace string_replace_all string_upper string_width string_width_ext surface_copy surface_copy_part surface_create surface_exists surface_free surface_get_height surface_get_texture surface_get_width surface_getpixel surface_reset_target surface_save surface_save_part surface_set_target tan texture_exists texture_get_height texture_get_width texture_preload texture_set_blending texture_set_interpolation texture_set_priority texture_set_repeat tile_add tile_delete tile_delete_at tile_exists tile_find tile_get_alpha tile_get_background tile_get_blend tile_get_depth tile_get_height tile_get_left tile_get_top tile_get_visible tile_get_width tile_get_x tile_get_xscale tile_get_y tile_get_yscale tile_layer_delete tile_layer_delete_at tile_layer_depth tile_layer_find tile_layer_hide tile_layer_shift tile_layer_show tile_set_alpha tile_set_background tile_set_blend tile_set_depth tile_set_position tile_set_region tile_set_scale tile_set_visible timeline_add timeline_delete timeline_exists timeline_get_name timeline_moment_add timeline_moment_clear timeline_name variable_global_array2_get variable_global_array2_set variable_global_array_get variable_global_array_set variable_global_exists variable_global_get variable_global_set variable_local_array2_get variable_local_array2_set variable_local_array_get variable_local_array_set variable_local_exists variable_local_get variable_local_set window_center window_default window_get_caption window_get_color window_get_cursor window_get_fullscreen window_get_height window_get_region_height window_get_region_scale window_get_region_width window_get_showborder window_get_showicons window_get_sizeable window_get_stayontop window_get_visible window_get_width window_get_x window_get_y window_handle window_mouse_get_x window_mouse_get_y window_mouse_set window_set_caption window_set_color window_set_cursor window_set_fullscreen window_set_position window_set_rectangle window_set_region_scale window_set_region_size 192
- 193. window_set_showborder window_set_showicons window_set_size window_set_sizeable window_set_stayontop window_set_visible window_view_mouse_get_x window_view_mouse_get_y window_view_mouse_set window_views_mouse_get_x window_views_mouse_get_y window_views_mouse_set Terminemos con las Constantes all bm_add bm_dest_alpha bm_dest_color bm_inv_dest_alpha bm_inv_dest_color bm_inv_src_alpha bm_inv_src_color bm_max bm_normal bm_one bm_src_alpha bm_src_alpha_sat bm_src_color bm_subtract bm_zero c_aqua c_black c_blue c_dkgray c_fuchsia c_gray c_green c_lime c_ltgray c_maroon c_navy c_olive c_purple c_red c_silver c_teal c_white c_yellow cr_appstart cr_arrow cr_arrrow cr_beam cr_cross cr_default cr_drag cr_handpoint cr_help cr_hourglass cr_hsplit cr_multidrag cr_no cr_nodrop cr_none cr_size_all cr_size_nesw cr_size_ns cr_size_nwse cr_size_we cr_sqlwait cr_uparrow cr_vsplit dll_cdecl dll_stdcall ef_cloud ef_ellipse ef_explosion ef_firework ef_flare ef_rain ef_ring ef_smoke ef_smokeup ef_snow ef_spark ef_star ev_alarm ev_animation_end ev_boundary ev_collision ev_create ev_destroy ev_draw ev_end_of_path ev_game_end ev_game_start ev_global_left_button ev_global_left_press ev_global_left_release ev_global_middle_button ev_global_middle_press ev_global_middle_release ev_global_press ev_global_release ev_global_right_button ev_global_right_press ev_global_right_release ev_joystick1_button1 ev_joystick1_button2 ev_joystick1_button3 ev_joystick1_button4 ev_joystick1_button5 ev_joystick1_button6 ev_joystick1_button7 ev_joystick1_button8 ev_joystick1_down ev_joystick1_left ev_joystick1_right ev_joystick1_up ev_joystick2_button1 ev_joystick2_button2 ev_joystick2_button3 ev_joystick2_button4 ev_joystick2_button5 ev_joystick2_button6 ev_joystick2_button7 ev_joystick2_button8 ev_joystick2_down ev_joystick2_left ev_joystick2_right ev_joystick2_up ev_keyboard ev_keypress ev_keyrelease ev_left_button ev_left_press ev_left_release ev_middle_button ev_middle_press ev_middle_release ev_mouse ev_mouse_enter ev_mouse_leave ev_mouse_wheel_down ev_mouse_wheel_up ev_no_button ev_no_more_health ev_no_more_lives ev_other ev_outside ev_right_button ev_right_press ev_right_release ev_room_end ev_room_start ev_step ev_step_begin ev_step_end ev_step_normal ev_user0 ev_user1 ev_user2 ev_user3 ev_user4 ev_user5 ev_user6 ev_user7 ev_user8 ev_user9 ev_user10 ev_user11 ev_user12 ev_user13 ev_user14 ev_user15 fa_archive fa_bottom fa_center fa_directory fa_hidden fa_left fa_middle fa_readonly fa_right fa_sysfile fa_top fa_volumeid false global local mb_any mb_left 193
- 194. mb_middle mb_none mb_right noone other pi pr_linelist pr_linestrip pr_pointlist pr_trianglefan pr_trianglelist pr_trianglestrip ps_change_all ps_change_motion ps_change_shape ps_deflect_horizontal ps_deflect_vertical ps_distr_gaussian ps_distr_linear ps_force_constant ps_force_linear ps_force_quadratic ps_shape_diamond ps_shape_ellipse ps_shape_line ps_shape_rectangle pt_shape_circle pt_shape_cloud pt_shape_disk pt_shape_explosion pt_shape_flare pt_shape_line pt_shape_pixel pt_shape_ring pt_shape_smoke pt_shape_snow pt_shape_spark pt_shape_sphere pt_shape_square pt_shape_star se_chorus se_compressor se_echo se_equalizer se_flanger se_gargle se_none se_reverb self true ty_real ty_string vk_add vk_alt vk_anykey vk_backspace vk_control vk_decimal vk_delete vk_di vide vk_down vk_end vk_enter vk_escape vk_f1 vk_f2 vk_f3 vk_f4 vk_f5 vk_f6 vk_f7 vk_f8 vk_f9 vk_f10 vk_f11 vk_f12 vk_home vk_insert vk_lalt vk_lcontrol vk_left vk_lshift vk_multiply vk_nokey vk_numpad0 vk_numpad1 vk_numpad2 vk_numpad3 vk_numpad4 vk_numpad5 vk_numpad6 vk_numpad7 vk_numpad8 vk_numpad9 vk_pagedown vk_pageup vk_pause vk_printscreen vk_ralt vk_rcontrol vk_return vk_right vk_rshift vk_shift vk_space vk_subtract vk_tab vk_up 194